sproutcore 0.9.0

data/frameworks/sproutcore/tests/foundation/application.rhtml

@@ -0,0 +1,125 @@
+<% popup_menu_view :a_menu, :pane => 'menu', :class => 'menu' do %>
+  <%= menu_item_view :item_enabled_key_equiv_no_target, 
+    :outlet => true, 
+    :label => "", 
+    :action => "onAltShiftA",
+    :key_equivalent => 'alt_shift_a' 
+  %>
+  <%= menu_item_view :item_enabled_key_equiv_with_target, 
+    :outlet => true, 
+    :label => "", 
+    :action => "onAltShiftB",
+    :target => "SC.exampleController",
+    :key_equivalent => 'alt_shift_b' 
+  %>
+  <%= menu_item_view :item_disabled_key_equiv, 
+    :outlet => true, 
+    :label => "", 
+    :enabled => false, 
+    :action => "onAltShiftB",
+    :key_equivalent => 'alt_shift_b' 
+  %>
+<% end %>
+
+<% view :view_1 do %>
+  <% view :view_1_1, :outlet => true do %>
+    <% view :view_1_1_1, :outlet => true do %>
+    <% end %>
+  <% end %>
+  <% view :view_1_2, :outlet => true do %>
+    <% view :view_1_2_1, :outlet => true do %>
+    <% end %>
+  <% end %>
+<% end %>
+
+
+<% content_for('final') do %>
+<script>
+
+Test.context("SC.Application", {
+
+  "Should be instantiated and placed in SC.app on page load": function()
+  {
+    SC.app.kindOf(SC.Application).shouldEqual(true);
+  },
+  "SC.app keyPane should be set to SC.window by default": function()
+  {
+    var keyPane = SC.app.get('keyPane');
+    ( keyPane == SC.window ).shouldEqual(true);
+  },
+  "SC.app mainPane should be set to SC.window by default": function()
+  {
+    var mainPane = SC.app.get('mainPane');
+    ( mainPane == SC.window ).shouldEqual(true);
+  },
+  "Setting the keyPane shouldn't change the mainPane": function()
+  {
+    ( SC.app.get('mainPane') == SC.window ).shouldEqual(true);
+
+    var pane = SC.PaneView.viewFor(null);
+    SC.app.set('keyPane', pane);
+    ( SC.app.get('mainPane') == SC.window ).shouldEqual(true);
+  },
+
+  setup: function()
+  {
+  },
+  teardown: function()
+  {
+  }
+
+});
+
+
+
+Test.context("SC.Application's sendAction method", {
+
+  "Should not handle actions that are not strings": function()
+  {
+    SC.app.sendAction( null, null, null ).shouldEqual(false);
+    SC.app.sendAction( false, null, null ).shouldEqual(false);
+    SC.app.sendAction( {}, null, null ).shouldEqual(false);
+    SC.app.sendAction( function(){}, null, null ).shouldEqual(false);
+  },
+  "Should return boolean for whether an action is handled": function()
+  {
+    var leaf1 = SC.page.get('view1').view11.view111;
+        
+    leaf1.anActionThatReturnsNothing = this.anActionThatReturnsNothing;
+    leaf1.anActionThatReturnsTrue    = this.anActionThatReturnsTrue;
+    leaf1.anActionThatReturnsFalse   = this.anActionThatReturnsFalse;
+    leaf1.becomeFirstResponder();
+
+    SC.app.sendAction( "anActionThatReturnsNothing", leaf1, null ).shouldEqual(true);
+    SC.app.sendAction( "anActionThatReturnsTrue", leaf1, null ).shouldEqual(true);
+
+    SC.app.sendAction( "anActionThatReturnsFalse", leaf1, null ).shouldEqual(false);
+    SC.app.sendAction( "anActionThatDoesNotExist", leaf1, null ).shouldEqual(false);
+  },
+  "Should ...": function()
+  {
+    var leaf1 = SC.page.get('view1').view11.view111;
+    var leaf2 = SC.page.get('view1').view12.view121;
+    
+    leaf1.bubblingAction = this.anActionThatReturnsNothing;
+    leaf2.bubblingAction = this.anActionThatReturnsNothing;
+    
+    leaf1.becomeFirstResponder();
+  },
+
+  setup: function()
+  {
+    this.anActionThatReturnsNothing = function() { this.__action_called__ = true; };
+    this.anActionThatReturnsTrue    = function() { this.__action_called__ = true; return true; };
+    this.anActionThatReturnsFalse   = function() { this.__action_called__ = true; return false; };
+    SC.page.awake();
+  },
+  teardown: function()
+  {
+  }
+
+});
+
+
+</script>
+<% end %>

data/frameworks/sproutcore/tests/foundation/array.rhtml

@@ -0,0 +1,221 @@
+<% # ========================================================================
+   # Array Unit Test
+   # ========================================================================
+%>
+<% content_for('final') do %>
+
+<script>
+
+// This is a generic set of tests.  To apply these, create a new contact, and
+// call this function passing in a factory function to build your element.
+ArrayTests = function(factoryFunc) {
+  return {
+    
+    setup: function() {
+      this.a = factoryFunc() ;
+      
+      // this will record observed changes.
+      var that = this ;
+      this.observer = function(target, key, value) {
+        that.notified[key] = true ;
+        that.notifiedValue[key] = value ;
+      }.bind(this) ;
+      
+      this.resetObservers = function() {
+        this.notified = {} ;
+        this.notifiedValue = {} ;
+      } ;
+      
+      this.observe = function() {
+        var keys = $A(arguments) ;
+        var loc = keys.length ;
+        while(--loc >= 0) {
+          this.a.addObserver(keys[loc], this.observer) ;
+        }
+      };
+      
+      this.didNotify = function(key) {
+        return this.notified[key] == true ;
+      } ;
+      
+      this.resetObservers() ;
+    },
+    
+    "[].replace(0,0,'X') => ['X'] + notify": function() {
+      this.observe('[]') ;
+      this.a.replace(0,0,['X']) ;
+      
+      this.a.length.shouldEqual(1) ;
+      this.a.objectAt(0).shouldEqual('X') ;
+      this.didNotify('[]').shouldEqual(YES) ;
+    },
+    
+    "[A,B,C,D].replace(1,2,X) => [A,X,D] + notify": function() {
+      this.a.replace(0,0, $w('A B C D')) ;
+      this.observe('[]') ;
+      
+      this.a.replace(1,2,['X']) ;
+      
+      this.a.get('length').shouldEqual(3) ;
+      this.a.objectAt(0).shouldEqual('A') ;
+      this.a.objectAt(1).shouldEqual('X') ;
+      this.a.objectAt(2).shouldEqual('D') ;
+      this.didNotify("[]").shouldEqual(YES) ;
+    },
+    
+    "[A,B,C,D].replace(1,2,[X,Y]) => [A,X,Y,D] + notify": function() {
+      this.a.replace(0,0, $w('A B C D')) ;
+      this.observe('[]') ;
+      
+      this.a.replace(1,2, $w('X Y')) ;
+      
+      this.a.get('length').shouldEqual(4) ;
+      this.a.objectAt(0).shouldEqual('A') ;
+      this.a.objectAt(1).shouldEqual('X') ;
+      this.a.objectAt(2).shouldEqual('Y') ;
+      this.a.objectAt(3).shouldEqual('D') ;
+      this.didNotify("[]").shouldEqual(YES) ;
+    },
+
+    "[A,B].replace(1,0,[X,Y]) => [A,X,Y,B] + notify": function() {
+      this.a.replace(0,0, $w('A B')) ;
+      this.observe('[]') ;
+      
+      this.a.replace(1,0, $w('X Y')) ;
+      
+      this.a.get('length').shouldEqual(4) ;
+      this.a.objectAt(0).shouldEqual('A') ;
+      this.a.objectAt(1).shouldEqual('X') ;
+      this.a.objectAt(2).shouldEqual('Y') ;
+      this.a.objectAt(3).shouldEqual('B') ;
+      this.didNotify("[]").shouldEqual(YES) ;
+    },
+    
+    "[A,B,C,D].replace(2,2) => [A,B] + notify": function() {
+      this.a.replace(0,0, $w('A B C D')) ;
+      this.observe('[]') ;
+      
+      this.a.replace(2,2) ;
+      
+      this.a.get('length').shouldEqual(2) ;
+      this.a.objectAt(0).shouldEqual('A') ;
+      this.a.objectAt(1).shouldEqual('B') ;
+      this.didNotify("[]").shouldEqual(YES) ;
+    },
+    
+    "[].insertAt(0,X) => [X] + notify": function() {
+      this.observe('[]') ;
+      this.a.insertAt(0,['X']) ;
+      this.a.get('length').shouldEqual(1) ;
+      this.a.objectAt(0).shouldEqual('X') ;
+      this.didNotify("[]").shouldEqual(YES) ;
+    },
+    
+    "[].removeObject(obj) should remove regardless of index position": function()
+    {
+      // spec for bug in Rev:402 where removeObject was skipping index 0 when scanning the array
+      this.a.set('[]', $w('A B C'));
+      this.a.get('length').shouldEqual(3);
+
+      this.a.removeObject('C');
+      this.a.get('length').shouldEqual(2);
+      this.a.removeObject('B');
+      this.a.get('length').shouldEqual(1);
+      this.a.removeObject('A');
+      this.a.get('length').shouldEqual(0);
+    },
+
+    
+    "[].objectAt(0) => undefined": function()
+    {
+      this.a.get('length').shouldEqual(0);
+      (this.a.objectAt(0) === undefined).shouldEqual(YES);
+    },
+    "[A,B,C].objectAt(5) => undefined": function()
+    {
+      this.a.get('length').shouldEqual(0);
+      this.a.set('[]', $w('A B C')) ;
+      this.a.get('length').shouldEqual(3) ;
+      this.a.objectAt(0).shouldEqual('A');
+      (this.a.objectAt(5) === undefined).shouldEqual(YES);
+    },
+    
+    "[A,B,C].set('[]',[X,Y]) => [X,Y] + notify": function() {
+      this.a.replace(0,0, $w('A B C')) ;
+      this.observe('[]') ;
+      
+      this.a.set('[]', $w('X Y')) ;
+      
+      this.a.get('length').shouldEqual(2) ;
+      this.a.objectAt(0).shouldEqual('X') ;
+      this.a.objectAt(1).shouldEqual('Y') ;
+      this.didNotify('[]').shouldEqual(YES) ;
+    },
+    
+    "[A,B,C] should be Enumerable": function() {
+      this.a.replace(0, 0, $w('A B C')) ;
+      
+      var cnt = 0 ;
+      var items = [] ;
+      this.a.each(function( item, idx ) {
+        items.push(item) ;
+        cnt++ ;
+      }) ;
+      
+      items[0].shouldEqual('A') ;
+      items[1].shouldEqual('B') ;
+      items[2].shouldEqual('C') ;
+      cnt.shouldEqual(this.a.get('length')) ;
+    },
+    
+    "ary.isEqual() should return true when array contents match": function() {
+      this.a.replace(0,0, $w('A B C')) ;
+      
+      var ary = $w('A B C') ; // test against a different object.
+      this.a.isEqual(ary).shouldEqual(true) ;
+      
+      ary = $w('A B') ;
+      this.a.isEqual(ary).shouldEqual(false) ;
+      
+      ary = $w('X Y Z') ;
+      this.a.isEqual(ary).shouldEqual(false) ;
+      
+      this.a.isEqual(this.a).shouldEqual(true) ;
+    }
+  } ;
+} ;
+
+// Test the SproutCore Array interface on native arrays.
+Test.context("SC.Array", ArrayTests(function() { return []; })) ;
+
+// Test the SproutCore Array interface on a custom object.
+DummyArray = SC.Object.extend(SC.Array, {
+  
+  length: 0,
+  
+  content: null,
+  
+  replace: function(idx, amt, objects) {
+    if (!this.content) this.content = [] ;
+
+    this.beginPropertyChanges() ;
+    this.content.replace(idx,amt,objects) ;
+    
+    this.set('length', this.content.length) ;
+    this.arrayContentDidChange() ;
+    this.endPropertyChanges() ;
+  },
+  
+  objectAt: function(idx) {
+    if (!this.content) this.content = [] ;
+    return this.content[idx] ;
+  }
+}) ;
+
+Test.context("DummyArray", ArrayTests(function() { 
+  return DummyArray.create()  ;
+}));
+
+</script>
+
+<% end %>

data/frameworks/sproutcore/tests/foundation/object.rhtml

@@ -0,0 +1,69 @@
+<% content_for('final') do %>
+<script>
+
+Test.context("A new SC.Object instance", {
+  
+  setup: function()
+  {
+    this.obj = SC.Object.create({
+      foo: "bar",
+      total: 12345,
+      aMethodThatExists: function() {},
+      aMethodThatReturnsTrue: function() { return true; },
+      aMethodThatReturnsFoobar: function() { return "Foobar"; }
+    });
+  },
+  teardown: function()
+  {
+    delete this.obj;
+  },
+  
+  "Should identify it's methods using the 'respondsTo' method": function()
+  {
+    this.obj.respondsTo('aMethodThatExists').shouldEqual(true);
+    this.obj.respondsTo('aMethodThatDoesNotExist').shouldEqual(false);
+  },
+  "Should return false when asked to perform a method it does not have": function()
+  {
+    this.obj.tryToPerform('aMethodThatDoesNotExist').shouldEqual(false);
+  },
+  "Should pass back the return value of a method it was asked to perform": function()
+  {
+    this.obj.tryToPerform('aMethodThatReturnsTrue').shouldEqual(true);
+    this.obj.tryToPerform('aMethodThatReturnsFoobar').shouldEqual("Foobar");
+  },
+
+  "Should return it's properties when requested using SC.Object#get": function()
+  {
+    this.obj.get('foo').shouldEqual('bar');
+    this.obj.get('total').shouldEqual(12345);
+  },
+  "Should allow changing of those properties by calling SC.Object#set": function()
+  {
+    this.obj.get('foo').shouldEqual('bar');
+    this.obj.get('total').shouldEqual(12345);
+
+    this.obj.set( 'foo', 'Chunky Bacon' );
+    this.obj.set( 'total', 12 );
+
+    this.obj.get('foo').shouldEqual('Chunky Bacon');
+    this.obj.get('total').shouldEqual(12);
+  },
+  "Should only advertise changes once per request to SC.Object#didChangeFor": function()
+  {
+    this.obj.set( 'foo', 'Chunky Bacon' );
+    this.obj.didChangeFor( this, 'foo' ).shouldEqual(true);
+    this.obj.didChangeFor( this, 'foo' ).shouldEqual(false);
+  },
+  "Should advertise changes once per request to SC.Object#didChangeFor when setting property to NULL": function()
+  {
+    this.obj.set( 'foo', null );
+    this.obj.didChangeFor( this, 'foo' ).shouldEqual(true);
+    this.obj.didChangeFor( this, 'foo' ).shouldEqual(false);
+  }
+
+
+});
+
+</script>
+<% end %>

data/frameworks/sproutcore/tests/globals/window.rhtml

@@ -0,0 +1,45 @@
+<% content_for('final') do %>
+
+<script type="text/javascript" charset="utf-8">
+
+Test.context("SC.window event handlers", {
+
+  "Should stop events when handled": function()
+  {
+    var e = SC.Mock.KeyEvent.create({ type: 'keyup', keyCode: 65 });
+    SC.window.keyUp = function(e) { this.keyUpWasHandled = true; };
+    
+    SC.window._onkeyup(e).shouldEqual(false);
+    SC.window.keyUpWasHandled.shouldEqual(true);
+    e.stopped.shouldEqual(true);
+  },
+
+  "Should not stop events when handler sets the event's _stopWhenHandled property to false": function()
+  {
+    var e = SC.Mock.KeyEvent.create({ type: 'keyup', keyCode: 65 });
+    SC.window.keyUp = function(e) { e._stopWhenHandled = false; this.keyUpWasHandled = true; };
+    
+    SC.window._onkeyup(e).shouldEqual(true);
+    SC.window.keyUpWasHandled.shouldEqual(true);
+    e.stopped.shouldEqual(false);
+  },
+
+  "Should not stop events when the event's _stopWhenHandled property is false *before* being sent to the handler": function()
+  {
+    var e = SC.Mock.KeyEvent.create({ type: 'keyup', keyCode: 65, _stopWhenHandled: false });
+    SC.window.keyUp = function(e) { this.keyUpWasHandled = true; };
+    
+    SC.window._onkeyup(e).shouldEqual(true);
+    SC.window.keyUpWasHandled.shouldEqual(true);
+    e.stopped.shouldEqual(false);
+  },
+
+  setup: function()
+  {
+  }
+
+});
+
+</script>
+
+<% end %>

data/frameworks/sproutcore/tests/panes/pane.rhtml

@@ -0,0 +1,88 @@
+<% content_for('final') do %>
+<script>
+
+Test.context("A new SC.PaneView instance", {
+
+  "Should identify itself as a SC.Pane": function()
+  {
+    this.pane.get('isPane').shouldEqual(true);
+  },
+  "Should not have a pane of it's own": function()
+  {
+    (this.pane.get('pane') === null).shouldEqual(true);
+  },
+
+  "Should not be keyPane or mainPane": function()
+  {
+    this.pane.get('isKeyPane').shouldEqual(false);
+    this.pane.get('isMainPane').shouldEqual(false);
+  },
+  "Should allow itself to be keyPane or mainPane": function()
+  {
+    this.pane.get('canBecomeKeyPane').shouldEqual(true);
+    this.pane.get('canBecomeMainPane').shouldEqual(true);
+  },
+  "Should run callback methods when changing keyPane or mainPane status": function()
+  {
+    var otherPane = SC.PaneView.viewFor(null);
+
+    this.pane._didBecomeKeyPaneCalled   = 0;
+    this.pane._willResignKeyPaneCalled  = 0;
+    this.pane._didBecomeMainPaneCalled  = 0;
+    this.pane._willResignMainPaneCalled = 0;
+    
+    this.pane.didBecomeKeyPane   = function() { this._didBecomeKeyPaneCalled++;   };
+    this.pane.willResignKeyPane  = function() { this._willResignKeyPaneCalled++;  };
+    this.pane.didBecomeMainPane  = function() { this._didBecomeMainPaneCalled++;  };
+    this.pane.willResignMainPane = function() { this._willResignMainPaneCalled++; };
+
+    // making keyPane
+    this.pane._didBecomeKeyPaneCalled.shouldEqual(0);
+    this.pane.makeKeyPane();
+    this.pane._didBecomeKeyPaneCalled.shouldEqual(1);
+    this.pane.makeKeyPane();
+    this.pane._didBecomeKeyPaneCalled.shouldEqual(1);
+    // resigning keyPane
+    this.pane._willResignKeyPaneCalled.shouldEqual(0);
+    otherPane.makeKeyPane();
+    this.pane._willResignKeyPaneCalled.shouldEqual(1);
+    // making mainPane
+    this.pane._didBecomeMainPaneCalled.shouldEqual(0);
+    this.pane.makeMainPane();
+    this.pane._didBecomeMainPaneCalled.shouldEqual(1);
+    this.pane.makeMainPane();
+    this.pane._didBecomeMainPaneCalled.shouldEqual(1);
+    // resigning mainPane
+    this.pane._willResignMainPaneCalled.shouldEqual(0);
+    otherPane.makeMainPane();
+    this.pane._willResignMainPaneCalled.shouldEqual(1);
+  },
+
+  "Should have a null firstResponder": function()
+  {
+    (this.pane.get('firstResponder') === null).shouldEqual(true);
+  },
+  "Should have a null defaultResponder": function()
+  {
+    (this.pane.get('defaultResponder') === null).shouldEqual(true);
+  },
+  "Should flag a view as 'isFirstResponder' when setting the firstResponder property": function()
+  {
+    var view = SC.View.create();
+    view.get('isFirstResponder').shouldEqual(false);
+    this.pane.set('firstResponder', view);
+    view.get('isFirstResponder').shouldEqual(true);
+  },
+  
+  setup: function()
+  {
+    this.pane = SC.PaneView.viewFor(null);
+  },
+  teardown: function()
+  {
+    delete this.pane;
+  }
+});
+
+</script>
+<% end %>

data/frameworks/sproutcore/tests/views/collection.rhtml

@@ -0,0 +1,137 @@
+<% content_for('final') do %>
+<script>
+
+Test.context("A SC.CollectionView with it's content set to a SC.CollectionController", {
+  
+  "Should contain the same number of item views as it's controller has records": function()
+  {
+    testCollectionView.get('itemViews').length.shouldEqual(6);
+  },
+  "Should update it's item views as it's controller is updated": function()
+  {
+    testCollectionView.get('itemViews').length.shouldEqual(6);
+    SC.Store.addRecord( SC.Record.create({ guid: '1007', name: 'item seven' }) );
+    testCollectionView.get('itemViews').length.shouldEqual(7);
+  },
+  "Should scroll to the selected item": function()
+  {
+    testCollection.get('records').length.shouldEqual(6);
+    testCollectionView.get('rootElement').scrollTop.shouldEqual(0);
+    testCollectionView.scrollToItemRecord( testCollection.get('records').last() );
+    testCollectionView.get('rootElement').scrollTop.shouldEqual(30);
+  },
+  "Should not scroll to the selected item if it's already fully visible": function()
+  {
+    testCollection.get('records').length.shouldEqual(6);
+    testCollectionView.get('rootElement').scrollTop.shouldEqual(0);
+    testCollectionView.scrollToItemRecord( testCollection.get('records')[1] );
+    testCollectionView.get('rootElement').scrollTop.shouldEqual(0);
+  },
+  setup: function()
+  {
+    // create the view...
+    testCollectionView = SC.CollectionView.extend({
+      contentBinding: 'testController.arrangedObjects',
+      selectionBinding: 'testController.selection'
+    }).create();
+    SC.window.appendChild(testCollectionView);
+    
+    // create some item data...
+    [
+      { guid: '1001', name: 'item one' },
+      { guid: '1002', name: 'item two' },
+      { guid: '1003', name: 'item three' },
+      { guid: '1004', name: 'item four' },
+      { guid: '1005', name: 'item five' },
+      { guid: '1006', name: 'item six' }
+    ].each(function(o){ SC.Store.addRecord(SC.Record.create(o)); });
+    
+    // a collection to hold the items...
+    testCollection = SC.Record.collection();
+    testCollection.refresh();
+
+    // a controller for the collection...
+    testController = SC.CollectionController.create();
+    testController.set('content', testCollection);
+    
+    
+    // make the view scrollable.
+    var element = Element.extend(testCollectionView.get('rootElement'));
+    element.setStyle({ overflow: 'auto', width: '100px', height: '30px' });
+    // set the item heights to force the collection to scroll
+    element.childElements().each(function(child)
+    {
+      child.setStyle({ height: '10px' });
+    });
+  },
+  teardown: function()
+  {
+    // tell SC.Store to dump all the records... 
+    // otherwise, since SC.Store is shared across all tests (yuk!) we'll get shared fixtues
+    testCollection.get('records').each(function(r){ SC.Store.removeRecord(r); });
+
+    // remove the view from SC.window... again, no shared fixtures...
+    testCollectionView.removeFromParent();
+
+    delete testCollectionView;
+    delete testCollection;
+    delete testController;
+  }
+  
+});
+
+
+
+
+
+Test.context("A SC.CollectionView with it's content set to a SC.ArrayController",
+{
+  "Should contain the same number of item views as it's controller has records": function()
+  {
+    this.controller.get('length').shouldEqual(6);
+    this.view.get('itemViews').length.shouldEqual(6);
+  },
+  "Should update it's item views as it's controller is updated": function()
+  {
+    this.view.get('itemViews').length.shouldEqual(6);
+    this.controller.pushObject({ guid: '1007', name: 'item seven' });
+    this.view.get('itemViews').length.shouldEqual(7);
+    this.controller.popObject();
+    this.view.get('itemViews').length.shouldEqual(6);
+  },
+  setup: function()
+  {
+    // create the view...
+    this.view = SC.CollectionView.create();
+    SC.window.appendChild(this.view);
+    
+    // create some item data...
+    this.array = [
+      { guid: '1001', name: 'item one' },
+      { guid: '1002', name: 'item two' },
+      { guid: '1003', name: 'item three' },
+      { guid: '1004', name: 'item four' },
+      { guid: '1005', name: 'item five' },
+      { guid: '1006', name: 'item six' }
+    ];
+    
+    this.controller = SC.ArrayController.create();
+    this.controller.set('content', this.array);
+    this.view.set('content', this.controller);
+  },
+  teardown: function()
+  {
+    // remove the view from SC.window
+    this.view.removeFromParent();
+
+    delete this.view;
+    delete this.array;
+    delete this.controller;
+  }
+});
+
+
+
+
+</script>
+<% end %>