sproutcore 1.5.0.pre.3 → 1.5.0.pre.4

data/lib/frameworks/sproutcore/frameworks/{amber → core_foundation}/tests/views/pane/append_remove.js

@@ -10,17 +10,17 @@ htmlbody('<div id="appendtest"></div>');
 
 // ..........................................................
 // appendTo()
-// 
+//
 module("SC.Pane#appendTo");
 
-test("adding to document for first time", function() {
+test("adding to document for first time - appendTo(elem)", function() {
   var pane = SC.Pane.create();
   ok(!pane.get('layer'), 'precond - does not yet have layer');
   ok(!pane.get('isVisibleInWindow'), 'precond - isVisibleInWindow = NO');
-  
+
   var elem = Q$('body').get(0);
   ok(elem, 'precond - found element to add to');
-  
+
   // now add
   pane.appendTo(elem);
   var layer = pane.get('layer');
@@ -28,9 +28,82 @@ test("adding to document for first time", function() {
   equals(layer.parentNode, elem, 'layer should belong to parent');
   ok(pane.get('isVisibleInWindow'), 'isVisibleInWindow should  = YES');
   ok(pane.rootResponder, 'should have rootResponder');
-  
 });
 
+test("adding to document for first time - appendTo(string)", function() {
+  var pane = SC.Pane.create();
+  ok(!pane.get('layer'), 'precond - does not yet have layer');
+  ok(!pane.get('isVisibleInWindow'), 'precond - isVisibleInWindow = NO');
+
+  // now add
+  pane.appendTo("#appendtest");
+  var layer = pane.get('layer');
+  ok(layer, 'should create layer');
+  equals(layer.parentNode, jQuery("#appendtest")[0], 'layer should belong to parent');
+  ok(pane.get('isVisibleInWindow'), 'isVisibleInWindow should  = YES');
+  ok(pane.rootResponder, 'should have rootResponder');
+});
+
+test("adding to document for first time - appendTo(jquery)", function() {
+  var pane = SC.Pane.create();
+  ok(!pane.get('layer'), 'precond - does not yet have layer');
+  ok(!pane.get('isVisibleInWindow'), 'precond - isVisibleInWindow = NO');
+
+  // now add
+  pane.appendTo(jQuery("#appendtest"));
+  var layer = pane.get('layer');
+  ok(layer, 'should create layer');
+  equals(layer.parentNode, jQuery("#appendtest")[0], 'layer should belong to parent');
+  ok(pane.get('isVisibleInWindow'), 'isVisibleInWindow should  = YES');
+  ok(pane.rootResponder, 'should have rootResponder');
+});
+
+test("adding to document for first time - prependTo(elem)", function() {
+  var pane = SC.Pane.create();
+  ok(!pane.get('layer'), 'precond - does not yet have layer');
+  ok(!pane.get('isVisibleInWindow'), 'precond - isVisibleInWindow = NO');
+
+  var elem = Q$('body').get(0);
+  ok(elem, 'precond - found element to add to');
+
+  // now add
+  pane.prependTo(elem);
+  var layer = pane.get('layer');
+  ok(layer, 'should create layer');
+  equals(layer.parentNode, elem, 'layer should belong to parent');
+  ok(pane.get('isVisibleInWindow'), 'isVisibleInWindow should  = YES');
+  ok(pane.rootResponder, 'should have rootResponder');
+});
+
+test("adding to document for first time - prependTo(string)", function() {
+  var pane = SC.Pane.create();
+  ok(!pane.get('layer'), 'precond - does not yet have layer');
+  ok(!pane.get('isVisibleInWindow'), 'precond - isVisibleInWindow = NO');
+
+  // now add
+  pane.prependTo("#appendtest");
+  var layer = pane.get('layer');
+  ok(layer, 'should create layer');
+  equals(layer.parentNode, jQuery("#appendtest")[0], 'layer should belong to parent');
+  ok(pane.get('isVisibleInWindow'), 'isVisibleInWindow should  = YES');
+  ok(pane.rootResponder, 'should have rootResponder');
+});
+
+test("adding to document for first time - prependTo(jquery)", function() {
+  var pane = SC.Pane.create();
+  ok(!pane.get('layer'), 'precond - does not yet have layer');
+  ok(!pane.get('isVisibleInWindow'), 'precond - isVisibleInWindow = NO');
+
+  // now add
+  pane.prependTo(jQuery("#appendtest"));
+  var layer = pane.get('layer');
+  ok(layer, 'should create layer');
+  equals(layer.parentNode, jQuery("#appendtest")[0], 'layer should belong to parent');
+  ok(pane.get('isVisibleInWindow'), 'isVisibleInWindow should  = YES');
+  ok(pane.rootResponder, 'should have rootResponder');
+});
+
+
 test("adding a pane twice should have no effect", function() {
   var cnt = 0;
   var pane = SC.Pane.create();
@@ -39,7 +112,7 @@ test("adding a pane twice should have no effect", function() {
     cnt++;
     return this._tmp_paneDidAttach.apply(this, arguments);
   };
-  
+
   pane.append();
   pane.append();
   equals(cnt, 1, 'should only append once');
@@ -49,12 +122,12 @@ test("readding pane", function() {
   var pane = SC.Pane.create();
   var elem1 = Q$('body').get(0), elem2 = Q$('#appendtest').get(0);
   ok(elem1 && elem2, 'precond - has elem1 && elem2: elem1=%@ elem2=%@'.fmt(elem1, elem2));
-  
+
   pane.appendTo(elem1);
   var layer = pane.get('layer');
   ok(layer, 'has layer');
   equals(layer.parentNode, elem1, 'layer belongs to parent');
-  
+
   pane.appendTo(elem2);
   equals(layer.parentNode, elem2, 'layer moved to new parent');
   ok(pane.get('isVisibleInWindow'), 'isVisibleInWindow should  = YES');
@@ -65,7 +138,7 @@ test("adding/remove/adding pane", function() {
   var pane = SC.Pane.create();
   var elem1 = Q$('body').get(0), elem2 = Q$('#appendtest').get(0);
   ok(elem1 && elem2, 'precond - has elem1 && elem2');
-  
+
   pane.appendTo(elem1);
   var layer = pane.get('layer');
   ok(layer, 'has layer');
@@ -73,17 +146,33 @@ test("adding/remove/adding pane", function() {
   ok(pane.get('isVisibleInWindow'), 'isVisibleInWindow is YES before remove');
   pane.remove();
   ok(!pane.get('isVisibleInWindow'), 'isVisibleInWindow is NO');
-  
+
   pane.appendTo(elem2);
   layer = pane.get('layer');
   equals(layer.parentNode, elem2, 'layer moved to new parent');
   ok(pane.get('isVisibleInWindow'), 'isVisibleInWindow should  = YES');
   ok(pane.rootResponder, 'should have rootResponder');
 });
-  
+
+test("removeFromParent throws an exception", function() {
+  var pane, exceptionCaught = false;
+
+  try {
+    pane = SC.Pane.create();
+    pane.append();
+    pane.removeFromParent();
+  } catch(e) {
+    exceptionCaught = (e instanceof SC.Error);
+  } finally {
+    pane.remove();
+  }
+
+  ok(exceptionCaught, "trying to call removeFromParent on a pane throws an exception");
+});
+
 // ..........................................................
 // remove()
-// 
+//
 module("SC.Pane#remove");
 
 test("removes pane from DOM", function() {
@@ -94,7 +183,7 @@ test("removes pane from DOM", function() {
   pane.appendTo(elem);
   layer = pane.get('layer');
   ok(elem, 'precond - found element to add to');
-  
+
   pane.remove();
   ok(layer.parentNode !== elem, 'layer no longer belongs to parent');
   ok(!pane.get('isVisibleInWindow'), 'isVisibleInWindow is NO');
@@ -103,14 +192,14 @@ test("removes pane from DOM", function() {
 
 // ..........................................................
 // SPECIAL CASES
-// 
+//
 
 test("updates frame and clippingFrame when loading MainPane", function() {
-  
+
   // needs a fixed layout size to make sure the sizes stay constant
-  var pane = SC.MainPane.create(); 
+  var pane = SC.MainPane.create();
   var w = SC.RootResponder.responder.computeWindowSize().width;
-  
+
   // add the pane to the main window.  should resize the frames
   SC.run(function() {
     pane.append();
@@ -119,6 +208,6 @@ test("updates frame and clippingFrame when loading MainPane", function() {
   // should equal window size
   equals(pane.get('frame').width, w, 'frame width should have changed');
   equals(pane.get('clippingFrame').width, w, 'clippingFrame width should have changed');
-  
+
 });
 

data/lib/frameworks/sproutcore/frameworks/core_foundation/tests/views/pane/child_view.js

@@ -0,0 +1,20 @@
+module("SC.Pane - childViews");
+
+test("SC.Pane should not attempt to recompute visibility on child views that do not have visibility support", function() {
+  var pane = SC.Pane.create({
+    childViews: ['noVisibility'],
+
+    noVisibility: SC.CoreView
+  });
+
+  // tomdale insists on slowing down the tests with extra scope chain traversals
+  var errored = NO;
+
+  try {
+    pane.append();
+  } catch(e) {
+    errored = YES;
+  }
+
+  ok(!errored, "appending a pane with child views without visibility does not result in an error");
+});

data/lib/frameworks/sproutcore/frameworks/core_foundation/tests/views/template/checkbox_support.js

@@ -0,0 +1,32 @@
+(function() {
+  var checkboxView, pane;
+
+  module("Checkbox Support", {
+    setup: function() {
+      checkboxView = SC.TemplateView.create(SC.CheckboxSupport, {
+        template: SC.Handlebars.compile('<input type="checkbox">')
+      });
+
+      pane = SC.MainPane.create({
+        childViews: [checkboxView]
+      });
+      pane.append();
+    },
+
+    teardown: function() {
+      pane.remove();
+    }
+  });
+
+  test("value property mirrors input value", function() {
+    checkboxView.$('input').attr('checked', true);
+
+    equals(checkboxView.get('value'), true, "gets value property from DOM");
+
+    checkboxView.$('input').attr('checked', false);
+
+    checkboxView.set('value', true);
+    ok(checkboxView.$('input').attr("checked"), "sets value of DOM to value property");
+  });
+})();
+

data/lib/frameworks/sproutcore/frameworks/core_foundation/tests/views/template/text_field_support.js

@@ -0,0 +1,73 @@
+(function() {
+  var textFieldView, pane;
+
+  module("Text Field Support", {
+    setup: function() {
+      textFieldView = SC.TemplateView.create(SC.TextFieldSupport, {
+        template: SC.Handlebars.compile('<input type="text">')
+      });
+
+      pane = SC.MainPane.create({
+        childViews: [textFieldView]
+      });
+      pane.append();
+    },
+
+    teardown: function() {
+      pane.remove();
+    }
+  });
+
+  test("value property mirrors input value", function() {
+    textFieldView.$('input').val('foo bar');
+
+    equals(textFieldView.get('value'), 'foo bar', "gets value property from DOM");
+
+    textFieldView.set('value', "afterlife");
+    equals(textFieldView.$('input').val(), "afterlife", "sets value of DOM to value property");
+  });
+
+  test("listens for focus and blur events", function() {
+    var focusCalled = 0;
+    var blurCalled = 0;
+
+    textFieldView.focus = function() {
+      focusCalled++;
+    };
+    textFieldView.blur = function() {
+      blurCalled++;
+    };
+
+    equals(focusCalled+blurCalled, 0, "precond - no callbacks called yet");
+
+    textFieldView.$('input').focus();
+    equals(focusCalled, 1, "focus called after field receives focus");
+
+    textFieldView.$('input').blur();
+    equals(blurCalled, 1, "blur alled after field blurs");
+  });
+
+  test("calls correct method for key events", function() {
+    var insertNewlineCalled = 0;
+    var cancelCalled = 0;
+
+    textFieldView.insertNewline = function() {
+      insertNewlineCalled++;
+      return YES;
+    };
+    textFieldView.cancel = function() {
+      cancelCalled++;
+      return YES;
+    };
+
+    textFieldView.$('input').focus();
+    equals(insertNewlineCalled+cancelCalled, 0, "precond - no callbacks called yet");
+
+    SC.RootResponder.responder.keyup(new SC.Event({ type: 'keyup', keyCode: 13 }));
+    equals(insertNewlineCalled, 1, "calls insertNewline after hitting return");
+
+    SC.RootResponder.responder.keyup(new SC.Event({ type: 'keyup', keyCode: 27 }));
+    equals(cancelCalled, 1, "calls cancel after pressing escape key");
+
+  });
+})();

data/lib/frameworks/sproutcore/frameworks/core_foundation/tests/views/template_view/collection.js

@@ -0,0 +1,65 @@
+module("SC.TemplateCollectionView");
+
+test("creating a collection view works", function() {
+  var ExampleView = SC.TemplateView.extend({
+    tagName: 'li',
+    template: SC.Handlebars.compile('{{content/title}}')
+  });
+
+  var CollectionView = SC.TemplateCollectionView.extend({
+    content: [{title: 'Hello'}],
+    itemView: ExampleView
+  });
+
+  var collectionView = CollectionView.create();
+  collectionView.createLayer();
+
+  ok(collectionView.$('li').length === 1, "The child example view was rendered");
+});
+
+test("passing a block to the collection helper sets it as the template for example views", function() {
+  TemplateTests.CollectionTestView = SC.TemplateCollectionView.create({
+    content: ['foo', 'bar', 'baz']
+  });
+
+  var view = SC.TemplateView.create({
+    template: SC.Handlebars.compile('{{#collection "TemplateTests.CollectionTestView"}} <aside></aside> {{/collection}}')
+  });
+
+  view.createLayer();
+  equals(view.$('aside').length, 3, 'one aside element is created for each content item');
+});
+
+test("a block passed to a collection helper defaults to the content property of the context", function() {
+  TemplateTests.CollectionTestView = SC.TemplateCollectionView.create({
+    content: ['foo', 'bar', 'baz']
+  });
+
+  var view = SC.TemplateView.create({
+    template: SC.Handlebars.compile('{{#collection "TemplateTests.CollectionTestView"}} <aside>{{this}}</aside> {{/collection}}')
+  });
+
+  view.createLayer();
+  equals(view.$('li:has(aside:contains("foo")) + li:has(aside:contains("bar")) + li:has(aside:contains("baz"))').length, 1, 'one aside element is created for each content item');
+});
+
+test("a block passed to a collection helper defaults to the content property of the context", function() {
+  TemplateTests.CollectionTestView = SC.TemplateCollectionView.create({
+    content: ['foo', 'bar', 'baz']
+  });
+
+  var view = SC.TemplateView.create({
+    template: SC.Handlebars.compile('{{#collection "TemplateTests.CollectionTestView"}} <aside>{{this}}</aside> {{/collection}}')
+  });
+
+  view.createLayer();
+  equals(view.$('li:has(aside:contains("foo")) + li:has(aside:contains("bar")) + li:has(aside:contains("baz"))').length, 1, 'precond - one aside element is created for each content item');
+
+  window.billy = true;
+
+  SC.run(function() {
+    TemplateTests.CollectionTestView.set('content', []);
+  });
+  equals(view.$('aside').length, 0, "all list item views should be removed from DOM");
+});
+

data/lib/frameworks/sproutcore/frameworks/core_foundation/tests/views/template_view/core.js

@@ -0,0 +1,67 @@
+module("SC.TemplateView", {
+  setup: function() {
+    // var view = SC.TemplateView.create();
+  },
+
+  teardown: function() {
+
+  }
+});
+
+test("template view should call the function of the associated template", function() {
+  var view;
+
+  view = SC.TemplateView.create({
+    templateName: 'test_template',
+
+    templates: SC.Object.create({
+      test_template: function(dataSource) {
+        return "<h1 id='twas-called'>template was called</h1>";
+      }
+    })
+  });
+
+  view.createLayer();
+
+  ok(view.$('#twas-called').length, "the named template was called");
+});
+
+test("template view should call the function of the associated template with itself as the context", function() {
+  var view;
+
+  view = SC.TemplateView.create({
+    templateName: 'test_template',
+
+    personName: "Tom DAAAALE",
+
+    templates: SC.Object.create({
+      test_template: function(dataSource) {
+        return "<h1 id='twas-called'>template was called for " + dataSource.get('personName') + "</h1>";
+      }
+    })
+  });
+
+  view.createLayer();
+
+  equals("template was called for Tom DAAAALE", view.$('#twas-called').text(), "the named template was called with the view as the data source");
+});
+
+test("template view defaults to a noop template", function() {
+  var view;
+  view = SC.TemplateView.create({});
+  view.createLayer();
+
+  equals(view.$().html(), '', "view div should be empty");
+});
+
+test("template views return YES to mouseDown if there is a mouseUp method", function() {
+  var view = SC.TemplateView.create();
+
+  ok(!view.tryToPerform('mouseDown'), "view returns NO if there is no mouseUp method");
+
+  view = SC.TemplateView.create({
+    mouseUp: function() { }
+  });
+
+  ok(view.tryToPerform('mouseDown'), "view returns YES if we add a mouseUp method");
+});