Merge branch 'master' of github.com:cappuccino/cappuccino

AppKit/CPWindow/CPWindow.j

@@ -426,6 +426,7 @@ CPTexturedBackgroundWindowMask
 
         // Create a generic content view.
         [self setContentView:[[CPView alloc] initWithFrame:CGRectMakeZero()]];
+        [self setInitialFirstResponder:[self contentView]];
 
         _firstResponder = self;
 
@@ -950,6 +951,12 @@ CPTexturedBackgroundWindowMask
 
     var bounds = CGRectMake(0.0, 0.0, CGRectGetWidth(_frame), CGRectGetHeight(_frame));
 
+    // During init the initial first responder is set to the contentView
+    // if it hasn't changed in the mean time we need to update that reference
+    // to the new contentView
+    if ([self initialFirstResponder] === _contentView)
+        [self setInitialFirstResponder:aView];
+
     _contentView = aView;
     [_contentView setFrame:[self contentRectForFrameRect:bounds]];
 
@@ -1274,17 +1281,17 @@ CPTexturedBackgroundWindowMask
 
 - (BOOL)acceptsFirstResponder
 {
-    return YES;
+    return NO;
 }
 
-- (id)initialFirstResponder
+- (CPView)initialFirstResponder
 {
     return _initialFirstResponder;
 }
 
-- (void)setInitialFirstResponder:(id)aResponder
+- (void)setInitialFirstResponder:(CPView)aView
 {
-    _initialFirstResponder = aResponder;
+    _initialFirstResponder = aView;
 }
 
 /*!
@@ -2487,30 +2494,70 @@ CPTexturedBackgroundWindowMask
 
 - (void)selectNextKeyView:(id)sender
 {
+    if (_keyViewLoopIsDirty && [self autorecalculatesKeyViewLoop])
+        [self recalculateKeyViewLoop];
+
+    var nextValidKeyView = nil;
+
     if ([_firstResponder isKindOfClass:[CPView class]])
-        [self selectKeyViewFollowingView:_firstResponder];
+        nextValidKeyView = [_firstResponder nextValidKeyView];
+
+    if (!nextValidKeyView)
+    {
+        var initialFirstResponder = [self initialFirstResponder];
+
+        if ([initialFirstResponder acceptsFirstResponder])
+            nextValidKeyView = initialFirstResponder;
+        else
+            nextValidKeyView = [initialFirstResponder nextValidKeyView];
+    }
+
+    [self makeFirstResponder:nextValidKeyView];
 }
 
 - (void)selectPreviousKeyView:(id)sender
 {
+    if (_keyViewLoopIsDirty && [self autorecalculatesKeyViewLoop])
+        [self recalculateKeyViewLoop];
+
+    var previousValidKeyView = nil;
+
     if ([_firstResponder isKindOfClass:[CPView class]])
-        [self selectKeyViewPrecedingView:_firstResponder];
+        previousValidKeyView = [_firstResponder previousValidKeyView];
+
+    if (!previousValidKeyView)
+    {
+        var initialFirstResponder = [self initialFirstResponder];
+
+        if ([initialFirstResponder acceptsFirstResponder])
+            previousValidKeyView = initialFirstResponder;
+        else
+            previousValidKeyView = [initialFirstResponder previousValidKeyView];
+    }
+
+    [self makeFirstResponder:previousValidKeyView];
 }
 
 - (void)selectKeyViewFollowingView:(CPView)aView
 {
-    if (_keyViewLoopIsDirty)
+    if (_keyViewLoopIsDirty && [self autorecalculatesKeyViewLoop])
         [self recalculateKeyViewLoop];
 
-    [self makeFirstResponder:[aView nextValidKeyView]];
+    var nextValidKeyView = [aView nextValidKeyView];
+
+    if ([nextValidKeyView isKindOfClass:[CPView class]])
+        [self makeFirstResponder:nextValidKeyView];
 }
 
 - (void)selectKeyViewPrecedingView:(CPView)aView
 {
-    if (_keyViewLoopIsDirty)
+    if (_keyViewLoopIsDirty && [self autorecalculatesKeyViewLoop])
         [self recalculateKeyViewLoop];
 
-    [self makeFirstResponder:[aView previousValidKeyView]];
+    var previousValidKeyView = [aView previousValidKeyView];
+
+    if ([previousValidKeyView isKindOfClass:[CPView class]])
+        [self makeFirstResponder:previousValidKeyView];
 }
 
 /*!
@@ -2598,9 +2645,11 @@ CPTexturedBackgroundWindowMask
 
 var allViews = function(aWindow)
 {
-    var views = [[aWindow contentView] subviews],
-        index = 0;
+    var views = [CPArray arrayWithObject:[aWindow contentView]];
 
+    [views addObjectsFromArray:[[aWindow contentView] subviews]];
+
+    var index = 0;
     for (; index < views.length; ++index)
         views = views.concat([views[index] subviews]);
 

Foundation/CPArray+KVO.j

@@ -131,7 +131,7 @@
 
     _replaceManySEL = sel_getName(@"replace" + capitalizedKey + "AtIndexes:with" + capitalizedKey + ":");
     if ([_proxyObject respondsToSelector:_replaceManySEL])
-        _replace = [_proxyObject methodForSelector:_replaceManySEL];
+        _replaceMany = [_proxyObject methodForSelector:_replaceManySEL];
 
     _objectAtIndexSEL = sel_getName(@"objectIn" + capitalizedKey + "AtIndex:");
     if ([_proxyObject respondsToSelector:_objectAtIndexSEL])
@@ -233,10 +233,25 @@
 
 - (id)objectAtIndex:(unsigned)anIndex
 {
-    if (_objectAtIndex)
-        return _objectAtIndex(_proxyObject, _objectAtIndexSEL, anIndex);
+    return [[self objectsAtIndexes:[CPIndexSet indexSetWithIndex:anIndex]] firstObject];
+}
 
-    return [[self _representedObject] objectAtIndex:anIndex];
+- (CPArray)objectsAtIndexes:(CPIndexSet)theIndexes
+{
+    if (_objectsAtIndexes)
+        return _objectsAtIndexes(_proxyObject, _objectsAtIndexesSEL, theIndexes);
+    if (_objectAtIndex)
+    {
+        var index = CPNotFound,
+            objects = [];
+
+        while ((index = [theIndexes indexGreaterThanIndex:index]) !== CPNotFound)
+            objects.push(_objectAtIndex(_proxyObject, _objectAtIndexSEL, index));
+
+        return objects;
+    }
+
+    return [[self _representedObject] objectsAtIndexes:theIndexes];
 }
 
 - (void)addObject:(id)anObject
@@ -288,37 +303,111 @@
     [self removeObject:anObject inRange:CPMakeRange(0, [self count])];
 }
 
-- (void)removeLastObject
+- (void)removeObjectsInArray:(CPArray)theObjects
+{
+    if (_removeMany)
+    {
+        var indexes = [CPIndexSet indexSet],
+            index = [theObjects count];
+
+        while (index--)
+            [indexes addIndex:[self indexOfObject:[theObjects objectAtIndex:index]]];
+
+        _removeMany(_proxyObject, _removeManySEL, indexes);
+    }
+    else if (_remove)
+    {
+        var index = [theObjects count];
+        while (index--)
+            _remove(_proxyObject, _removeSEL, [self indexOfObject:[theObjects objectAtIndex:index]]);
+    }
+    else
+    {
+        var target = [[self _representedObject] copy];
+        [target removeObjectsInArray:theObjects];
+        [self _setRepresentedObject:target];
+    }
+}
+
+- (void)removeObject:(id)theObject inRange:(CPRange)theRange
 {
     if (_remove)
-        return _remove(_proxyObject, _removeSEL, [self count] - 1);
+        _remove(_proxyObject, _removeSEL, [self indexOfObject:theObject inRange:theRange]);
+    else if (_removeMany)
+    {
+        var index = [self indexOfObject:theObject inRange:theRange];
+        _removeMany(_proxyObject, _removeManySEL, [CPIndexSet indexSetWithIndex:index]);
+    }
+    else
+    {
+        var index;
 
-    var target = [[self _representedObject] copy];
+        while ((index = [self indexOfObject:theObject inRange:theRange]) !== CPNotFound)
+        {
+            [self removeObjectAtIndex:index];
+            theRange = CPIntersectionRange(CPMakeRange(index, length - index), theRange);
+        }
+    }
+}
 
-    [target removeLastObject];
-    [self _setRepresentedObject:target];
+- (void)removeLastObject
+{
+    [self removeObjectsAtIndexes:[CPIndexSet indexSetWithIndex:[self count] - 1]];
 }
 
 - (void)removeObjectAtIndex:(unsigned)anIndex
 {
-    if (_remove)
-        return _remove(_proxyObject, _removeSEL, anIndex);
+    [self removeObjectsAtIndexes:[CPIndexSet indexSetWithIndex:anIndex]];
+}
 
-    var target = [[self _representedObject] copy];
+- (void)removeObjectsAtIndexes:(CPIndexSet)theIndexes
+{
+    if (_removeMany)
+        _removeMany(_proxyObject, _removeManySEL, theIndexes);
+    else if (_remove)
+    {
+        var index = [theIndexes lastIndex];
 
-    [target removeObjectAtIndex:anIndex];
-    [self _setRepresentedObject:target];
+        while (index !== CPNotFound)
+        {
+            _remove(_proxyObject, _removeSEL, index)
+            index = [theIndexes indexLessThanIndex:index];
+        }
+    }
+    else
+    {
+        var target = [[self _representedObject] copy];
+        [target removeObjectsAtIndexes:theIndexes];
+        [self _setRepresentedObject:target];
+    }
 }
 
 - (void)replaceObjectAtIndex:(unsigned)anIndex withObject:(id)anObject
 {
-    if (_replace)
-        return _replace(_proxyObject, _replaceSEL, anIndex, anObject);
+    [self replaceObjectsAtIndexes:[CPIndexSet indexSetWithIndex:anIndex] withObjects:[anObject]]
+}
 
-    var target = [[self _representedObject] copy];
+- (void)replaceObjectsAtIndexes:(CPIndexSet)theIndexes withObjects:(CPArray)theObjects
+{
+    if (_replaceMany)
+        return _replaceMany(_proxyObject, _replaceManySEL, theIndexes, theObjects);
+    else if (_replace)
+    {
+        var i = 0,
+            index = [theIndexes firstIndex];
 
-    [target replaceObjectAtIndex:anIndex withObject:anObject];
-    [self _setRepresentedObject:target];
+        while (index !== CPNotFound)
+        {
+            _replace(_proxyObject, _replaceSEL, index, [theObjects objectAtIndex:i++]);
+            index = [theIndexes indexGreaterThanIndex:index];
+        }
+    }
+    else
+    {
+        var target = [[self _representedObject] copy];
+        [target replaceObjectsAtIndexes:theIndexes withObjects:theObjects];
+        [self _setRepresentedObject:target];
+    }
 }
 
 @end

Jakefile

@@ -160,6 +160,10 @@ function generateDocs(/* boolean */ noFrame)
         rm_rf($DOCUMENTATION_BUILD);
         mv("debug.txt", FILE.join("Documentation", "debug.txt"));
         mv("Documentation", $DOCUMENTATION_BUILD);
+
+        // There is a bug in doxygen 1.7.x preventing loading correctly the custom CSS
+        // So let's do it manually
+        cp(FILE.join(documentationDir, "doxygen.css"), FILE.join($DOCUMENTATION_BUILD, "html", "doxygen.css"));
     }
 }
 

Tests/AppKit/CPWindowTest.j

@@ -5,15 +5,108 @@
 
 @implementation CPWindowTest : OJTestCase
 {
-    CPWindow theWindow;
+    CPWindow                _window @accessors(property=window);
 }
 
--(void)testCanAllocWindow
+- (void)setUp
 {
-    theWindow = [[CPWindow alloc] initWithContentRect:CGRectMake(0,0,200,150) 
-                                            styleMask:CPWindowNotSizable];
+    _window = [[CPWindow alloc] initWithContentRect:CGRectMake(0.0, 0.0, 1024.0, 768.0)
+                                          styleMask:CPWindowNotSizable];
+}
 
-    [self assertTrue:!!theWindow];
+- (void)testCanAllocWindow
+{
+    [self assertTrue:!![self window]];
+}
+
+- (void)testThatContentViewIsInitialFirstResponder
+{
+    var contentView = [[self window] contentView];
+    [self assert:contentView
+          equals:[[self window] initialFirstResponder]
+         message:@"The window's content view must be the initial first responder"];
+}
+
+- (void)testKeyViewLoop
+{
+    var contentView = [[self window] contentView],
+        textField = [CPTextField textFieldWithStringValue:@"" placeholder:@"" width:100.0];
+
+    [textField setFrame:CGRectMake(100.0, 100.0, 100.0, 26.0)];
+    [contentView addSubview:textField];
+    [[self window] recalculateKeyViewLoop];
+
+    var nextTextField = [CPTextField textFieldWithStringValue:@"" placeholder:@"" width:100];
+    [nextTextField setFrame:CGRectMake(100.0, 200.0, 100.0, 26.0)];
+    [contentView addSubview:nextTextField];
+    [[self window] recalculateKeyViewLoop];
+
+    // Test nextKeyView
+    [self assert:textField
+          equals:[contentView nextKeyView]
+         message:@"textField should be the next key view of contentView"];
+
+    [self assert:nextTextField
+          equals:[textField nextKeyView]
+         message:@"nextTextField should be the next key view of textField"];
+
+    [self assert:contentView
+          equals:[nextTextField nextKeyView]
+         message:@"contentView should be the next key view of nextTextField"];
+
+    // Test previousKeyView
+    [self assert:contentView
+          equals:[textField previousKeyView]
+         message:@"contentView should be the previous key view of textField"];
+
+    [self assert:textField
+          equals:[nextTextField previousKeyView]
+         message:@"textField should be the previous key view of nextTextField"];
+
+    [self assert:nextTextField
+          equals:[contentView previousKeyView]
+         message:@"nextTextField should be the previous key view of contentView"];
+}
+
+- (void)testValiKeyViewLoop
+{
+    var contentView = [[self window] contentView],
+        textField = [CPTextField textFieldWithStringValue:@"" placeholder:@"" width:100.0];
+
+    [textField setFrame:CGRectMake(100.0, 100.0, 100.0, 26.0)];
+    [contentView addSubview:textField];
+    [[self window] recalculateKeyViewLoop];
+
+    var nextTextField = [CPTextField textFieldWithStringValue:@"" placeholder:@"" width:100];
+    [nextTextField setFrame:CGRectMake(100.0, 200.0, 100.0, 26.0)];
+    [contentView addSubview:nextTextField];
+    [[self window] recalculateKeyViewLoop];
+
+    // Test nextValidKeyView
+    [self assert:textField
+          equals:[contentView nextValidKeyView]
+         message:@"textField should be the next valid key view of contentView"];
+
+    [self assert:nextTextField
+          equals:[textField nextValidKeyView]
+         message:@"nextTextField should be the next valid key view of textField"];
+
+    [self assert:textField
+          equals:[nextTextField nextValidKeyView]
+         message:@"textField should be the next key valid view of nextTextField"];
+
+    // Test previousValidKeyView
+    [self assert:nextTextField
+          equals:[textField previousValidKeyView]
+         message:@"nextTextField should be the previous valid key view of textField"];
+
+    [self assert:textField
+          equals:[nextTextField previousValidKeyView]
+         message:@"textField should be the previous key valid view of nextTextField"];
+
+    [self assert:nextTextField
+          equals:[contentView previousValidKeyView]
+         message:@"nextTextField should be the previous valid key view of contentView"];
 }
 
 @end

Tests/Foundation/CPKVCArrayTest.j

@@ -0,0 +1,396 @@
+var COUNTER;
+
+@implementation CPKVCArrayTest : OJTestCase
+{
+    TestObject                          _object @accessors(property=object);
+    ImplementedTestObject               _implementedObject @accessors(property=implementedObject);
+}
+
+- (void)setUp
+{
+    _object = [[TestObject alloc] init];
+    _implementedObject = [[ImplementedTestObject alloc] init];
+
+    COUNTER = 0;
+}
+
+- (void)_patchSelector:(SEL)theSelector
+{
+    var method_dtable = [[self object] class].method_dtable,
+        method_list = [[self object] class].method_list,
+        selectorsToRemove = [@selector(countOfValues), @selector(objectInValuesAtIndex),
+                                @selector(objectInValuesAtIndex:), @selector(valuesAtIndexes:),
+                                @selector(insertObject:inValuesAtIndex:), @selector(insertValues:atIndexes:),
+                                @selector(removeObjectFromValuesAtIndex:), @selector(removeValuesAtIndexes:),
+                                @selector(removeObjectFromValuesAtIndex:),
+                                @selector(replaceObjectInValuesAtIndex:withObject:),
+                                @selector(replaceValuesAtIndexes:withValues:)],
+        selectorIndex = [selectorsToRemove count];
+
+    while (selectorIndex--)
+    {
+        var selector = [selectorsToRemove objectAtIndex:selectorIndex],
+            implementation = method_dtable[selector];
+
+        if (!implementation)
+            continue;
+
+        delete method_dtable[selector]
+        [method_list removeObject:implementation];
+    }
+
+    var method = class_getInstanceMethod([[self implementedObject] class], theSelector),
+        implementation = method_getImplementation(method);
+
+    class_addMethod([[self object] class], theSelector, implementation);
+}
+
+- (void)testUsesCountOfKey
+{
+    [self _patchSelector:@selector(countOfValues)];
+
+    var count = [[[self object] mutableArrayValueForKey:@"values"] count];
+
+    [self assert:10 equals:count message:@"countOfValues should return 10"];
+    [self assert:1 equals:COUNTER message:@"countOfValues should have been called once"]
+}
+
+- (void)testObjectAtIndexUsesObjectInKeyAtIndex
+{
+    [self _patchSelector:@selector(objectInValuesAtIndex:)];
+
+    var values = [[self object] mutableArrayValueForKey:@"values"],
+        object = [values objectAtIndex:0];
+
+    [self assert:0 equals:object]
+    [self assert:1 equals:COUNTER message:@"objectInValuesAtIndex: should have been called once"];
+}
+
+- (void)testObjectsAtIndexesUsesObjectInKeyAtIndex
+{
+    [self _patchSelector:@selector(objectInValuesAtIndex:)];
+
+    var values = [[self object] mutableArrayValueForKey:@"values"],
+        objects = [values objectsAtIndexes:[CPIndexSet indexSetWithIndexesInRange:CPMakeRange(0, 2)]];
+
+    [self assert:[0, 1] equals:objects]
+    [self assert:2 equals:COUNTER message:@"objectInValuesAtIndex: should have been called once"];
+}
+
+- (void)testObjectAtIndexUsesKeyAtIndexes
+{
+    [self _patchSelector:@selector(valuesAtIndexes:)];
+
+    var values = [[self object] mutableArrayValueForKey:@"values"],
+        object = [values objectAtIndex:0];
+
+    [self assert:0 equals:object]
+    [self assert:1 equals:COUNTER message:@"valuesAtIndexes: should have been called once"];
+}
+
+- (void)testObjectsAtIndexesUsesKeyAtIndexes
+{
+    [self _patchSelector:@selector(valuesAtIndexes:)];
+
+    var values = [[self object] mutableArrayValueForKey:@"values"],
+        objects = [values objectsAtIndexes:[CPIndexSet indexSetWithIndexesInRange:CPMakeRange(0, 2)]];
+
+    [self assert:[0, 1] equals:objects]
+    [self assert:1 equals:COUNTER message:@"valuesAtIndexes: should have been called once"];
+}
+
+- (void)testInsertObjectAtIndexUsesInsertKeyAtIndex
+{
+    [self _patchSelector:@selector(insertObject:inValuesAtIndex:)];
+
+    [[[self object] mutableArrayValueForKey:@"values"] insertObject:11 atIndex:10];
+
+    [self assert:11 equals:[[[self object] values] objectAtIndex:10]];
+    [self assert:1 equals:COUNTER message:@"insertObject:inValuesAtIndex: should have been called once"];
+}
+
+- (void)testInsertObjectsAtIndexesUsesInsertKeyAtIndex
+{
+    [self _patchSelector:@selector(insertObject:inValuesAtIndex:)];
+
+    var indexes = [CPIndexSet indexSetWithIndexesInRange:CPMakeRange(10, 2)];
+    [[[self object] mutableArrayValueForKey:@"values"] insertObjects:[11, 12] atIndexes:indexes];
+
+    [self assert:[11, 12] equals:[[[self object] values] objectsAtIndexes:indexes]];
+    [self assert:2
+          equals:COUNTER
+         message:@"insertValues:atIndexes: should have been called once for each object"];
+}
+
+- (void)testInsertObjectAtIndexUsesInsertKeyAtIndexes
+{
+    [self _patchSelector:@selector(insertValues:atIndexes:)];
+
+    [[[self object] mutableArrayValueForKey:@"values"] insertObject:11 atIndex:10];
+
+    [self assert:11 equals:[[[self object] values] objectAtIndex:10]];
+    [self assert:1 equals:COUNTER message:@"insertValues:atIndexes: should have been called once"];
+}
+
+- (void)testInsertObjectsAtIndexesUsesInsertKeyAtIndexes
+{
+    [self _patchSelector:@selector(insertValues:atIndexes:)];
+
+    var indexes = [CPIndexSet indexSetWithIndexesInRange:CPMakeRange(10, 2)];
+    [[[self object] mutableArrayValueForKey:@"values"] insertObjects:[11, 12] atIndexes:indexes];
+
+    [self assert:[11, 12] equals:[[[self object] values] objectsAtIndexes:indexes]];
+    [self assert:1
+          equals:COUNTER
+         message:@"insertValues:atIndexes: should have been called once for each object"];
+}
+
+- (void)testRemoveObjectAtIndexUsesRemoveObjectFromKeyAtIndex
+{
+    [self _patchSelector:@selector(removeObjectFromValuesAtIndex:)];
+
+    [[[self object] mutableArrayValueForKey:@"values"] removeObjectAtIndex:0];
+
+    [self assert:[1, 2, 3, 4, 5, 6, 7, 8, 9] equals:[[self object] values]];
+    [self assert:1 equals:COUNTER message:@"removeObjectFromValuesAtIndex: should have been called once"];
+}
+
+- (void)testRemoveObjectAtIndexesUsesRemoveObjectFromKeyAtIndex
+{
+    [self _patchSelector:@selector(removeObjectFromValuesAtIndex:)];
+
+    var indexes = [CPIndexSet indexSetWithIndexesInRange:CPMakeRange(0, 2)];
+    [[[self object] mutableArrayValueForKey:@"values"] removeObjectsAtIndexes:indexes];
+
+    [self assert:[2, 3, 4, 5, 6, 7, 8, 9] equals:[[self object] values]];
+    [self assert:2 equals:COUNTER message:@"removeValuesAtIndex: should have been called once for each object"];
+}
+- (void)testRemoveObjectsAtIndexesUsesRemoveKeyAtIndex
+{
+    [self _patchSelector:@selector(removeValuesAtIndexes:)];
+
+    [[[self object] mutableArrayValueForKey:@"values"] removeObjectAtIndex:0];
+
+    [self assert:[1, 2, 3, 4, 5, 6, 7, 8, 9] equals:[[self object] values]];
+    [self assert:1
+          equals:COUNTER
+         message:@"removeValuesAtIndexes: should have been once for each object"];
+}
+
+- (void)testRemoveObjectsAtIndexesUsesRemoveKeyAtIndexes
+{
+    [self _patchSelector:@selector(removeValuesAtIndexes:)];
+
+    var indexes = [CPIndexSet indexSetWithIndexesInRange:CPMakeRange(3, 2)];
+    [[[self object] mutableArrayValueForKey:@"values"] removeObjectsAtIndexes:indexes];
+
+    [self assert:[0, 1, 2, 5, 6, 7, 8, 9] equals:[[self object] values]];
+    [self assert:1 equals:COUNTER message:@"removeValuesAtIndexes: should have been called once"];
+}
+
+- (void)testRemoveObjectUsesRemoveKeyAtIndex
+{
+    [self _patchSelector:@selector(removeObjectFromValuesAtIndex:)];
+
+    [[[self object] mutableArrayValueForKey:@"values"] removeObject:1];
+
+    [self assert:[0, 2, 3, 4, 5, 6, 7, 8, 9] equals:[[self object] values]];
+    [self assert:1 equals:COUNTER message:"removeObjectFromValuesAtIndex: should have been called once"]
+}
+
+- (void)testeRemoveObjectUsesRemoveKeyAtIndexes
+{
+    [self _patchSelector:@selector(removeValuesAtIndexes:)];
+
+    [[[self object] mutableArrayValueForKey:@"values"] removeObject:5];
+
+    [self assert:[0, 1, 2, 3, 4, 6, 7, 8, 9] equals:[[self object] values]];
+    [self assert:1 equals:COUNTER message:@"removeValuesAtIndexes: should have been called once"];
+}
+
+- (void)testRemoveObjectsInArrayUsesRemoveKeyAtIndex
+{
+    [self _patchSelector:@selector(removeObjectFromValuesAtIndex:)];
+
+    [[[self object] mutableArrayValueForKey:@"values"] removeObjectsInArray:[3, 6]];
+
+    [self assert:[0, 1, 2, 4, 5, 7, 8, 9] equals:[[self object] values]];
+    [self assert:2 equals:COUNTER message:"removeObjectFromValuesAtIndex: should have been called once"]
+}
+
+- (void)testRemoveObjectsInArrayUsesRemoveKeyAtIndexes
+{
+    [self _patchSelector:@selector(removeValuesAtIndexes:)];
+
+    [[[self object] mutableArrayValueForKey:@"values"] removeObjectsInArray:[0, 9]];
+
+    [self assert:[1, 2, 3, 4, 5, 6, 7, 8] equals:[[self object] values]];
+    [self assert:1 equals:COUNTER message:@"removeValuesAtIndexes: should have been called once"];
+}
+
+- (void)testRemoveLastObjectUsesRemoveKeyAtIndex
+{
+    [self _patchSelector:@selector(removeObjectFromValuesAtIndex:)];
+
+    [[[self object] mutableArrayValueForKey:@"values"] removeLastObject];
+
+    [self assert:[0, 1, 2, 3, 4, 5, 6, 7, 8] equals:[[self object] values]];
+    [self assert:1 equals:COUNTER message:"removeObjectFromValuesAtIndex: should have been called once"]
+}
+
+- (void)testRemoveLastObjectUsesRemoveKeyAtIndexes
+{
+    [self _patchSelector:@selector(removeValuesAtIndexes:)];
+
+    [[[self object] mutableArrayValueForKey:@"values"] removeLastObject];
+
+    [self assert:[0, 1, 2, 3, 4, 5, 6, 7, 8] equals:[[self object] values]];
+    [self assert:1 equals:COUNTER message:@"removeValuesAtIndexes: should have been called once"];
+}
+
+- (void)testReplaceObjectAtIndexWithObjectUsesReplaceObjectInKeyAtIndexWithObject
+{
+    [self _patchSelector:@selector(replaceObjectInValuesAtIndex:withObject:)];
+
+    [[[self object] mutableArrayValueForKey:@"values"] replaceObjectAtIndex:0 withObject:1];
+
+    [self assert:[1, 1, 2, 3, 4, 5, 6, 7, 8, 9] equals:[[self object] values]];
+    [self assert:1
+          equals:COUNTER
+         message:@"replaceObjectInValuesAtIndex:withObject: should have been called once"];
+}
+
+- (void)testReplaceObjectsAtIndexesWithObjectsUsesReplaceObjectInKeyAtIndexWithObject
+{
+    [self _patchSelector:@selector(replaceObjectInValuesAtIndex:withObject:)];
+
+    var indexes = [CPIndexSet indexSetWithIndexesInRange:CPMakeRange(5, 3)];
+    [[[self object] mutableArrayValueForKey:@"values"] replaceObjectsAtIndexes:indexes withObjects:[1, 2, 3]];
+
+    [self assert:[0, 1, 2, 3, 4, 1, 2, 3, 8, 9] equals:[[self object] values]];
+    [self assert:3
+          equals:COUNTER
+         message:@"replaceObjectInValuesAtIndex:withObject: should have been called once"];
+}
+
+- (void)testReplaceObjectAtIndexWithObjectUsesReplaceKeyAtIndexesWithKeys
+{
+    [self _patchSelector:@selector(replaceValuesAtIndexes:withValues:)];
+
+    [[[self object] mutableArrayValueForKey:@"values"] replaceObjectAtIndex:5 withObject:6];
+
+    [self assert:[0, 1, 2, 3, 4, 6, 6, 7, 8, 9] equals:[[self object] values]];
+    [self assert:1
+          equals:COUNTER
+         message:@"replaceObjectInValuesAtIndex:withObject: should have been called once"];
+}
+
+- (void)testReplaceObjectsAtIndexesWithObjectsUsesReplaceKeyAtIndexesWithKeys
+{
+    [self _patchSelector:@selector(replaceValuesAtIndexes:withValues:)];
+
+    var indexes = [CPIndexSet indexSetWithIndexesInRange:CPMakeRange(6, 2)];
+    [[[self object] mutableArrayValueForKey:@"values"] replaceObjectsAtIndexes:indexes withObjects:[7, 8]];
+
+    [self assert:[0, 1, 2, 3, 4, 5, 7, 8, 8, 9] equals:[[self object] values]];
+    [self assert:1
+          equals:COUNTER
+         message:@"replaceObjectInValuesAtIndexes:withValues: should have been called once"];
+}
+
+@end
+
+@implementation TestObject : CPObject
+{
+    CPArray                     _values @accessors(property=values);
+}
+
+- (id)init
+{
+    if (self = [super init])
+    {
+        _values = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+    }
+
+    return self;
+}
+
+@end
+
+@implementation ImplementedTestObject : TestObject
+{
+}
+
+- (int)countOfValues
+{
+    // CPLog.warn(@"countOfValues");
+
+    COUNTER += 1;
+    return [[self values] count];
+}
+
+- (id)objectInValuesAtIndex:(int)theIndex
+{
+    // CPLog.warn(@"objectInValuesAtIndex: %@", theIndex);
+
+    COUNTER += 1;
+    return [[self values] objectAtIndex:theIndex];
+}
+
+- (CPArray)valuesAtIndexes:(CPIndexSet)theIndexes
+{
+    // CPLog.warn(@"valuesAtIndexes: %@", theIndexes);
+
+    COUNTER += 1;
+    return [[self values] objectsAtIndexes:theIndexes];
+}
+
+- (void)insertObject:(id)theObject inValuesAtIndex:(int)theIndex
+{
+    // CPLog.warn(@"insertObject: %@ inValuesAtIndex: %@", theObject, theIndex);
+
+    COUNTER += 1;
+    [[self values] insertObject:theObject atIndex:theIndex];
+}
+
+- (void)insertValues:(CPArray)theObjects atIndexes:(CPIndexSet)theIndexes
+{
+    // CPLog.warn(@"insertValues: %@ atIndexes: %@", theObjects, theIndexes);
+
+    COUNTER += 1;
+    [[self values] insertObjects:theObjects atIndexes:theIndexes];
+}
+
+- (void)removeObjectFromValuesAtIndex:(int)theIndex
+{
+    // CPLog.warn(@"removeObjectFromValuesAtIndex: %@", theIndex);
+
+    COUNTER += 1;
+    [[self values] removeObjectAtIndex:theIndex];
+}
+
+- (void)removeValuesAtIndexes:(CPIndexSet)theIndexes
+{
+    // CPLog.warn(@"removeValuesAtIndexes: %@", theIndexes);
+
+    COUNTER += 1;
+    [[self values] removeObjectsAtIndexes:theIndexes];
+}
+
+- (void)replaceObjectInValuesAtIndex:(int)theIndex withObject:(id)theObject
+{
+    // CPLog.warn(@"replaceObjectInValuesAtIndex: %@ withObject: %@", theIndex, theObject);
+
+    COUNTER += 1;
+    [[self values] replaceObjectAtIndex:theIndex withObject:theObject];
+}
+
+- (void)replaceValuesAtIndexes:(CPIndexSet)theIndexes withValues:(id)theObjects
+{
+    // CPLog.warn(@"replaceValuesAtIndexes: %@ withValues: %@", theIndexes, theObjects);
+
+    COUNTER += 1;
+    [[self values] replaceObjectsAtIndexes:theIndexes withObjects:theObjects];
+}
+
+@end

Tools/Documentation/Cappuccino.doxygen

@@ -25,7 +25,7 @@ DOXYFILE_ENCODING      = UTF-8
 # The PROJECT_NAME tag is a single word (or a sequence of words surrounded
 # by quotes) that should identify the project.
 
-PROJECT_NAME           = "Cappuccino API"
+PROJECT_NAME           = " API"
 
 # The PROJECT_NUMBER tag can be used to enter a project or revision number.
 # This could be handy for archiving the generated documentation or
@@ -33,6 +33,8 @@ PROJECT_NAME           = "Cappuccino API"
 
 PROJECT_NUMBER         = 0.9.1
 
+PROJECT_LOGO             = ./Tools/Documentation/logo.png
+
 # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute)
 # base path where the generated documentation will be put.
 # If a relative path is entered, it will be relative to the location
@@ -845,7 +847,7 @@ HTML_FOOTER            =
 # the style sheet file to the HTML output directory, so don't put your own
 # stylesheet in the HTML output directory as well, or it will be erased!
 
-HTML_STYLESHEET        = ./Tools/Documentation/doxygen.css
+#HTML_STYLESHEET        = doxygen.css
 
 # The HTML_COLORSTYLE_HUE tag controls the color of the HTML output.
 # Doxygen will adjust the colors in the stylesheet and background images

Tools/xcodecapp-cocoa/Jakefile

@@ -1,10 +1,10 @@
 
 require("../../common.jake");
 
-var OS = require("os");
-var task = require("jake").task
-var stream = require("narwhal/term").stream;
-var applicationName = "xcodecapp-cocoa.app";
+var OS = require("os"),
+    task = require("jake").task,
+    stream = require("narwhal/term").stream,
+    applicationName = "xcodecapp-cocoa.app";
 
 task ("build", function()
 {
@@ -22,9 +22,7 @@ task ("build", function()
         cp_r(FILE.join("build", "Release", "xcodecapp-cocoa.app"), supportPath);
         FILE.chmod(FILE.join(supportPath, "Contents", "MacOS", "xcodecapp-cocoa"), 0755);
 
-        if (FILE.exists(installPath))
-            FILE.remove(installPath);
-        FILE.symlink(supportPath, installPath);
+        OS.system(["ln", "-sf", supportPath, installPath]);
     }
     else
     {