sproutcore 1.6.0.rc.2-x86-mingw32 → 1.6.0.1-x86-mingw32

data/lib/frameworks/sproutcore/frameworks/experimental/frameworks/forms/mixins/edit_mode.js

@@ -4,7 +4,7 @@
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
 /**
-  Handles propagation of a property inEditMode to all child views.
+  Handles propagation of a property isEditing to all child views.
 */
 SC.FormsEditMode = {
   
@@ -37,12 +37,20 @@ SC.FormsEditMode = {
   */
   _propagateEditMode: function() {
     var isEditing = this.get("isEditing");
-    var cv = this.get("childViews"), idx, len = cv.length, v;
+    var cv = this.get("childViews");
+    if (!cv) { return; }
+
+    var idx, len = cv.length, v;
     for (idx = 0; idx < len; idx++) {
       v = cv[idx];
-      if (SC.typeOf(v) === SC.T_STRING || v.isClass) return;
-      if (v.get("hasEditMode")) v.set("isEditing", isEditing);
+
+      if (SC.typeOf(v) === SC.T_STRING || v.isClass) {
+        return;
+      }
+      if (v.get("hasEditMode")) {
+        v.set("isEditing", isEditing);
+      }
     }
   }
   
-};
+};

data/lib/frameworks/sproutcore/frameworks/experimental/frameworks/forms/mixins/emptiness.js

@@ -6,89 +6,105 @@
 
 /**
   @namespace 
-  A view is empty if all of its children are empty. A view is automatically counted as empty if it is not visible and not empty if it is being edited.
-  All fields must mix this in for it to work properly.
+  A view is empty if all of its children are empty. A view is automatically 
+  counted as empty if it is not visible, and not empty if it is being edited.
+
+  Any field that does not mix in CalculatesEmptiness will be considered empty.
 */
 SC.CalculatesEmptiness = {
   
   hasCalculatesEmptiness: YES,
   
-  /**
-  Whether this view should be considered a value. If it is not it will be ignored for calculating emptiness.
-   */
-  isValue: YES,
-  
   /**
   YES if the value of the field is empty. Defaults to yes so if you don't override this, it will only consider child fields in emptiness calculation (this is the desired behavior for forms).
   */
   isValueEmpty: YES,
   
   /**
-  Defaults to YES so that a field with no children will act properly.
-   */
-  _SCCE_childrenAreEmpty: YES,
+    Defaults to YES so that a field with no children will act properly.
+  */
+  _scce_childrenAreEmpty: YES,
   
+  /**
+    If YES, all visible fields are considered non-empty when editing.
+    @type Boolean
+    @default YES
+  */
   isEditingAffectsIsEmpty: YES,
-  
-  _SCCE_isEditingDidChange: function() {
-    if(this.get('isEditingAffectsIsEmpty')) this.propertyDidChange('isEmpty');
+
+
+  _scce_isEditingDidChange: function() {
+    if(this.get('isEditingAffectsIsEmpty')) {
+      this.notifyPropertyChange('isEmpty');
+    }
   }.observes('isEditing'),
   
   /**
-  YES if the field itself is empty. Even if the value is non-empty, the field can be empty due to isVisible.
-   */
+    YES if the field itself is empty. Even if the value is non-empty, the field can be empty due to isVisible.
+  */
   isEmpty: function() {
-    // if it's not visible, it counts as empty
-    // if it's editing, it can't be empty
-    return !this.get('isValue') || !this.get('isVisible') || ((!this.get('isEditingAffectsIsEmpty') || !this.get('isEditing')) && this.get('isValueEmpty') && this.get('_SCCE_childrenAreEmpty'));
-  }.property('isValueEmpty', 'isVisible', '_SCCE_childrenAreEmpty').cacheable(),
-  
+    // When not visible, it is empty. Period.
+    if (!this.get('isVisible')) {
+      return YES;
+    }
+
+    // if it is editing and edit mode affects emptiness, it is NOT empty.
+    if (this.get('isEditingAffectsIsEmpty') && this.get('isEditing')) {
+      return NO;
+    }
+
+    // otherwise, it is empty if its value AND all children are empty.
+    return this.get('isValueEmpty') && this.get('_scce_childrenAreEmpty');
+  }.property('isValueEmpty', 'isVisible', '_scce_childrenAreEmpty', 'isEditingAffectsIsEmpty').cacheable(),
+
   /**
-  When emptiness changes tell the parent to re-check its emptiness.
+    When emptiness changes tell the parent to re-check its own emptiness.
   */
-  _SCCE_isEmptyDidChange: function() {
+  _scce_isEmptyDidChange: function() {
     var parentView = this.get('parentView');
-    
-    if (parentView && parentView._SCCE_emptinessDidChangeFor) parentView._SCCE_emptinessDidChangeFor(this);
+
+    if (parentView && parentView._scce_emptinessDidChangeFor) {
+      parentView._scce_emptinessDidChangeFor(this);
+    }
   }.observes('isEmpty'),
-  
+
   initMixin: function() {
-    this._SCCE_emptinessDidChangeFor();
+    this._scce_emptinessDidChangeFor();
   },
-  
+
   /**
   Called by fields when their emptiness changes.
 
   Always triggers (at end of run loop) a relayout of fields.
   */
-  _SCCE_emptinessDidChangeFor: function(child)
-  {
-    this.invokeOnce('_SCCE_recalculateChildrensEmptiness');
+  _scce_emptinessDidChangeFor: function(child) {
+    this.invokeOnce('_scce_recalculateChildrensEmptiness');
   },
 
   /**
   By default, a view will check all of its fields to determine if it is empty. It is only empty if all of its value fields are.
   */
-  _SCCE_recalculateChildrensEmptiness: function()
+  _scce_recalculateChildrensEmptiness: function()
   {
-    // in short, we get the value fields, if we come across one that is visible and not empty
+    // in short, we get the value fields, if we come across one that is not empty
     // we cannot be empty.
     var views = this.get('childViews');
-    
+
     var empty = YES,
     len = views.length,
     field;
-    
+
     for (var i = 0; i < len; i++)
     {
       field = views[i];
-      
-      if (!field.get('isEmpty')) {
+
+      if (!field.get('isEmpty') && field.hasCalculatesEmptiness) {
         empty = NO;
         break;
       }
     }
     
-    this.setIfChanged('_SCCE_childrenAreEmpty', empty);
+    this.setIfChanged('_scce_childrenAreEmpty', empty);
   }
 };
+

data/lib/frameworks/sproutcore/frameworks/experimental/frameworks/forms/render_delegates/form.js

@@ -6,7 +6,8 @@
 
 
 SC.BaseTheme.formRenderDelegate = SC.RenderDelegate.create({
-  name: 'form',
+  className: 'form',
+  flowSpacing: { left: 5, top: 5, bottom: 5, right: 5 },
 
   render: function() {
   },

data/lib/frameworks/sproutcore/frameworks/experimental/frameworks/forms/render_delegates/form_row.js

@@ -5,16 +5,8 @@
 // ==========================================================================
 
 SC.BaseTheme.formRowRenderDelegate = SC.RenderDelegate.create({
-  name: 'form-row',
-
-  render: function(context) {
-    
-  },
-  
-  update: function() {
-    
-  }
+  className: 'form-row',
+  flowSpacing: { right: 15, left: 0, top: 0, bottom: 0 },
+  flowPadding: 0
 });
 
-SC.BaseTheme.FORM_ROW_FLOW_SPACING = { right: 15, left: 0, top: 0, bottom: 0 };
-SC.BaseTheme.FORM_ROW_FLOW_PADDING = { left: 0, right: 0, bottom: 0, top: 0 };

data/lib/frameworks/sproutcore/frameworks/experimental/frameworks/forms/tests/mixins/edit_mode.js

@@ -0,0 +1,53 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2008-2011 Apple Inc. All rights reserved.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+
+// FormsEditMode propagates the 'isEditing' property to its child view.
+// It is simple enough that we can test it super-cleanly: mix it into
+// an object, provide an array 'childViews' containing other objects,
+// and match.
+//
+// Things to test:
+//
+// - Basic: isEditing defaults to NO, hasEditMode is YES; these are sanity checks.
+// - Changing isEditing propagates to children.
+//
+module("Forms - FormsEditMode mixin");
+
+test("Basics", function() { 
+  var view = SC.Object.create(SC.FormsEditMode, { childViews: [] });
+
+  // flags like this are often matched without .get, so test that way
+  equals(view.hasEditMode, YES, "Has Edit Mode");
+
+  // this default is good to check, as it is just the kind of thing
+  // someone would change when trying to fix a different bug--for instance,
+  // if FormView stopped properly initializing in edit mode.
+  equals(view.get('isEditing'), NO, "isEditing defaults to NO");
+});
+
+test("Changing isEditing propagates to children", function() {
+  var view = SC.Object.create(SC.FormsEditMode, {
+    childViews: [SC.Object.create(SC.FormsEditMode), SC.Object.create()]
+  });
+
+  equals(view.childViews[0].get('isEditing'), NO, "Child view that hasEditing is in edit mode");
+  equals(view.childViews[1].get('isEditing'), undefined, "Child view without hasEditing has not changed");
+
+  view.set('isEditing', YES);
+
+  equals(view.childViews[0].get('isEditing'), YES, "Child view that hasEditing is in edit mode");
+  equals(view.childViews[1].get('isEditing'), undefined, "Child view without hasEditing has not changed");
+});
+
+test("Changing isEditing on something with no children doesn't crash", function() {
+  var view = SC.Object.create(SC.FormsEditMode, {
+    childViews: null
+  });
+
+  view.set('isEditing', YES);
+
+  equals(view.childViews, null, "Look ma, no childViews!");
+});

data/lib/frameworks/sproutcore/frameworks/experimental/frameworks/forms/tests/mixins/emptiness.js

@@ -0,0 +1,114 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2008-2011 Apple Inc. All rights reserved.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+
+module("Forms - CalculatesEmptiness");
+
+test("Basics - Walks like a duck and all that", function() {
+  var calculatesEmptiness = SC.Object.create(SC.CalculatesEmptiness, { childViews: [] });
+
+  equals(calculatesEmptiness.hasCalculatesEmptiness, YES, "hasCalculatesEmptiness gets set");
+});
+
+test("Is not empty when isValueEmpty is NO", function() {
+  SC.RunLoop.begin();
+  var o = SC.Object.create(SC.CalculatesEmptiness, {
+    isVisible: YES, childViews: []
+  });
+  SC.RunLoop.end();
+
+  equals(o.get('isEmpty'), YES, "Starts out as empty because isValueEmpty is YES");
+
+  SC.RunLoop.begin();
+  o.set('isValueEmpty', NO);
+  SC.RunLoop.end();
+
+  equals(o.get('isEmpty'), NO, "No longer empty after changing isValueEmpty");
+});
+
+test("Is empty when isVisible is NO", function() {
+  SC.RunLoop.begin();
+  var o = SC.Object.create(SC.CalculatesEmptiness, {
+    isVisible: YES, childViews: [], isValueEmpty: NO
+  });
+  SC.RunLoop.end();
+
+  equals(o.get('isEmpty'), NO, "Starts out as empty because isValueEmpty is NO");
+
+  SC.RunLoop.begin();
+  o.set('isVisible', NO);
+  SC.RunLoop.end();
+
+  equals(o.get('isEmpty'), YES, "Now empty after changing isVisible");
+});
+
+test("isEditing makes it not empty", function() {
+  SC.RunLoop.begin();
+  var o = SC.Object.create(SC.CalculatesEmptiness, {
+    isVisible: YES, childViews: []
+  });
+  SC.RunLoop.end();
+
+  equals(o.get('isEmpty'), YES, "Starts out as empty because isValueEmpty is YES");
+
+  SC.RunLoop.begin();
+  o.set('isEditing', YES);
+  SC.RunLoop.end();
+
+  equals(o.get('isEmpty'), NO, "No longer empty after changing isEditing");
+});
+
+test("isEditing does not change emptiness if isEditingAffectsIsEmpty is NO", function() {
+  SC.RunLoop.begin();
+  var o = SC.Object.create(SC.CalculatesEmptiness, {
+    isVisible: YES, childViews: [], isEditing: YES
+  });
+  SC.RunLoop.end();
+
+  equals(o.get('isEmpty'), NO, "Starts out as non-empty because isEditing is YES");
+
+  SC.RunLoop.begin();
+  o.set('isEditingAffectsIsEmpty', NO);
+  SC.RunLoop.end();
+
+  equals(o.get('isEmpty'), YES, "Empty after changing isEditingAffectsIsEmpty");
+
+});
+
+test("Is empty if no children provide hasCalculatesEmptiness", function() {
+  SC.RunLoop.begin();
+  var o = SC.Object.create(SC.CalculatesEmptiness, {
+    isVisible: YES,
+    childViews: [
+      SC.Object.create(), SC.Object.create()
+    ]
+  });
+  SC.RunLoop.end();
+
+  equals(o.get('isEmpty'), YES, "Is empty because it has no value and all children don't use emptiness");
+});
+
+test("Is empty depends on emptiness of children with hasCalculatesEmptiness", function() {
+  SC.RunLoop.begin();
+  var o = SC.Object.create(SC.CalculatesEmptiness, {
+    isVisible: YES,
+    childViews: [
+      SC.Object.create(SC.CalculatesEmptiness, { childViews: [], isVisible: YES }), SC.Object.create()
+    ]
+  });
+  SC.RunLoop.end();
+
+  // needed so that the child view can notify the parent of changes to emptiness
+  o.childViews[0].parentView = o;
+
+  equals(o.get('isEmpty'), YES, "Is empty because the child that hasCalculatesEmptiness is empty");
+
+  SC.RunLoop.begin();
+  o.childViews[0].set('isValueEmpty', NO);
+  SC.RunLoop.end();
+
+  equals(o.childViews[0].get('isEmpty'), NO, "Child view is not empty.");
+  equals(o.get('isEmpty'), NO, "Is no longer empty because the child is not empty");
+});

data/lib/frameworks/sproutcore/frameworks/experimental/frameworks/forms/tests/views/form.js

@@ -6,12 +6,180 @@
 
 /*globals Forms module test ok equals same stop start */
 
-module("Forms.FormView");
+var Form, FormWithChildren, FormWithLabelWidths;
 
-// TODO: Replace with real unit test for Forms.FormView
-test("test description", function() {
-  var expected = "test";
-  var result   = "test";
-  equals(result, expected, "test should equal test");
+module("Forms - FormView", {
+  setup: function() {
+    // a basic form view, no children
+    Form = SC.FormView.extend({
+
+    });
+
+    // a form with some children
+    FormWithChildren = SC.FormView.extend({
+      childViews: ('row rowWithLabel rowTestingHumanization rowWithContent ' +
+                   'rowWithContentValueKey viewWithContentValueSupport ' +
+                   'viewWithContent viewWithContentValueKey plainView').w(),
+
+      // keep things clean: don't use real form rows. Simulate to test
+      // interface between FormRow and Form
+      row: SC.View.extend({
+        isFormRow: YES
+      }),
+
+      rowWithLabel: SC.View.extend({
+        isFormRow: YES,
+        label: "Hi"
+      }),
+
+      rowTestingHumanization: SC.View.extend({
+        isFormRow: YES
+      }),
+
+      rowWithContent: SC.View.extend({
+        isFormRow: YES,
+        hasContentValueSupport: YES,
+        content: SC.Object.create({ original: YES })
+      }),
+
+      rowWithContentValueKey: SC.View.extend({
+        isFormRow: YES,
+        hasContentValueSupport: YES,
+        contentValueKey: 'hello'
+      }),
+
+      viewWithContentValueSupport: SC.View.extend({
+        hasContentValueSupport: YES
+      }),
+
+      viewWithContent: SC.View.extend({
+        hasContentValueSupport: YES,
+        content: SC.Object.create({ original: YES })
+      }),
+
+      viewWithContentValueKey: SC.View.extend({
+        hasContentValueSupport: YES,
+        contentValueKey: 'hello'
+      }),
+
+      plainView: SC.View.extend({
+      })
+
+    });
+
+    FormWithLabelWidths = SC.FormView.extend({
+      childViews: 'view1 view2'.w(),
+      view1: SC.View.extend({
+        isFormRow: YES,
+        hasRowLabel: YES,
+        rowLabelMeasuredSize: 50
+      }),
+
+      view2: SC.View.extend({
+        isFormRow: YES,
+        hasRowLabel: YES,
+        rowLabelMeasuredSize: 70
+      })
+    });
+  }
+
+});
+
+test("FormView defaults", function() {
+  var form = Form.create();
+
+  // just sanity-checking
+  equals(form.get('layoutDirection'), SC.LAYOUT_VERTICAL, "Default layout direction");
+  equals(form.get('canWrap'), NO, "canWrap should default to NO");
+  equals(form.get('editsByDefault'), YES, "Forms should edit by default");
+
+});
+
+test("FormView - editsB'))fault sets isEditing appropriately", function() {
+  var formEditsByDefault = Form.create(), formNoEdit = Form.create({ editsByDefault: NO });
+
+  equals(formEditsByDefault.get('isEditing'), YES, "Form with editsByDefault is editing");
+  equals(formNoEdit.get('isEditing'), NO, "Form without editsByDefault is not editing");
 });
 
+test("FormView - labels set on rows correctly", function() {
+  var form = FormWithChildren.create();
+  equals(form.childViews[0].get('label'), "Row", "Label set automatically");
+  equals(form.childViews[1].get('label'), "Hi", "Label not set automatically if set directly");
+  equals(form.childViews[2].get('label'), "Row Testing Humanization", "Humanization is applied");
+});
+
+test("FormView - content set on rows correctly", function() {
+  var content = SC.Object.create({
+    row: "Hi",
+    rowWithContent: "Yeah, this is ignored",
+    specialKey: "Some Value",
+    plainView: "Yo"
+  });
+
+  SC.RunLoop.begin();
+  var form = FormWithChildren.create({ content: content });
+  SC.RunLoop.end();
+
+  equals(form.row.get('content'), content, "Content gets set for normal row");
+  equals(form.rowWithContent.getPath('content.original'), YES, "Row with content has original content");
+  equals(form.viewWithContentValueSupport.get('content'), content, "Content gets set on view with content value support");
+  equals(form.viewWithContent.getPath('content.original'), YES, "Content stays original on row that already has content");
+  equals(form.plainView.get('content'), content, "Plain views get content as well");
+});
+
+test("FormView - contentValueKey", function() {
+  var content = SC.Object.create({
+    row: "Hi",
+    rowWithContent: "Yeah, this is ignored",
+    specialKey: "Some Value",
+    plainView: "Yo"
+  });
+
+  SC.RunLoop.begin();
+  var form = FormWithChildren.create({ content: content });
+  SC.RunLoop.end();
+
+  // Form rows don't have contentValue support.
+  equals(form.row.get('formKey'), 'row', "Row's formKey is set automatically.");
+
+  // implicit setting of contentValueKey on just any view is a bad idea... so we check that
+  // it is NOT set implicitly.
+  equals(form.rowWithContent.get('contentValueKey'), undefined, "Row with content value support does not get 'contentValueKey' set");
+
+  // but if it is set directly, that should still work
+  equals(form.rowWithContentValueKey.get('contentValueKey'), 'hello', "Row with existing contentValueKey keeps its original one");
+
+  // views with content value support likewise should not get the key set directly;
+  // so many views can have contentValueSupport, and that behavior may not be what we want
+  equals(form.viewWithContentValueSupport.get('contentValueKey'), undefined, "View with content value support gets left alone");
+  equals(form.viewWithContentValueKey.get('contentValueKey'), 'hello', "View with existing contentValueKey keeps original");
+  equals(form.plainView.get('contentValueKey'), undefined, "contentValueKey not set on plain view");
+  equals(form.plainView.get('formKey'), 'plainView', "formKey is set on plain view");
+});
+
+test("FormView - Row label width management", function() {
+  SC.RunLoop.begin();
+  var form = FormWithLabelWidths.create();
+  SC.RunLoop.end();
+
+  equals(form.view1.get('rowLabelSize'), 70, "First row's rowLabelSize is correct");
+  equals(form.view2.get('rowLabelSize'), 70, "Second row's rowLabelSize is correct");
+
+  SC.RunLoop.begin();
+  form.view2.set('rowLabelMeasuredSize', 30);
+
+  // row view will have to tell parent, but since these are not real row views:
+  form.rowLabelMeasuredSizeDidChange(form.view2, 30);
+
+  SC.RunLoop.end();
+
+
+  equals(form.view1.get('rowLabelSize'), 50, "First row's rowLabelSize is correct");
+  equals(form.view2.get('rowLabelSize'), 50, "Second row's rowLabelSize is correct");
+
+  // setting labelWidth directly should make FormView always use that
+  form.set('labelWidth', 500);
+  equals(form.view1.get('rowLabelSize'), 500, "First row's rowLabelSize is correct");
+  equals(form.view2.get('rowLabelSize'), 500, "Second row's rowLabelSize is correct");
+});