sproutcore 1.10.3.1 → 1.11.0.rc1

data/lib/frameworks/sproutcore/frameworks/foundation/tests/mixins/auto_resize_test.js

@@ -5,7 +5,7 @@
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
 
-/*global module, test, equals,ok */
+/*global module, test, equals, ok, start, stop */
 
 var view;
 
@@ -26,6 +26,40 @@ module("SC.AutoResize", {
 
 });
 
+/**
+  When resizing only the height, we should restrict the width to that of the given
+  element. This way, the height will grow appropriately to fit the target as
+  text wraps within the maximum width.
+  */
+test("Resize height only.", function () {
+  stop(700);
+
+  var pane = SC.Pane.create({
+    layout: { top: 200, left: 0, width: 200, height: 200 }
+  });
+
+  // Set the view up for height only resizing.
+  // i.e. It should grow to fit the text wrapped within the width of the view.
+  view.set('shouldResizeWidth', false);
+  view.set('shouldResizeHeight', true);
+
+  SC.run(function () {
+    pane.appendChild(view);
+    pane.append();
+  });
+
+  setTimeout(function () {
+    ok(view.get('frame').width == 200, 'frame width is 200');
+    ok(view.get('layout').height > 200, 'height > 200');
+
+    pane.destroy();
+    pane.remove();
+
+    start();
+  }, 500);
+});
+
+
 test("Resize with transition plugin - no conflict", function () {
   stop(700);
 
@@ -144,3 +178,131 @@ test("Resize with child view layout", function () {
     start();
   }, 500);
 });
+
+/**
+  For a TextFieldView where we set it to only resize its height every time its value changes 
+  we get the textareas width and set its max-width to this if no autoResizeLayer has been set.
+
+  This test checks that every-time the value changes the max-width we set doesn't change the 
+  textarea width (i.e. takes padding into account when measuring).
+ */
+test("Resize height only for textarea where textarea has padding.", function () {
+  stop(700);
+
+  var pane = SC.Pane.create({
+    layout: { top: 200, left: 0, width: 200, height: 200 }
+  });
+
+  // use a textarea for this test rather than label view
+  var view = SC.TextFieldView.create(SC.AutoResize, {
+    supportsAutoResize: YES,
+    shouldAutoResize: YES,
+    shouldResizeHeight: YES,
+    shouldResizeWidth: NO,
+    isTextArea: YES,
+    autoResizePadding: 10,
+
+    layout: {minHeight: 60, height: 60},
+
+    value: "Some text"
+  });
+
+  SC.run(function () {
+    pane.appendChild(view);
+    pane.append();
+  });
+
+  // add some padding to the element (generally done via css stylesheet)
+  // and also set the box-sizing to border-box so the textarea has 100%
+  // width including the padding.
+  SC.run(function () {
+    view.$('textarea').css({
+      'padding': '10px',
+      '-webkit-box-sizing': 'border-box', 
+      '-moz-box-sizing': 'border-box',
+      'box-sizing': 'border-box' 
+    })
+  });
+
+  // now the css is applied measure the textareas width
+  var origWidth = view.$('textarea').outerWidth();
+
+  // now we update the value and check the width of the textarea
+  // remains correct
+  SC.run(function () {
+    view.set('value', view.get('value') + "!");
+  });
+
+  setTimeout(function () {
+    // check the frame and textarea have the expected dimensions
+    ok(view.get('frame').width == 200, 'frame width is 200');
+    equals(origWidth, view.$('textarea').outerWidth(), 'textarea width has not changed since update of value')
+
+    pane.destroy();
+    pane.remove();
+
+    start();
+  }, 500);
+});
+
+/*
+  Test a TextFiledView with padding auto resizes text
+ */
+test("Resize text only for input where input has padding.", function () {
+  stop(700);
+
+  var pane = SC.Pane.create({
+    layout: {top: 200, left: 0, width: 200, height: 200 }
+  });
+
+  // use a text input for this test rather than a label view
+  var view = SC.TextFieldView.create(SC.AutoResize, {
+    supportsAutoResize: YES,
+    shouldAutoResize: YES,
+    shouldResizeHeight: NO,
+    shouldResizeWidth: NO,
+    isTextArea: NO,
+    autoResizePadding: 10,
+
+    layout: {minHeight: 60, height: 60},
+
+    value: "Some text"
+  });
+
+  SC.run(function () {
+    pane.appendChild(view);
+    pane.append();
+  });
+
+  // add some padding to the element (generally done via css stylesheet)
+  // and also set the box-sizing to border-box so the input element has 100%
+  // width including the padding.
+  SC.run(function () {
+    view.$('input').css({
+      'padding': '10px',
+      '-webkit-box-sizing': 'border-box', 
+      '-moz-box-sizing': 'border-box',
+      'box-sizing': 'border-box' 
+    })
+  });
+
+  // now the css is applied measure the input fields width
+  var origWidth = view.$('input').outerWidth();
+
+  // now we update the value and check the width of the input field
+  // remains correct
+  SC.run(function () {
+    view.set('value', view.get('value') + "!");
+  });
+
+  setTimeout(function () {
+    // check the frame and input field have the expected dimensions
+    ok(view.get('frame').width == 200, 'frame width is 200');
+    equals(origWidth, view.$('input').outerWidth(), 'input field width has not changed since update of value')
+
+    pane.destroy();
+    pane.remove();
+
+    start();
+  }, 500);
+})

data/lib/frameworks/sproutcore/frameworks/foundation/tests/mixins/flowed_layout/tests.js

@@ -956,3 +956,44 @@ test("undefined and null can be passed for both defaultFlowSpacing and child's f
   view.destroy();
 });
 
+test("Observed childViews", function() {
+  var view;
+
+  SC.run(function() {
+    view = SC.View.create(SC.FlowedLayout, {
+      childViews: 'a b c'.w(),
+
+      a: SC.View.create({
+        layout: { width: 100, height: 100 }
+      }),
+
+      b: SC.View.create({
+        layout: { width: 300, height: 100 }
+      }),
+
+      c: SC.View.create({
+        layout: { width: 200, height: 100 }
+      })
+    });
+    view._doRender();
+    view._doAttach(document.body);
+  });
+
+  // TODO: Redo this without poking private implementations.
+  ok(view._scfl_isObserving.contains(view.a), "FlowedLayout view should observe all three childViews (a).");
+  ok(view._scfl_isObserving.contains(view.b), "FlowedLayout view should observe all three childViews (b).");
+  ok(view._scfl_isObserving.contains(view.c), "FlowedLayout view should observe all three childViews (c).");
+
+  // Remove a child view.
+  SC.run(function() {
+    view.removeChild(view.b);
+  });
+
+  ok(!view._scfl_isObserving.contains(view.b), "FlowedLayout view should no longer observe the layout of a removed child view (b).");
+  ok(view._scfl_isObserving.contains(view.a), "FlowedLayout view should still be observing all three childViews (a).");
+  ok(view._scfl_isObserving.contains(view.c), "FlowedLayout view should still be observing all three childViews (c).");
+
+  // Cleanup
+  view.destroy();
+
+});

data/lib/frameworks/sproutcore/frameworks/foundation/tests/mixins/staticLayout.js

@@ -117,16 +117,13 @@ test("Test that an exception is thrown when calling adjust and setting to auto",
   function(){
   var error=null;
   console.log('NOTE: The following error concerning width:auto is expected.');
-  parent.adjust('width', 'auto').adjust('height', 'auto');
   try{
+    parent.adjust('width', 'auto').adjust('height', 'auto');
     parent.get('layoutStyle');
   }catch(e){
     error=e;
   }
-  equals(SC.T_ERROR,SC.typeOf(error),'Layout style functions should throw an '+
-  'error if width/height are set to auto but staticLayout is not enabled' + error );
-      
-   
+  equals(SC.T_ERROR,SC.typeOf(error),'Layout style functions should throw an error if width/height are set to auto but staticLayout is not enabled' + error );
 });
 
 test("Test SC.StaticLayout frame support", function() {

data/lib/frameworks/sproutcore/frameworks/foundation/tests/private/tree_item_observer/methods.js

@@ -0,0 +1,268 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2012 7x7 Software, Inc.
+// License:   Licensed under MIT license
+// ==========================================================================
+/*globals module, test, ok, isObj, equals, expects, start, stop*/
+
+var content, root;
+var TestObject = SC.Object.extend({
+  toString: function () { return "TestObject(%@)".fmt(this.get('title')); }
+});
+
+module('SC.TreeItemObserver Methods', {
+  setup: function () {
+    content = [
+      TestObject.create({
+        isGroup: YES,
+        title: "A",
+        isExpanded: YES,
+        outline: 0,
+        children: "0".w().map(function (x) {
+          return TestObject.create({
+            title: "A.%@".fmt(x),
+            outline: 1
+          });
+        })
+      }),
+
+      TestObject.create({
+        isGroup: YES,
+        title: "B",
+        isExpanded: YES,
+        outline: 0,
+        children: "0 1".w().map(function (x) {
+          return TestObject.create({
+            title: "B.%@".fmt(x),
+            outline: 1
+          });
+        })
+      }),
+
+      TestObject.create({
+        isGroup: YES,
+        title: "C",
+        isExpanded: NO,
+        outline: 0,
+        children: "0 1 2".w().map(function (x) {
+          return TestObject.create({
+            title: "C.%@".fmt(x),
+            outline: 1
+          });
+        })
+      })
+    ];
+
+    root = TestObject.create({
+      title: "ROOT",
+      children: content,
+      isExpanded: YES
+    });
+
+    // Create a TreeItemObserver for testing.
+    // SC.run(function () {
+    //   tio = SC.TreeItemObserver.create({
+    //     delegate: SC.Object.create({
+    //       treeItemChildrenKey: "children",
+    //       treeItemIsExpandedKey: "isExpanded"
+    //     }),
+    //     item: root
+    //   });
+    // });
+  },
+
+  teardown: function () {
+    // tio.destroy();
+    // tio = null;
+    root.destroy();
+    content.invoke('destroy');
+    root = content = null;
+  }
+});
+
+test("SC.TreeItemObserver.prototype.init(): No delegate", function () {
+  var tio,
+    item;
+
+  SC.run(function () {
+    tio = SC.TreeItemObserver.create({
+      item: root
+    });
+  });
+
+  item = tio.get('item');
+
+  // TIO should add observers on the item (based on the default keys)
+  ok(item.hasObserverFor('treeItemChildren'), "The item is observed for changes to treeItemChildren.");
+  ok(item.hasObserverFor('treeItemIsExpanded'), "The item is observed for changes to treeItemIsExpanded.");
+
+  // Clean up.
+  tio.destroy();
+});
+
+test("SC.TreeItemObserver.prototype.init(): With delegate", function () {
+  var tio,
+    delegate,
+    item;
+
+  SC.run(function () {
+    tio = SC.TreeItemObserver.create({
+      delegate: SC.Object.create({
+        treeItemChildrenKey: "children",
+        treeItemIsExpandedKey: "isExpanded"
+      }),
+      item: root
+    });
+  });
+
+  delegate = tio.get('delegate');
+  item = tio.get('item');
+
+  // TIO should add observers on the delegate.
+  ok(delegate.hasObserverFor('treeItemChildrenKey'), "The delegate is observed for changes to treeItemChildrenKey.");
+  ok(delegate.hasObserverFor('treeItemIsExpandedKey'), "The delegate is observed for changes to treeItemIsExpandedKey.");
+  ok(delegate.hasObserverFor('treeItemIsGrouped'), "The delegate is observed for changes to treeItemIsGrouped.");
+
+  // TIO should add observers on the item (based on the delegate keys)
+  ok(item.hasObserverFor('children'), "The item is observed for changes to children.");
+  ok(item.hasObserverFor('isExpanded'), "The item is observed for changes to isExpanded.");
+
+  // Clean up.
+  tio.destroy();
+});
+
+
+test("SC.TreeItemObserver.prototype.destroy(): No delegate", function () {
+  var tio,
+    item;
+
+  SC.run(function () {
+    tio = SC.TreeItemObserver.create({
+      item: root
+    });
+  });
+
+  item = tio.get('item');
+  tio.destroy();
+
+  // TIO should remove observers on the item on destroy (based on the default keys)
+  ok(!item.hasObserverFor('treeItemChildren'), "The item is no longer observed for changes to treeItemChildren.");
+  ok(!item.hasObserverFor('treeItemIsExpanded'), "The item is no longer observed for changes to treeItemIsExpanded.");
+
+});
+
+
+test("SC.TreeItemObserver.prototype.destroy(): With delegate", function () {
+  var tio,
+    delegate,
+    item;
+
+  SC.run(function () {
+    tio = SC.TreeItemObserver.create({
+      delegate: SC.Object.create({
+        treeItemChildrenKey: "children",
+        treeItemIsExpandedKey: "isExpanded"
+      }),
+      item: root
+    });
+  });
+
+  delegate = tio.get('delegate');
+  item = tio.get('item');
+  tio.destroy();
+
+  // TIO should remove observers on the delegate on destroy.
+  ok(!delegate.hasObserverFor('treeItemChildrenKey'), "The delegate is no longer observed for changes to treeItemChildrenKey.");
+  ok(!delegate.hasObserverFor('treeItemIsExpandedKey'), "The delegate is no longer observed for changes to treeItemIsExpandedKey.");
+  ok(!delegate.hasObserverFor('treeItemIsGrouped'), "The delegate is no longer observed for changes to treeItemIsGrouped.");
+
+  // TIO should remove observers on the item on destroy (based on the delegate keys)
+  ok(!item.hasObserverFor('children'), "The item is no longer observed for changes to children.");
+  ok(!item.hasObserverFor('isExpanded'), "The item is no longer observed for changes to isExpanded.");
+
+});
+
+
+test("SC.TreeItemObserver.prototype._delegateDidChange()", function () {
+  var tio,
+    oldDelegate,
+    newDelegate,
+    item;
+
+  SC.run(function () {
+    tio = SC.TreeItemObserver.create({
+      delegate: SC.Object.create({
+        treeItemChildrenKey: "children",
+        treeItemIsExpandedKey: "isExpanded"
+      }),
+      item: root
+    });
+  });
+
+  oldDelegate = tio.get('delegate');
+  item = tio.get('item');
+
+  SC.run(function () {
+    tio.set('delegate', SC.Object.create({
+      treeItemChildrenKey: "otherChildren",
+      treeItemIsExpandedKey: "otherIsExpanded"
+    }));
+  });
+
+  newDelegate = tio.get('delegate');
+
+  // TIO should remove observers on the old delegate.
+  ok(!oldDelegate.hasObserverFor('treeItemChildrenKey'), "The original delegate is no longer observed for changes to treeItemChildrenKey.");
+  ok(!oldDelegate.hasObserverFor('treeItemIsExpandedKey'), "The original delegate is no longer observed for changes to treeItemIsExpandedKey.");
+  ok(!oldDelegate.hasObserverFor('treeItemIsGrouped'), "The original delegate is no longer observed for changes to treeItemIsGrouped.");
+
+  // TIO should add observers on the new delegate.
+  ok(newDelegate.hasObserverFor('treeItemChildrenKey'), "The delegate is observed for changes to treeItemChildrenKey.");
+  ok(newDelegate.hasObserverFor('treeItemIsExpandedKey'), "The delegate is observed for changes to treeItemIsExpandedKey.");
+  ok(newDelegate.hasObserverFor('treeItemIsGrouped'), "The delegate is observed for changes to treeItemIsGrouped.");
+
+  // TIO should remove observers on the item when the delegate changes (based on the old delegate keys).
+  ok(!item.hasObserverFor('children'), "The original item is no longer observed for changes to children.");
+  ok(!item.hasObserverFor('isExpanded'), "The original item is no longer observed for changes to isExpanded.");
+
+  // TIO should add observers on the item (based on the new delegate keys).
+  ok(item.hasObserverFor('otherChildren'), "The item is observed for changes to otherChildren.");
+  ok(item.hasObserverFor('otherIsExpanded'), "The item is observed for changes to otherIsExpanded.");
+});
+
+
+test("SC.TreeItemObserver.prototype._itemDidChange()", function () {
+  var tio,
+    oldItem,
+    newItem;
+
+  SC.run(function () {
+    tio = SC.TreeItemObserver.create({
+      delegate: SC.Object.create({
+        treeItemChildrenKey: "children",
+        treeItemIsExpandedKey: "isExpanded"
+      }),
+      item: root
+    });
+  });
+
+  oldItem = tio.get('item');
+
+  SC.run(function () {
+    tio.set('item', TestObject.create({
+      title: "NEW ROOT",
+      children: content,
+      isExpanded: YES
+    }));
+  });
+
+  newItem = tio.get('item');
+
+  // TIO should remove observers on the item when the delegate changes (based on the old delegate keys).
+  ok(!oldItem.hasObserverFor('children'), "The original item is no longer observed for changes to children.");
+  ok(!oldItem.hasObserverFor('isExpanded'), "The original item is no longer observed for changes to isExpanded.");
+
+  // TIO should add observers on the item (based on the new delegate keys).
+  ok(newItem.hasObserverFor('children'), "The item is observed for changes to otherChildren.");
+  ok(newItem.hasObserverFor('isExpanded'), "The item is observed for changes to otherIsExpanded.");
+});