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

data/lib/frameworks/sproutcore/frameworks/runtime/system/object.js

@@ -22,6 +22,34 @@ SC.BENCHMARK_OBJECTS = NO;
 // definition because SC.Object is copied frequently and we want to keep the
 // number of class methods to a minimum.
 
+SC._detect_base = function _detect_base(func, parent, name) {
+  return function invoke_superclass_method() {
+    var base = parent[name], args;
+
+    if (!base) {
+      throw new Error("No '" + name + "' method was found on the superclass");
+    }
+
+    // NOTE: It is possible to cache the base, so that the first
+    // call to sc_super will avoid doing the lookup again. However,
+    // since the cost of the extra method dispatch is low and is
+    // only incurred on sc_super, but also creates another possible
+    // weird edge-case (when a class is enhanced after first used),
+    // we'll leave it off for now unless profiling demonstrates that
+    // it's a hotspot.
+    //if(base && func === base) { func.base = function() {}; }
+    //else { func.base = base; }
+
+    if(func.isEnhancement) {
+      args = Array.prototype.slice.call(arguments, 1);
+    } else {
+      args = arguments;
+    }
+
+    return base.apply(this, args);
+  };
+};
+
 /** @private
   Augments a base object by copying the properties from the extended hash.
   In addition to simply copying properties, this method also performs a
@@ -36,8 +64,8 @@ SC.BENCHMARK_OBJECTS = NO;
   @param {Hash} extension
   @returns {Hash} base hash
 */
-SC._object_extend = function _object_extend(base, ext) {
-  if (!ext) throw "SC.Object.extend expects a non-null value.  Did you forget to 'sc_require' something?  Or were you passing a Protocol to extend() as if it were a mixin?";
+SC._object_extend = function _object_extend(base, ext, proto) {
+  if (!ext) { throw "SC.Object.extend expects a non-null value.  Did you forget to 'sc_require' something?  Or were you passing a Protocol to extend() as if it were a mixin?"; }
 
   // set _kvo_cloned for later use
   base._kvo_cloned = null;
@@ -105,7 +133,8 @@ SC._object_extend = function _object_extend(base, ext) {
       // add super to funcs.  Be sure not to set the base of a func to
       // itself to avoid infinite loops.
       if (!value.superclass && (value !== (cur=base[key]))) {
-        value.superclass = value.base = cur || K;
+        value.superclass = cur || K;
+        value.base = proto ? SC._detect_base(value, proto, key) : cur || K;
       }
 
       // handle regular observers
@@ -147,6 +176,10 @@ SC._object_extend = function _object_extend(base, ext) {
         }
         outlets[outlets.length] = key ;
       }
+
+      if (value.isEnhancement) {
+        value = SC._enhance(base[key], value);
+      }
     }
 
     // copy property
@@ -176,6 +209,16 @@ SC._object_extend = function _object_extend(base, ext) {
   return base ;
 } ;
 
+SC._enhance = function(originalFunction, enhancement) {
+  return function() {
+    var args = Array.prototype.slice.call(arguments, 0);
+    var self = this;
+
+    args.unshift(function() { return originalFunction.apply(self, arguments); });
+    return enhancement.apply(this, args);
+  };
+}
+
 /** @class
 
   Root object for the SproutCore framework.  SC.Object is the root class for
@@ -202,7 +245,10 @@ SC._object_extend = function _object_extend(base, ext) {
   @extends SC.Observable
   @since SproutCore 1.0
 */
-SC.Object = function(props) { return this._object_init(props); };
+SC.Object = function(props) {
+  this.__sc_super__ = SC.Object.prototype;
+  return this._object_init(props);
+};
 
 SC.mixin(SC.Object, /** @scope SC.Object */ {
 
@@ -256,7 +302,10 @@ SC.mixin(SC.Object, /** @scope SC.Object */ {
 
     // build a new constructor and copy class methods.  Do this before
     // adding any other properties so they are not overwritten by the copy.
-    var prop, ret = function(props) { return this._object_init(props); } ;
+    var prop, ret = function(props) {
+      this.__sc_super__ = ret.prototype;
+      return this._object_init(props);
+    } ;
     for(prop in this) {
       if (!this.hasOwnProperty(prop)) continue ;
       ret[prop] = this[prop];
@@ -267,6 +316,7 @@ SC.mixin(SC.Object, /** @scope SC.Object */ {
 
     // now setup superclass, guid
     ret.superclass = this ;
+    ret.__sc_super__ = this.prototype;
     SC.generateGuid(ret, "sc"); // setup guid
 
     ret.subclasses = SC.Set.create();
@@ -275,7 +325,7 @@ SC.mixin(SC.Object, /** @scope SC.Object */ {
     // setup new prototype and add properties to it
     var base = (ret.prototype = SC.beget(this.prototype));
     var idx, len = arguments.length;
-    for(idx=0;idx<len;idx++) SC._object_extend(base, arguments[idx]) ;
+    for(idx=0;idx<len;idx++) { SC._object_extend(base, arguments[idx], ret.__sc_super__) ; }
     base.constructor = ret; // save constructor
 
     if (bench) SC.Benchmark.end('SC.Object.extend') ;
@@ -283,7 +333,7 @@ SC.mixin(SC.Object, /** @scope SC.Object */ {
   },
 
   reopen: function(props) {
-    return SC._object_extend(this.prototype, props);
+    return SC._object_extend(this.prototype, props, this.__sc_super__);
   },
 
   /**
@@ -436,7 +486,7 @@ SC.Object.prototype = {
   _object_init: function(extensions) {
     // apply any new properties
     var idx, len = (extensions) ? extensions.length : 0;
-    for(idx=0;idx<len;idx++) SC._object_extend(this, extensions[idx]) ;
+    for(idx=0;idx<len;idx++) { SC._object_extend(this, extensions[idx], this.__sc_super__) ; }
     SC.generateGuid(this, "sc") ; // add guid
     this.init() ; // call real init
 

data/lib/frameworks/sproutcore/frameworks/runtime/system/run_loop.js

@@ -306,3 +306,5 @@ SC.run = function(callback, target, forceNested) {
     if(forceNested || !alreadyRunning) SC.RunLoop.end();
   }
 };
+
+SC.RunLoop.currentRunLoop = SC.RunLoop.create();

data/lib/frameworks/sproutcore/frameworks/runtime/tests/core/itemType.js

@@ -50,11 +50,10 @@ test("SC.isArray" ,function(){
 	var numarray      = [1,2,3],
 	    number        = 23,
 	    strarray      = ["Hello", "Hi"],
-    	string        = "Hello";
+    	string        = "Hello",
 	    object   	    = {},
       length        = {length: 12},
-      fn            = function() {},
-      nodelist      = document.getElementsByTagName("body")
+      fn            = function() {};
 
 	equals( SC.isArray(numarray), true,  "[1,2,3]" );
 	equals( SC.isArray(number),   false, "23" );
@@ -62,7 +61,11 @@ test("SC.isArray" ,function(){
 	equals( SC.isArray(string),   false, '"Hello"' );
 	equals( SC.isArray(object),   false, "{}" );
   equals( SC.isArray(length),   true,  "{length: 12}" );
-  equals( SC.isArray(window),   false, "window" )
-  equals( SC.isArray(fn),       false, "function() {}" )
-  equals( SC.isArray(nodelist), true, "NodeList" )
+  equals( SC.isArray(window),   false, "window" );
+  equals( SC.isArray(fn),       false, "function() {}" );
+
+  if (window.document) {
+    var nodelist      = document.getElementsByTagName("body")
+    equals( SC.isArray(nodelist), true, "NodeList" );
+  }
 });

data/lib/frameworks/sproutcore/frameworks/runtime/tests/core/makeArray.js

@@ -27,4 +27,18 @@ test("should return an array for the object passed ",function(){
 	equals(SC.isArray(ret),true) ;  	
 	ret = SC.makeArray(arrayA);
 	equals(SC.isArray(ret),true) ;
-});
+});
+
+test("isArray should return true for empty arguments", function() {
+  var func = function(foo, bar) {
+    ok(SC.isArray(arguments), "arguments is an array");
+  };
+  func();
+});
+
+test("SC.$A should return an empty array if passed an empty arguments object", function() {
+  var func = function(foo, bar) {
+    equals(SC.$A(arguments).length, 0, "returns an empty array");
+  };
+  func();
+});

data/lib/frameworks/sproutcore/frameworks/runtime/tests/mixins/array.js

@@ -11,6 +11,8 @@
 // BUILT-IN ARRAY
 // 
 
+sc_require('debug/test_suites/array/base');
+
 SC.ArraySuite.generate("built-in Array");
 
 // ..........................................................

data/lib/frameworks/sproutcore/frameworks/runtime/tests/mixins/observable/chained.js

@@ -0,0 +1,31 @@
+module("chained observers");
+
+test("chained observers on enumerable properties are triggered when any item changes", function() {
+  var momma = SC.Object.create({
+    children: [ SC.Object.create({ name: "Bartholomew" }), SC.Object.create({ name: "Agnes" }), SC.Object.create({ name: "Dan" }) ]
+  });
+
+  var family = SC.Object.create({
+    momma: momma
+  });
+
+  var observerFiredCount = 0;
+  family.addObserver('momma.children.@each.name', this, function() {
+    observerFiredCount++;
+  });
+
+  SC.run(function() { family.getPath('momma.children').objectAt(0).set('name', 'Teddy'); });
+
+  equals(observerFiredCount, 1, "observer fired after changing a child item's name");
+
+  //observerFiredCount = 0;
+  //SC.run(function() { family.getPath('momma.children').pushObject(SC.Object.create({ name: "Nancy" })); });
+
+  //equals(observerFiredCount, 1, "observer fired after adding a new item");
+
+  //observerFiredCount = 0;
+  //SC.run(function() { family.getPath('momma.children').objectAt(3).set('name', "Herbert"); });
+
+  //equals(observerFiredCount, 1, "observer fired after changing property on new object");
+});
+

data/lib/frameworks/sproutcore/frameworks/runtime/tests/mixins/observable/observable.js

@@ -427,6 +427,24 @@ test('setting one of two computed properties that depend on a third property sho
   equals(object.get('isOn'), NO, 'object.isOn should be NO');
 });
 
+test("dependent keys should be able to be specified as property paths", function() {
+  var depObj = SC.Object.create({
+    menu: SC.Object.create({
+      price: 5
+    }),
+
+    menuPrice: function() {
+      return this.getPath('menu.price');
+    }.property('menu.price').cacheable()
+  });
+
+  equals(depObj.get('menuPrice'), 5, "precond - initial value returns 5");
+
+  depObj.setPath('menu.price', 6);
+
+  equals(depObj.get('menuPrice'), 6, "cache is properly invalidated after nested property changes");
+});
+
 // ..........................................................
 // OBSERVABLE OBJECTS
 //

data/lib/frameworks/sproutcore/frameworks/runtime/tests/system/logger.js

@@ -9,169 +9,57 @@
 // ie. setting the actual console.log = null means setting up
 // and tearing down no longer work properly.
 
-function testConsole() {
-  return {
-    log: function() { return true; },
-    alert: function() { return true; },
-    debug: function() { return true; },
-    dir: function() { return true; },
-    dirxml: function() { return true; },
-    error: function() { return true; },
-    group: function() { return true; },
-    groupEnd: function() { return true; },
-    info: function() { return true; },
-    profile: function() { return true; },
-    profileEnd: function() { return true; },
-    time: function() { return true; },
-    timeEnd: function() { return true; },
-    trace: function() { return true; },
-    warn: function() { return true; }
-  };
-}
-
-module("SC.Logger", {
-  setup: function() {
-    SC.Logger.set('reporter', testConsole());
-    
-    SC.Logger.debugEnabled = true;
-    SC.Logger.format = true;
-    SC.Logger.fallBackOnLog = true;
-    SC.Logger.fallBackOnAlert = false;
-  },
-  teardown: function() {
-  }
-});
-
-test("exists", function() {
-  equals(SC.Logger.get('exists'), true, "Reporter does exist check");
-  
-  SC.Logger.set('reporter', null);
-  equals(SC.Logger.get('exists'), false, "Reporter does not exist check");
-});
-
-test("log", function() {
-  equals(SC.Logger.log("test"), true, "Function is defined" );
-  
-  var reporter = SC.Logger.get('reporter');
-  reporter.log = null;
-  equals(SC.Logger.log("test"), false, "Function is null");
-  
-  SC.Logger.fallBackOnAlert = true;
-  equals(SC.Logger.log("test"), true, "Function is null -- fallBackOnAlert true");
-});
-
-test("debug", function() {
-  equals(SC.Logger.debug("Debug"), true, "Function is defined");
-
-  SC.Logger.get('reporter').debug = null;
-  equals(SC.Logger.debug("Debug"), true, "Function is null -- fallBackOnLog true");
-
-  SC.Logger.fallBackOnLog = false;
-  equals(SC.Logger.debug("Debug"), false, "Function is null -- fallBackOnLog false");
-});
-
-test("dir", function() {
-  equals(SC.Logger.dir({test:"string"}), true, "Function is defined");
-  
-  SC.Logger.get('reporter').dir = null;
-  equals(SC.Logger.dir({test:"string"}), true, "Function is null -- fallBackOnLog true");
-  
-  SC.Logger.fallBackOnLog = false;
-  equals(SC.Logger.dir({test:"string"}), false, "Function is null -- fallBackOnLog false");
-});
+module("SC.Logger");
 
-test("dirxml", function() {
-  equals(SC.Logger.dirxml("<here id='2'>is some XML</here>"), true, "Function is defined");
+test("addReporter", function() {
+  var reporter = {
+    log: function() { SC.Logger.set('hasBeenCalled', YES); }
+  };
   
-  SC.Logger.get('reporter').dirxml = null;
-  equals(SC.Logger.dirxml("<here id='2'>is some XML</here>"), true, "Function is null -- fallBackOnLog true");
+  SC.Logger.set('hasBeenCalled', NO);
+  SC.Logger.addReporter(reporter);
+  SC.Logger.log();
   
-  SC.Logger.fallBackOnLog = false;
-  equals(SC.Logger.dirxml("<here id='2'>is some XML</here>"), false, "Function is null -- fallBackOnLog false");
+  ok(SC.Logger.get('reporters').indexOf(reporter) > -1, "Reporter was added to reporters array");
+  ok(SC.Logger.get('hasBeenCalled'), "Function as called when invoked on SC.Logger");
+  delete SC.Logger.hasBeenCalled;
 });
 
-test("error", function() {
-  equals(SC.Logger.error("Error"), true, "Function is defined");
+test("clearReporters", function() {
+  var reporter = {
+    log: function() { SC.Logger.set('hasBeenCalled', YES); }
+  };
   
-  SC.Logger.get('reporter').error = null;
-  equals(SC.Logger.error("Error"), true, "Function is null -- fallBackOnLog true");
-
-  SC.Logger.fallBackOnLog = false;
-  equals(SC.Logger.error("Error"), false, "Function is null -- fallBackOnLog false");
-});
-
-test("group", function() {
-  equals(SC.Logger.group("mygroup"), true, "Function is defined");
+  SC.Logger.set('hasBeenCalled', NO);
+  SC.Logger.addReporter(reporter);
   
-  SC.Logger.get('reporter').group = null;
-  equals(SC.Logger.group("mygroup"), false, "Function is null");
-});
-
-test("groupEnd", function() {
-  equals(SC.Logger.groupEnd("mygroup"), true, "Function is defined");
+  ok(SC.Logger.get('reporters').indexOf(reporter) > -1, "precond - Reporter was added to reporters array");
   
-  SC.Logger.get('reporter').groupEnd = null;
-  equals(SC.Logger.groupEnd("mygroup"), false, "Function is null");
-});
-
-test("info", function() {
-  equals(SC.Logger.info("Info"), true, "Function is defined");
+  SC.Logger.clearReporters(YES);
   
-  SC.Logger.get('reporter').info = null;
-  equals(SC.Logger.info("Info"), true, "Function is null -- fallBackOnLog true");
-
-  SC.Logger.fallBackOnLog = false;
-  equals(SC.Logger.info("Info"), false, "Function is null -- fallBackOnLog false");
+  ok(SC.Logger.get('reporters').indexOf(reporter) === -1, "Reporter was removed from reporters array");
 });
 
-test("profile", function() {
-  equals(SC.Logger.profile(), true, "Function is defined");
-  
-  SC.Logger.get('reporter').profile = null;
-  equals(SC.Logger.profile(), false, "Function is null");
+test("log", function() {
+  equals(SC.Logger.log("test"), SC.Logger, "Function is defined and returns SC.Logger");
 });
 
-test("profileEnd", function() {
-  equals(SC.Logger.profileEnd(), true, "Function is defined");
-  
-  SC.Logger.get('reporter').profileEnd = null;
-  equals(SC.Logger.profileEnd(), false, "Function is null");
+test("debug", function() {
+  ok(SC.Logger.debug("Debug"), SC.Logger, "Function is defined and returns SC.Logger");
 });
 
-test("time", function() {
-  equals(SC.Logger.time('mytime'), true, "Function is defined");
-  
-  SC.Logger.get('reporter').time = null;
-  equals(SC.Logger.time('mytime'), false, "Function is null");
+test("dir", function() {
+  equals(SC.Logger.dir({test:"string"}), SC.Logger, "Function is defined and returns SC.Logger");
 });
 
-test("timeEnd", function() {
-  equals(SC.Logger.timeEnd('mytime'), true, "Function is defined");
-  
-  SC.Logger.get('reporter').timeEnd = null;
-  equals(SC.Logger.timeEnd('mytime'), false, "Function is null");
+test("error", function() {
+  equals(SC.Logger.error("Error"), SC.Logger, "Function is defined and returns SC.Logger");
 });
 
-test("trace", function() {
-  equals(SC.Logger.trace(), true, "Function is defined");
-  
-  SC.Logger.get('reporter').trace = null;
-  equals(SC.Logger.trace(), false, "Function is null");
+test("info", function() {
+  equals(SC.Logger.info("Info"), SC.Logger, "Function is defined and returns SC.Logger");
 });
 
 test("warn", function() {
-  equals(SC.Logger.warn("Warn"), true, "Function is defined");
-  
-  SC.Logger.get('reporter').warn = null;
-  equals(SC.Logger.warn("Warn"), true, "Function is null -- fallBackOnLog true");
-
-  SC.Logger.fallBackOnLog = false;
-  equals(SC.Logger.warn("Warn"), false, "Function is null -- fallBackOnLog false");
-});
-
-test("_argumentsToString", function() {
-  equals(SC.Logger._argumentsToString.apply(SC.Logger, ["test", "test2"]), "test" + SC.LOGGER_LOG_DELIMITER + "test2", "Formatting using default delimiter");
-  
-  SC.LOGGER_LOG_DELIMITER = "|";
-  equals(SC.Logger._argumentsToString.apply(SC.Logger, ["test", "test2"]), "test|test2", "Formatting using custom delimiter");
+  equals(SC.Logger.warn("Warn"), SC.Logger, "Function is defined and returns SC.Logger");
 });

data/lib/frameworks/sproutcore/frameworks/runtime/tests/system/object/concatenated_properties.js

@@ -0,0 +1,71 @@
+(function(){
+
+  var klass;
+
+  module("SC.Object Concatenated Properties", {
+    setup: function(){
+      klass = SC.Object.extend({
+        concatenatedProperties: ['values'],
+        values: ['a', 'b', 'c']
+      });
+    }
+  });
+
+  test("concatenates instances", function() {
+    var obj = klass.create({
+      values: ['d', 'e', 'f']
+    });
+
+    var values = obj.get('values'),
+        expected = ['a', 'b', 'c', 'd', 'e', 'f'];
+    ok(values.isEqual(expected), "should concatenate values property (expected: %@, got: %@)".fmt(expected, values));
+  });
+
+  test("concatenates subclasses", function() {
+    var subKlass = klass.extend({
+      values: ['d', 'e', 'f']
+    });
+    var obj = subKlass.create();
+
+    var values = obj.get('values'),
+        expected = ['a', 'b', 'c', 'd', 'e', 'f'];
+    ok(values.isEqual(expected), "should concatenate values property (expected: %@, got: %@)".fmt(expected, values));
+  });
+
+  test("concatenates reopen", function() {
+    klass.reopen({
+      values: ['d', 'e', 'f']
+    });
+    var obj = klass.create();
+
+    var values = obj.get('values'),
+        expected = ['a', 'b', 'c', 'd', 'e', 'f'];
+    ok(values.isEqual(expected), "should concatenate values property (expected: %@, got: %@)".fmt(expected, values));
+  });
+
+  test("concatenates mixin", function() {
+    var mixin = {
+      values: ['d', 'e']
+    };
+    var subKlass = klass.extend(mixin, {
+      values: ['f']
+    });
+    var obj = subKlass.create();
+
+    var values = obj.get('values'),
+        expected = ['a', 'b', 'c', 'd', 'e', 'f'];
+    ok(values.isEqual(expected), "should concatenate values property (expected: %@, got: %@)".fmt(expected, values));
+  });
+
+  test("concatenates reopen, subclass, and instance", function() {
+    klass.reopen({ values: ['d'] });
+    var subKlass = klass.extend({ values: ['e'] });
+    var obj = subKlass.create({ values: ['f'] });
+
+    var values = obj.get('values'),
+        expected = ['a', 'b', 'c', 'd', 'e', 'f'];
+    ok(values.isEqual(expected), "should concatenate values property (expected: %@, got: %@)".fmt(expected, values));
+  });
+
+
+})();