ember-source 1.4.0.beta.3 → 1.4.0.beta.4

data/dist/ember-debug.js

@@ -7,7 +7,7 @@ var Ember = { assert: function() {}, FEATURES: { isEnabled: function() {} } };
  *            Portions Copyright 2008-2011 Apple Inc. All rights reserved.
  * @license   Licensed under MIT license
  *            See https://raw.github.com/emberjs/ember.js/master/LICENSE
- * @version   1.4.0-beta.3
+ * @version   1.4.0-beta.4+pre.88c597fa
  */
 
 

data/dist/ember-runtime.js

@@ -5,7 +5,7 @@
  *            Portions Copyright 2008-2011 Apple Inc. All rights reserved.
  * @license   Licensed under MIT license
  *            See https://raw.github.com/emberjs/ember.js/master/LICENSE
- * @version   1.4.0-beta.3
+ * @version   1.4.0-beta.4+pre.88c597fa
  */
 
 
@@ -198,7 +198,7 @@ if (!Ember.testing) {
  *            Portions Copyright 2008-2011 Apple Inc. All rights reserved.
  * @license   Licensed under MIT license
  *            See https://raw.github.com/emberjs/ember.js/master/LICENSE
- * @version   1.4.0-beta.3
+ * @version   1.4.0-beta.4+pre.88c597fa
  */
 
 
@@ -281,7 +281,7 @@ var define, requireModule, require, requirejs;
 
   @class Ember
   @static
-  @version 1.4.0-beta.3
+  @version 1.4.0-beta.4+pre.88c597fa
 */
 
 if ('undefined' === typeof Ember) {
@@ -308,10 +308,10 @@ Ember.toString = function() { return "Ember"; };
 /**
   @property VERSION
   @type String
-  @default '1.4.0-beta.3'
+  @default '1.4.0-beta.4+pre.88c597fa'
   @static
 */
-Ember.VERSION = '1.4.0-beta.3';
+Ember.VERSION = '1.4.0-beta.4+pre.88c597fa';
 
 /**
   Standard environmental variables. You can define these in a global `EmberENV`
@@ -2933,16 +2933,6 @@ var META_KEY = Ember.META_KEY,
   property is not defined but the object implements the `setUnknownProperty`
   method then that will be invoked as well.
 
-  If you plan to run on IE8 and older browsers then you should use this
-  method anytime you want to set a property on an object that you don't
-  know for sure is private. (Properties beginning with an underscore '_'
-  are considered private.)
-
-  On all newer browsers, you only need to use this method to set
-  properties if the property might not be defined on the object and you want
-  to respect the `setUnknownProperty` handler. Otherwise you can ignore this
-  method.
-
   @method set
   @for Ember
   @param {Object} obj The object to modify.
@@ -3699,12 +3689,7 @@ Ember.defineProperty = function(obj, keyName, desc, data, meta) {
       obj[keyName] = undefined; // make enumerable
     }
 
-    
-      if (desc.func && desc._dependentCPs) {
-        addImplicitCPs(obj, desc._dependentCPs, meta);
-      }
-    
-  } else {
+      } else {
     descs[keyName] = undefined; // shadow descriptor in proto
     if (desc == null) {
       value = data;
@@ -3740,22 +3725,6 @@ Ember.defineProperty = function(obj, keyName, desc, data, meta) {
 };
 
 
-  var addImplicitCPs = function defineImplicitCPs(obj, implicitCPs, meta) {
-    var cp, key, length = implicitCPs.length;
-
-    for (var i=0; i<length; ++i) {
-      cp = implicitCPs[i];
-      key = cp.implicitCPKey;
-
-      Ember.defineProperty(obj, key, cp, undefined, meta);
-
-      if (cp._dependentCPs) {
-        addImplicitCPs(obj, cp._dependentCPs, meta);
-      }
-    }
-  };
-
-
 })();
 
 
@@ -4494,8 +4463,6 @@ var get = Ember.get,
 
 
 
-
-
   var expandProperties = Ember.expandProperties;
 
 
@@ -4658,8 +4625,9 @@ function removeDependentKeys(desc, obj, keyName, meta) {
 function ComputedProperty(func, opts) {
   this.func = func;
   
-    setDependentKeys(this, opts && opts.dependentKeys);
+    this._dependentKeys = opts && opts.dependentKeys;
   
+
   this._cacheable = (opts && opts.cacheable !== undefined) ? opts.cacheable : true;
   this._readOnly = opts && (opts.readOnly !== undefined || !!opts.readOnly);
 }
@@ -4670,14 +4638,6 @@ ComputedProperty.prototype = new Ember.Descriptor();
 var ComputedPropertyPrototype = ComputedProperty.prototype;
 
 
-  ComputedPropertyPrototype.toString = function() {
-    if (this.implicitCPKey) {
-      return this.implicitCPKey;
-    }
-    return Ember.Descriptor.prototype.toString.apply(this, arguments);
-  };
-
-
 /**
   Properties are cacheable by default. Computed property will automatically
   cache the return value of your function until one of the dependent keys changes.
@@ -4783,8 +4743,9 @@ ComputedPropertyPrototype.property = function() {
     }
   
   
-    setDependentKeys(this, args);
+    this._dependentKeys = args;
   
+
   return this;
 };
 
@@ -5046,84 +5007,30 @@ function getProperties(self, propertyNames) {
 var registerComputed, registerComputedWithProperties;
 
 
-  var guidFor = Ember.guidFor,
-      map = Ember.EnumerableUtils.map,
-      filter = Ember.EnumerableUtils.filter,
-      typeOf = Ember.typeOf;
-
-  var implicitKey = function (cp) {
-    return [guidFor(cp)].concat(cp._dependentKeys).join('_');
-  };
-
-  var normalizeDependentKey = function (key) {
-    if (key instanceof Ember.ComputedProperty) {
-      return implicitKey(key);
-    } else if (typeof key === 'string' || key instanceof String || typeof key === 'object' || typeof key === 'number') {
-      return key;
-    } else {
-      Ember.assert('Unexpected dependent key  ' + key + ' of type ' + typeof(key), false);
-    }
-  };
-
-  var normalizeDependentKeys = function (keys) {
-    return map(keys, function (key) {
-      return normalizeDependentKey(key);
-    });
-  };
-
-  var selectDependentCPs = function (keys) {
-    return filter(keys, function (key) {
-      return key instanceof Ember.ComputedProperty;
-    });
-  };
-
-  var setDependentKeys = function(cp, dependentKeys) {
-    if (dependentKeys) {
-      cp._dependentKeys = normalizeDependentKeys(dependentKeys);
-      cp._dependentCPs = selectDependentCPs(dependentKeys);
-      cp.implicitCPKey = implicitKey(cp);
-    } else {
-      cp._dependentKeys = cp._dependentCPs = [];
-      delete cp.implicitCPKey;
-    }
-  };
-  // expose `normalizeDependentKey[s]` so user CP macros can easily support
-  // composition
-  Ember.computed.normalizeDependentKey = normalizeDependentKey;
-  Ember.computed.normalizeDependentKeys = normalizeDependentKeys;
 
   registerComputed = function (name, macro) {
     Ember.computed[name] = function(dependentKey) {
-      var args = normalizeDependentKeys(a_slice.call(arguments));
+      var args = a_slice.call(arguments);
       return Ember.computed(dependentKey, function() {
         return macro.apply(this, args);
       });
     };
   };
 
-
-
   registerComputedWithProperties = function(name, macro) {
     Ember.computed[name] = function() {
-      var args = a_slice.call(arguments);
-      var properties = normalizeDependentKeys(args);
+      var properties = a_slice.call(arguments);
 
       var computed = Ember.computed(function() {
         return macro.apply(this, [getProperties(this, properties)]);
       });
 
-      return computed.property.apply(computed, args);
+      return computed.property.apply(computed, properties);
     };
   };
 
 
 
-  Ember.computed.literal = function (value) {
-    return Ember.computed(function () {
-      return value;
-    });
-  };
-
 
 /**
   A computed property that returns true if the value of the dependent
@@ -5654,51 +5561,6 @@ Ember.computed.oneWay = function(dependentKey) {
   });
 };
 
-if (Ember.FEATURES.isEnabled('computed-read-only')) {
-/**
-  Where `computed.oneWay` provides oneWay bindings, `computed.readOnly` provides
-  a readOnly one way binding. Very often when using `computed.oneWay` one does
-  not also want changes to propogate back up, as they will replace the value.
-
-  This prevents the reverse flow, and also throws an exception when it occurs.
-
-  Example
-
-  ```javascript
-  User = Ember.Object.extend({
-    firstName: null,
-    lastName: null,
-    nickName: Ember.computed.readOnly('firstName')
-  });
-
-  user = User.create({
-    firstName: 'Teddy',
-    lastName:  'Zeenny'
-  });
-
-  user.get('nickName');
-  # 'Teddy'
-
-  user.set('nickName', 'TeddyBear');
-  # throws Exception
-  # throw new Ember.Error('Cannot Set: nickName on: <User:ember27288>' );`
-
-  user.get('firstName');
-  # 'Teddy'
-  ```
-
-  @method computed.readOnly
-  @for Ember
-  @param {String} dependentKey
-  @return {Ember.ComputedProperty} computed property which creates a
-  one way computed property to the original value for property.
-*/
-Ember.computed.readOnly = function(dependentKey) {
-  return Ember.computed(dependentKey, function() {
-    return get(this, dependentKey);
-  }).readOnly();
-};
-}
 /**
   A computed property that acts like a standard getter and setter,
   but returns the value at the provided `defaultPath` if the
@@ -6375,7 +6237,7 @@ define("backburner",
               return true;
             }
           }
-        } else if (window.toString.call(timer) === "[object Array]"){ // we're cancelling a throttle or debounce
+        } else if (Object.prototype.toString.call(timer) === "[object Array]"){ // we're cancelling a throttle or debounce
           return this._cancelItem(findThrottler, throttlers, timer) || 
                    this._cancelItem(findDebouncee, debouncees, timer);
         } else {
@@ -6489,6 +6351,7 @@ define("backburner",
 
     __exports__.Backburner = Backburner;
   });
+
 })();
 
 
@@ -7985,7 +7848,7 @@ Ember.mixin = function(obj) {
 
   Note that mixins extend a constructor's prototype so arrays and object literals
   defined as properties will be shared amongst objects that implement the mixin.
-  If you want to define an property in a mixin that is not shared, you can define
+  If you want to define a property in a mixin that is not shared, you can define
   it either as a computed property or have it be created on initialization of the object.
 
   ```javascript
@@ -12050,54 +11913,7 @@ Ember.String = {
   }
 };
 
-if (Ember.FEATURES.isEnabled("string-humanize")) {
-  /**
-    Returns the Humanized form of a string
-
-    Replaces underscores with spaces, and capitializes first character
-    of string. Also strips "_id" suffixes.
-
-    ```javascript
-    'first_name'.humanize()       // 'First name'
-    'user_id'.humanize()          // 'User'
-    ```
-
-    @method humanize
-    @param {String} str The string to humanize.
-    @return {String} The humanized string.
-  */
-
-  Ember.String.humanize = function(str) {
-    return str.replace(/_id$/, '').
-      replace(/_/g, ' ').
-      replace(/^\w/g, function(s){
-        return s.toUpperCase();
-      });
-  };
-}
-
-if (Ember.FEATURES.isEnabled("string-parameterize")) {
-  /**
-    Transforms a string so that it may be used as part of a 'pretty' / SEO friendly URL.
 
-    ```javascript
-    'My favorite items.'.parameterize();                        // 'my-favorite-items'
-    'action_name'.parameterize();                               // 'action-name'
-    '100 ways Ember.js is better than Angular.'.parameterize(); // '100-ways-emberjs-is-better-than-angular'
-    ```
-
-    @method parameterize
-    @param {String} str The string to parameterize.
-    @return {String} the parameterized string.
-  */
-  Ember.String.parameterize = function(str) {
-    return str.replace(STRING_PARAMETERIZE_REGEXP_1, '-') // replace underscores, slashes and spaces with separator
-              .replace(STRING_PARAMETERIZE_REGEXP_2, '')  // remove non-alphanumeric characters except the separator
-              .replace(STRING_PARAMETERIZE_REGEXP_3, '-') // replace multiple occurring separators
-              .replace(STRING_PARAMETERIZE_REGEXP_4, '')  // trim leading and trailing separators 
-              .toLowerCase();
-  };
-}
 
 
 })();
@@ -12122,13 +11938,7 @@ var fmt = Ember.String.fmt,
     capitalize = Ember.String.capitalize,
     classify = Ember.String.classify;
 
-if (Ember.FEATURES.isEnabled("string-humanize")) {
-  var humanize = Ember.String.humanize;
-}
 
-if (Ember.FEATURES.isEnabled("string-parameterize")) {
-  var parameterize = Ember.String.parameterize;
-}
 
 if (Ember.EXTEND_PROTOTYPES === true || Ember.EXTEND_PROTOTYPES.String) {
 
@@ -12222,30 +12032,8 @@ if (Ember.EXTEND_PROTOTYPES === true || Ember.EXTEND_PROTOTYPES.String) {
     return capitalize(this);
   };
 
-  if (Ember.FEATURES.isEnabled("string-humanize")) {
-    /**
-      See [Ember.String.humanize](/api/classes/Ember.String.html#method_humanize).
-
-      @method humanize
-      @for String
-    */
-    String.prototype.humanize = function() {
-      return humanize(this);
-    };
-  }
-
-  if (Ember.FEATURES.isEnabled("string-parameterize")) {
-    /**
-      See [Ember.String.parameterize](/api/classes/Ember.String.html#method_parameterize).
-
-      @method parameterize
-      @for String
-    */
-    String.prototype.parameterize = function() {
-      return parameterize(this);
-    };
-  }
-
+  
+  
 }
 
 
@@ -14508,11 +14296,23 @@ Ember.Enumerable = Ember.Mixin.create({
     @return {Boolean} `true` if the passed function returns `true` for any item
   */
   any: function(callback, target) {
-    var found = this.find(function(x, idx, i) {
-      return !!callback.call(target, x, idx, i);
-    });
+    var len     = get(this, 'length'),
+        context = popCtx(),
+        found   = false,
+        last    = null,
+        next, idx;
+
+    if (target === undefined) { target = null; }
+
+    for (idx = 0; idx < len && !found; idx++) {
+      next  = this.nextObject(idx, last, context);
+      found = callback.call(target, next, idx, this);
+      last  = next;
+    }
 
-    return typeof found !== 'undefined';
+    next = last = null;
+    context = pushCtx(context);
+    return found;
   },
 
   /**
@@ -15751,20 +15551,22 @@ ReduceComputedPropertyInstanceMeta.prototype = {
   setValue: function(newValue, triggerObservers) {
     // This lets sugars force a recomputation, handy for very simple
     // implementations of eg max.
-    if (newValue !== undefined) {
-      var fireObservers = triggerObservers && (newValue !== this.cache[this.propertyName]);
+    if (newValue === this.cache[this.propertyName]) {
+      return;
+    }
 
-      if (fireObservers) {
-        propertyWillChange(this.context, this.propertyName);
-      }
+    if (triggerObservers) {
+      propertyWillChange(this.context, this.propertyName);
+    }
 
+    if (newValue === undefined) {
+      delete this.cache[this.propertyName];
+    } else {
       this.cache[this.propertyName] = newValue;
+    }
 
-      if (fireObservers) {
-        propertyDidChange(this.context, this.propertyName);
-      }
-    } else {
-      delete this.cache[this.propertyName];
+    if (triggerObservers) {
+      propertyDidChange(this.context, this.propertyName);
     }
   }
 };
@@ -18022,7 +17824,7 @@ Ember.TargetActionSupport = Ember.Mixin.create({
   }).property('actionContext'),
 
   /**
-  Send an "action" with an "actionContext" to a "target". The action, actionContext
+  Send an `action` with an `actionContext` to a `target`. The action, actionContext
   and target will be retrieved from properties of the object. For example:
 
   ```javascript
@@ -18502,7 +18304,7 @@ Ember.ActionHandler = Ember.Mixin.create({
     var hashName;
 
     if (!props._actions) {
-      Ember.assert(this + " 'actions' should not be a function", typeof(props.actions) !== 'function');
+      Ember.assert("'actions' should not be a function", typeof(props.actions) !== 'function');
 
       if (typeOf(props.actions) === 'object') {
         hashName = 'actions';
@@ -21023,8 +20825,7 @@ var get = Ember.get, set = Ember.set, forEach = Ember.EnumerableUtils.forEach,
   ```
 
   The itemController instances will have a `parentController` property set to
-  either the the `parentController` property of the `ArrayController`
-  or to the `ArrayController` instance itself.
+  to the `ArrayController` instance.
 
   @class ArrayController
   @namespace Ember
@@ -21125,6 +20926,15 @@ Ember.ArrayController = Ember.ArrayProxy.extend(Ember.ControllerMixin,
     return Ember.A();
   }),
 
+  /**
+   * Flag to mark as being "virtual". Used to keep this instance
+   * from participating in the parentController hierarchy.
+   *
+   * @private
+   * @type Boolean
+   */
+  _isVirtual: false,
+
   controllerAt: function(idx, object, controllerClass) {
     var container = get(this, 'container'),
         subControllers = get(this, '_subControllers'),
@@ -21138,10 +20948,14 @@ Ember.ArrayController = Ember.ArrayProxy.extend(Ember.ControllerMixin,
     if (!container.has(fullName)) {
       throw new Ember.Error('Could not resolve itemController: "' + controllerClass + '"');
     }
-
+    var parentController;
+    if (this._isVirtual) {
+      parentController = get(this, 'parentController');
+    }
+    parentController = parentController || this;
     subController = container.lookupFactory(fullName).create({
       target: this,
-      parentController: get(this, 'parentController') || this,
+      parentController: parentController,
       content: object
     });