sproutcore 1.10.3.1 → 1.11.0.rc1

data/lib/frameworks/sproutcore/frameworks/foundation/tests/system/undo_manager.js

@@ -0,0 +1,231 @@
+// ==========================================================================
+// SC.UndoManager Unit Test
+// ==========================================================================
+/*globals SC */
+
+module("SC.UndoManager");
+
+test("simple undo case", function () {
+  var undoManager = SC.UndoManager.create(),
+    obj = SC.Object.create({
+      undoManager: undoManager,
+
+      value: null,
+
+      actionName: 0,
+
+      _undoAction: function(value) {
+        this.set('value', value);
+      },
+
+      valDidChange: function() {
+        var that = this,
+          value = this._value;
+
+        undoManager.registerUndoAction(this, this._undoAction, value, this.actionName);
+
+        this._value = this.get('value');
+      }.observes('value')
+    });
+
+  obj.actionName = 'group1';
+  obj.set('value', 'a');
+  ok(undoManager.get('canUndo'), "We should be able to undo");
+  equals(undoManager.get('undoActionName'), 'group1', "The name of the undo stack should be 'group1'");
+
+  obj.actionName = 'group2';
+  obj.set('value', 'ab');
+
+  obj.actionName = 'group3';
+  obj.set('value', 'abc');
+  equals(undoManager.get('undoActionName'), 'group3', "The name of the undo stack should be 'group3'");
+
+  undoManager.undo();
+  equals(obj.get('value'), 'ab', "val should be 'ab'");
+  ok(undoManager.get('canRedo'), "We should be able to redo");
+  equals(undoManager.get('undoActionName'), 'group2', "The name of the undo stack should be 'group2'");
+  equals(undoManager.get('redoActionName'), 'group3', "The name of the redo stack should be 'group3'");
+
+  undoManager.undo();
+  equals(obj.get('value'), 'a', "val should be 'a'");
+  equals(undoManager.get('undoActionName'), 'group1', "The name of the undo stack should be 'group1'");
+  equals(undoManager.get('redoActionName'), 'group2', "The name of the redo stack should be 'group2'");
+
+  undoManager.redo();
+  equals(obj.get('value'), 'ab', "val should be 'ab'");
+  equals(undoManager.get('undoActionName'), 'group2', "The name of the undo stack should be 'group2'");
+  equals(undoManager.get('redoActionName'), 'group3', "The name of the redo stack should be 'group3'");
+
+  undoManager.undo();
+  equals(obj.get('value'), 'a', "val should be 'a'");
+
+  undoManager.undo();
+  equals(obj.get('value'), null, "val should be 'null'");
+  ok(!undoManager.get('canUndo'), "We shouldn't be able to undo");
+  equals(undoManager.get('undoActionName'), null, "The name of the undo stack should be 'null'");
+
+  undoManager.redo();
+  equals(obj.get('value'), 'a', "val should be 'a'");
+
+  undoManager.redo();
+  equals(obj.get('value'), 'ab', "val should be 'ab'");
+
+  undoManager.redo();
+  equals(obj.get('value'), 'abc', "val should be 'abc'");
+  ok(!undoManager.get('canRedo'), "We shouldn't be able to redo");
+
+  undoManager.undo();
+  undoManager.undo();
+  equals(obj.get('value'), 'a', "val should be 'a'");
+
+  obj.set('value', 'ad');
+  ok(!undoManager.get('canRedo'), "We shouldn't be able to redo");
+
+  undoManager.undo();
+  ok(undoManager.get('canUndo'), "We should be able to undo");
+  ok(undoManager.get('canRedo'), "We should be able to redo");
+
+  undoManager.reset();
+
+  ok(!undoManager.get('canUndo'), "We shouldn't be able to undo");
+  ok(!undoManager.get('canRedo'), "We shouldn't be able to redo");
+});
+
+
+test("grouped undo case", function () {
+  var undoManager = SC.UndoManager.create(),
+    obj = SC.Object.create({
+      undoManager: undoManager,
+
+      value: null,
+
+      actionName: 0,
+
+      _undoAction: function(value) {
+        this.set('value', value)
+      },
+
+      valDidChange: function() {
+        var value = this._value,
+            actionName = this.actionName;
+
+        if (actionName === this._actionName) {
+          undoManager.registerGroupedUndoAction(this, this._undoAction, value);
+        }
+        else {
+          undoManager.registerUndoAction(this, this._undoAction, value, actionName);
+        }
+
+        this._value = this.get('value');
+        this._actionName = actionName;
+      }.observes('value')
+    });
+
+  obj.actionName = 'group1';
+  obj.set('value', 'a');
+  ok(undoManager.get('canUndo'), "We should be able to undo");
+  equals(undoManager.get('undoActionName'), 'group1', "The name of the undo stack should be 'group1'");
+
+  obj.actionName = 'group2';
+  obj.set('value', 'ab');
+  obj.set('value', 'abc');
+  equals(undoManager.get('undoActionName'), 'group2', "The name of the undo stack should be 'group2'");
+
+  obj.actionName = 'group3';
+  obj.set('value', 'abcd');
+
+  undoManager.undo();
+  equals(obj.get('value'), 'abc', "val should be 'abc'");
+  ok(undoManager.get('canRedo'), "We should be able to redo");
+  equals(undoManager.get('undoActionName'), 'group2', "The name of the undo stack should be 'group2'");
+  equals(undoManager.get('redoActionName'), 'group3', "The name of the redo stack should be 'group3'");
+
+  undoManager.undo();
+  equals(obj.get('value'), 'a', "val should be 'a'");
+
+  undoManager.redo();
+  equals(obj.get('value'), 'abc', "val should be 'abc'");
+
+  undoManager.undo();
+  equals(obj.get('value'), 'a', "val should be 'a'");
+
+  undoManager.undo();
+  equals(obj.get('value'), null, "val should be 'null'");
+  ok(!undoManager.get('canUndo'), "We shouldn't be able to undo");
+
+  undoManager.redo();
+  equals(obj.get('value'), 'a', "val should be 'a'");
+
+  undoManager.redo();
+  equals(obj.get('value'), 'abc', "val should be 'abc'");
+
+  undoManager.redo();
+  equals(obj.get('value'), 'abcd', "val should be 'abcd'");
+  ok(!undoManager.get('canRedo'), "We shouldn't be able to redo");
+
+  undoManager.redo();
+});
+
+test("set action name", function () {
+  var undoManager = SC.UndoManager.create();
+
+  undoManager.setActionName('group1');
+  undoManager.registerUndoAction();
+
+  equals(undoManager.get('undoActionName'), null, "The name of the undo stack should be null");
+
+  undoManager.setActionName('group1');
+
+  equals(undoManager.get('undoActionName'), 'group1', "The name of the undo stack should be 'group1'");
+});
+
+test("restrict number of groups", function () {
+  var undoManager = SC.UndoManager.create({
+      maxStackLength: 2
+    }),
+    obj = SC.Object.create({
+      undoManager: undoManager,
+      value: 0,
+      _undoAction: function(value) {
+        this.set('value', value);
+      },
+      valDidChange: function() {
+        var value = this.get('value') - 1;
+        undoManager.registerUndoAction(this, this._undoAction, value);
+      }.observes('value')
+    }),
+    computeStackLength = function(stack) {
+      var length = 1;
+      while(stack = stack.prev) {
+        length++;
+      }
+      return length;
+    },
+    length;
+
+  obj.incrementProperty('value');
+  obj.incrementProperty('value');
+  obj.incrementProperty('value');
+  obj.incrementProperty('value');
+  obj.incrementProperty('value');
+
+  equals(obj.get('value'), 5, "value should be 5");
+
+  length = computeStackLength(undoManager.undoStack);
+  equals(length, 3, "The undo stack length should be 3");
+
+  undoManager.endUndoGroup();
+
+  length = computeStackLength(undoManager.undoStack);
+  equals(length, 2, "The undo stack length should be 2");
+
+  undoManager.undo();
+  undoManager.undo();
+
+  ok(!undoManager.get('canUndo'), "We shouldn't be able to undo");
+
+  length = computeStackLength(undoManager.redoStack);
+  equals(length, 2, "The redo stack length should be 2");
+});
+
+

data/lib/frameworks/sproutcore/frameworks/foundation/tests/views/container/ui.js

@@ -29,6 +29,14 @@
 
   });
 
+  pane.add("deepNowShowing", SC.ContainerView, {
+    viewPage: SC.Page.extend({
+      view1: SC.View,
+      view2: SC.View
+    }),
+    init: function() { sc_super(); this.viewPage = this.viewPage.create(); } // have to create page
+  });
+
   pane.add("cleans-up-views", SC.ContainerView, {
     nowShowing: 'uninstantiatedView',
 
@@ -146,6 +154,14 @@
 
   });
 
+  test("nowShowing as local property path", function() {
+    var view = pane.view('deepNowShowing');
+
+    view.set("nowShowing", '.viewPage.view1');
+
+    ok(view.get('contentView') === view.getPath('viewPage.view1'), "Setting nowShowing to a local property path correctly updates the contentView.");
+  });
+
   test("Cleans up instantiated views", function() {
     var view = pane.view("cleans-up-views");
     view.awake();

data/lib/frameworks/sproutcore/frameworks/foundation/tests/views/image/ui.js

@@ -22,6 +22,11 @@
       value: 'sprite-class',
       useCanvas: NO
     })
+    .add('sprite_image_canvas', SC.ImageView, {
+      layout: { width: 200, height: 300 },
+      value: 'sprite-class'
+      // Must use default calculated-property version of useCanvas.
+    })
     .add('image_canvas', SC.ImageView, {
       layout: { width: 200, height: 300 },
       useCanvas: YES,
@@ -550,6 +555,28 @@
     ok(!viewElem.hasClass('another-sprite'), "When value removed, element has old class removed");
   });
 
+  test("CSS class is applied for ImageView using a sprite for value while using canvas", function () {
+    var view = pane.view('sprite_image_canvas'),
+        viewElem = view.$();
+
+    ok(viewElem.hasClass('sprite-class'), "element given correct class");
+
+    SC.run(function () {
+      view.set('value', 'another-sprite');
+    });
+
+    ok(!viewElem.hasClass('sprite-class'), "When value changed, element has old class removed");
+    ok(viewElem.hasClass('another-sprite'), "When value changed, element has new class added");
+
+    SC.run(function () {
+      view.set('value', null);
+    });
+
+    viewElem = view.$();
+    ok(!viewElem.hasClass('another-sprite'), "When value removed, element has old class removed");
+  });
+
+
   test("Changing the type of image view updates the layer appropriately (with canvas)", function () {
     var view = pane.view('canvas_not_loaded'),
       jqEl = view.$(),

data/lib/frameworks/sproutcore/frameworks/foundation/tests/views/text_field/methods.js

@@ -196,6 +196,30 @@ test("autoCorrect=null should not add autocorrect", function() {
   ok(!view.$input().attr('autocorrect'), 'should not have an autocorrect attribute set');
 });
 
+test("autoComplete=YES should add autocomplete='on'", function() {
+  SC.RunLoop.begin();
+  view.set('autoComplete', YES);
+  view.displayDidChange();
+  SC.RunLoop.end();
+  ok(view.$input().attr('autocomplete') === "on", 'should have an autocomplete attribute set to "on"');
+});
+
+test("autoComplete=NO should add autocomplete='off'", function() {
+  SC.RunLoop.begin();
+  view.set('autoComplete', NO);
+  view.displayDidChange();
+  SC.RunLoop.end();
+  ok(view.$input().attr('autocomplete') === "off", 'should have an autocomplete attribute set to "off"');
+});
+
+test("autoComplete=null should not add autocomplete", function() {
+  SC.RunLoop.begin();
+  view.set('autoComplete', null);
+  view.displayDidChange();
+  SC.RunLoop.end();
+  ok(!view.$input().attr('autocomplete'), 'should not have an autocomplete attribute set');
+});
+
 /**
  SC.TextFieldView was extended to make use of interpretKeyEvents, which
  allows easy actions to be implemented based off of several key "keys".  This

data/lib/frameworks/sproutcore/frameworks/foundation/tests/views/text_field/ui.js

@@ -13,6 +13,12 @@
     value: ''
   })
 
+  .add("empty - no hint on focus", SC.TextFieldView, {
+    hint: "Full Name",
+    hintOnFocus: false,
+    value: ''
+  })
+
   .add("with value", SC.TextFieldView, {
     hint: "Full Name",
     value: 'John Doe'
@@ -93,9 +99,9 @@
     var layer = view.$();
 
     ok(!layer.hasClass('not-empty'), 'layer should not have not-empty class');
-    if (SC.browser.isWebkit || (SC.browser.isMozilla &&
-        SC.browser.compare(SC.browser.engineVersion, '2.0') >= 0)) equals(input.val(), '', 'input should have empty value');
-    else equals(input.val(), expectedHint, 'input should have expected hint as value');
+
+    equals(input.val(), '', 'input should have empty value');
+
     if (expectedHint) {
       var hint = view.$('.hint');
       if (hint.length === 1) {
@@ -145,7 +151,7 @@
   pane.verifyReadOnly = function verifyReadonly(view, isReadOnly) {
     var input = view.$('input');
 
-    if(isReadOnly) {
+    if (isReadOnly) {
       ok(input.attr('readOnly'), 'input should have readOnly attr');
     } else {
       ok(!input.attr('readOnly'), 'input should not have readOnly attr');
@@ -164,6 +170,13 @@
     pane.verifyDisabled(view, NO);
   });
 
+  test("empty - no hint on focus", function () {
+    var view = pane.view('empty - no hint on focus');
+
+    pane.verifyEmpty(view, 'Full Name');
+    pane.verifyDisabled(view, NO);
+  });
+
   test("with value", function () {
     var view = pane.view('with value');
     pane.verifyNotEmpty(view, 'John Doe', 'Full Name');
@@ -340,6 +353,19 @@
     equals(hint.css('line-height'), "14px", "The line-height of the hint of a non-empty text field should be");
   });
 
+  test("Changing maxLength", function () {
+    var view = pane.view('with value'),
+        input = view.$input();
+
+    equals(input.attr('maxLength'), 5096, 'Max length should begin at')
+
+    SC.run(function () {
+      view.set('maxLength', 1234);
+    });
+
+    equals(input.attr('maxLength'), 1234, 'Max length should now be');
+  });
+
 
   if (!SC.browser.isIE && !SC.platform.input.placeholder) {
     test("Changing value to null -- password field", function () {
@@ -359,7 +385,6 @@
   // TEST SELECTION SUPPORT
   //
 
-
   module('SC.TextFieldView: Selection Support', pane.standardSetup());
 
   test("Setting the selection to a null value should fail", function () {
@@ -411,7 +436,111 @@
     ok(fetchedSelection.get('length') === 3, 'the selection should have length 3');
   });
 
+  test("Setting no selection direction", function () {
+    var view = pane.view('with value');
+    var fieldElement = view.$input()[0];
+    fieldElement.focus();
+    fieldElement.size = 10;     // Avoid Firefox 3.5 issue
+
+    var newSelection = SC.TextSelection.create({ start: 2, end: 5, direction: 'none' });
+    view.set('selection', newSelection);
+
+    var fetchedSelection = view.get('selection');
+    ok(!SC.platform.input.selectionDirection || fetchedSelection.get('direction') === 'none',
+        'the selection direction should be none');
+  });
+
+  test("Setting forward selection direction", function () {
+    var view = pane.view('with value');
+    var fieldElement = view.$input()[0];
+    fieldElement.focus();
+    fieldElement.size = 10;     // Avoid Firefox 3.5 issue
+
+    var newSelection = SC.TextSelection.create({ start: 2, end: 5, direction: 'forward' });
+    view.set('selection', newSelection);
+
+    var fetchedSelection = view.get('selection');
+    ok(!SC.platform.input.selectionDirection || fetchedSelection.get('direction') === 'forward',
+        'the selection direction should be forward');
+  });
+
+  test("Setting backward selection direction", function () {
+    var view = pane.view('with value');
+    var fieldElement = view.$input()[0];
+    fieldElement.focus();
+    fieldElement.size = 10;     // Avoid Firefox 3.5 issue
+
+    var newSelection = SC.TextSelection.create({ start: 2, end: 5, direction: 'backward' });
+    view.set('selection', newSelection);
+
+    var fetchedSelection = view.get('selection');
+    ok(!SC.platform.input.selectionDirection || fetchedSelection.get('direction') === 'backward',
+        'the selection direction should be backward');
+  });
+
+  test("Getting no selection direction", function () {
+    var view = pane.view('with value');
+    var fieldElement = view.$input()[0];
+    fieldElement.focus();
+    fieldElement.size = 10;     // Avoid Firefox 3.5 issue
+
+    fieldElement.setSelectionRange(2, 5, 'none');
 
+    var fetchedSelection = view.get('selection');
+    ok(!SC.platform.input.selectionDirection || fetchedSelection.get('direction') === 'none',
+        'the selection direction should be none');
+  });
+
+  test("Getting forward selection direction", function () {
+    var view = pane.view('with value');
+    var fieldElement = view.$input()[0];
+    fieldElement.focus();
+    fieldElement.size = 10;     // Avoid Firefox 3.5 issue
+
+    fieldElement.setSelectionRange(2, 5, 'forward');
+
+    var fetchedSelection = view.get('selection');
+    ok(!SC.platform.input.selectionDirection || fetchedSelection.get('direction') === 'forward',
+        'the selection direction should be forward');
+  });
+
+  test("Getting backward selection direction", function () {
+    var view = pane.view('with value');
+    var fieldElement = view.$input()[0];
+    fieldElement.focus();
+    fieldElement.size = 10;     // Avoid Firefox 3.5 issue
+
+    fieldElement.setSelectionRange(2, 5, 'backward');
+
+    var fetchedSelection = view.get('selection');
+    ok(!SC.platform.input.selectionDirection || fetchedSelection.get('direction') === 'backward',
+        'the selection direction should be backward');
+  });
+
+  test("Setting textarea selection direction", function () {
+    var view = pane.view('textarea - with value');
+    var fieldElement = view.$input()[0];
+    fieldElement.focus();
+
+    var newSelection = SC.TextSelection.create({ start: 2, end: 5, direction: 'backward' });
+    view.set('selection', newSelection);
+
+    var fetchedSelection = view.get('selection');
+    ok(!SC.platform.input.selectionDirection || fetchedSelection.get('direction') === 'backward',
+        'the selection direction should be backward');
+  });
+
+  test("Getting textarea selection direction", function () {
+    var view = pane.view('textarea - with value');
+    var fieldElement = view.$input()[0];
+    fieldElement.focus();
+
+    fieldElement.setSelectionRange(2, 5, 'backward');
+
+    var fetchedSelection = view.get('selection');
+    ok(!SC.platform.input.selectionDirection || fetchedSelection.get('direction') === 'backward',
+        'the selection direction should be backward');
+  });
 
   // ..........................................................
   // TEST ACCESSORY VIEWS
@@ -735,7 +864,7 @@
     view.get('pane').makeFirstResponder(testResponder);
 
     // verify it no longer has focus
-    ok(!view.get('focused'), 'view should no longer have focus');
+    ok(!view.get('focused'), 'view should no longer have focus (Warning: this test will fail if the browser window doesn\'t have focus)');
   });
 
   test("editing a field should not change the cursor position", function () {