/ - Diff - Synnefo - Greek Research and Technology Network's projects

Revision 326c136c

     // ==========================================================================
     // Project:   Ember - JavaScript Application Framework
     // Copyright: Copyright 2011-2013 Tilde Inc. and contributors
     //            Portions Copyright 2006-2011 Strobe Inc.
     //            Portions Copyright 2008-2011 Apple Inc. All rights reserved.
     // License:   Licensed under MIT license
     //            See https://raw.github.com/emberjs/ember.js/master/LICENSE
     // ==========================================================================
     /*!
      * @overview  Ember - JavaScript Application Framework
      * @copyright Copyright 2011-2014 Tilde Inc. and contributors
      *            Portions Copyright 2006-2011 Strobe Inc.
      *            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
      */
      // Version: 1.2.0
     (function() {
     /*global __fail__*/
-...
+      }
+    }
     Ember.ENV = 'undefined' === typeof ENV ? {} : ENV;
     // This needs to be kept in sync with the logic in
     // `packages/ember-metal/lib/core.js`.
     //
     // This is duplicated here to ensure that `Ember.ENV`
     // is setup even if `Ember` is not loaded yet.
     if (Ember.ENV) {
       // do nothing if Ember.ENV is already setup
     } else if ('undefined' !== typeof EmberENV) {
       Ember.ENV = EmberENV;
     } else if('undefined' !== typeof ENV) {
       Ember.ENV = ENV;
     } else {
       Ember.ENV = {};
+    }
     if (!('MANDATORY_SETTER' in Ember.ENV)) {
       Ember.ENV.MANDATORY_SETTER = true; // default to true for debug dist
-...
     */
     Ember.assert = function(desc, test) {
       if (!test) {
         Ember.Logger.assert(test, desc);
+      }
       if (Ember.testing && !test) {
         // when testing, ensure test failures when assertions fail
         throw new Ember.Error("Assertion Failed: " + desc);
+      }
     };
-...
     // Inform the developer about the Ember Inspector if not installed.
     if (!Ember.testing) {
       if (typeof window !== 'undefined' && window.chrome && window.addEventListener) {
       var isFirefox = typeof InstallTrigger !== 'undefined';
       var isChrome = !!window.chrome && !window.opera;
       if (typeof window !== 'undefined' && (isFirefox || isChrome) && window.addEventListener) {
         window.addEventListener("load", function() {
           if (document.body && document.body.dataset && !document.body.dataset.emberExtension) {
             Ember.debug('For more advanced debugging, install the Ember Inspector from https://chrome.google.com/webstore/detail/ember-inspector/bmdblncegkenkacieihfhpjfppoconhi');
             var downloadURL;
             if(isChrome) {
               downloadURL = 'https://chrome.google.com/webstore/detail/ember-inspector/bmdblncegkenkacieihfhpjfppoconhi';
             } else if(isFirefox) {
               downloadURL = 'https://addons.mozilla.org/en-US/firefox/addon/ember-inspector/'
+            }
             Ember.debug('For more advanced debugging, install the Ember Inspector from ' + downloadURL);
+          }
         }, false);
+      }
-...
     })();
     // ==========================================================================
     // Project:   Ember - JavaScript Application Framework
     // Copyright: Copyright 2011-2013 Tilde Inc. and contributors
     //            Portions Copyright 2006-2011 Strobe Inc.
     //            Portions Copyright 2008-2011 Apple Inc. All rights reserved.
     // License:   Licensed under MIT license
     //            See https://raw.github.com/emberjs/ember.js/master/LICENSE
     // ==========================================================================
     /*!
      * @overview  Ember - JavaScript Application Framework
      * @copyright Copyright 2011-2014 Tilde Inc. and contributors
      *            Portions Copyright 2006-2011 Strobe Inc.
      *            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
      */
      // Version: 1.2.0
     (function() {
     var define, requireModule;
     var define, requireModule, require, requirejs;
     (function() {
       var registry = {}, seen = {};
-...
         registry[name] = { deps: deps, callback: callback };
       };
       requireModule = function(name) {
       requirejs = require = requireModule = function(name) {
       requirejs._eak_seen = registry;
         if (seen[name]) { return seen[name]; }
         seen[name] = {};
         var mod, deps, callback, reified, exports;
         mod = registry[name];
         if (!mod) {
           throw new Error("Module '" + name + "' not found.");
         if (!registry[name]) {
           throw new Error("Could not find module " + name);
+        }
         deps = mod.deps;
         callback = mod.callback;
         reified = [];
         var mod = registry[name],
             deps = mod.deps,
             callback = mod.callback,
             reified = [],
             exports;
         for (var i=0, l=deps.length; i<l; i++) {
           if (deps[i] === 'exports') {
             reified.push(exports = {});
           } else {
             reified.push(requireModule(deps[i]));
             reified.push(requireModule(resolve(deps[i])));
+          }
+        }
         var value = callback.apply(this, reified);
         return seen[name] = exports || value;
         function resolve(child) {
           if (child.charAt(0) !== '.') { return child; }
           var parts = child.split("/");
           var parentBase = name.split("/").slice(0, -1);
           for (var i=0, l=parts.length; i<l; i++) {
             var part = parts[i];
             if (part === '..') { parentBase.pop(); }
             else if (part === '.') { continue; }
             else { parentBase.push(part); }
+          }
           return parentBase.join("/");
+        }
       };
     })();
     (function() {
     /*globals Em:true ENV */
     /*globals Em:true ENV EmberENV MetamorphENV:true */
     /**
     @module ember
-...
       @class Ember
       @static
       @version 1.2.0
       @version 1.4.0
     */
     if ('undefined' === typeof Ember) {
-...
     /**
       @property VERSION
       @type String
       @default '1.2.0'
       @final
       @default '1.4.0'
       @static
     */
     Ember.VERSION = '1.2.0';
     Ember.VERSION = '1.4.0';
     /**
       Standard environmental variables. You can define these in a global `ENV`
       variable before loading Ember to control various configuration
       settings.
       Standard environmental variables. You can define these in a global `EmberENV`
       variable before loading Ember to control various configuration settings.
       For backwards compatibility with earlier versions of Ember the global `ENV`
       variable will be used if `EmberENV` is not defined.
       @property ENV
       @type Hash
     */
     if ('undefined' === typeof ENV) {
       exports.ENV = {};
     // This needs to be kept in sync with the logic in
     // `packages/ember-debug/lib/main.js`.
     if (Ember.ENV) {
       // do nothing if Ember.ENV is already setup
     } else if ('undefined' !== typeof EmberENV) {
       Ember.ENV = EmberENV;
     } else if('undefined' !== typeof ENV) {
       Ember.ENV = ENV;
     } else {
       Ember.ENV = {};
+    }
     Ember.config = Ember.config || {};
     // We disable the RANGE API by default for performance reasons
     if ('undefined' === typeof ENV.DISABLE_RANGE_API) {
       ENV.DISABLE_RANGE_API = true;
     if ('undefined' === typeof Ember.ENV.DISABLE_RANGE_API) {
       Ember.ENV.DISABLE_RANGE_API = true;
+    }
     if ("undefined" === typeof MetamorphENV) {
       exports.MetamorphENV = {};
+    }
     Ember.ENV = Ember.ENV || ENV;
     Ember.config = Ember.config || {};
     MetamorphENV.DISABLE_RANGE_API = Ember.ENV.DISABLE_RANGE_API;
     /**
       Hash of enabled Canary features. Add to before creating your application.
-...
       return -1;
     };
     /**
       Array polyfills to support ES5 features in older browsers.
       @namespace Ember
       @property ArrayPolyfills
     */
     Ember.ArrayPolyfills = {
       map: arrayMap,
       forEach: arrayForEach,
       indexOf: arrayIndexOf
     };
       /**
         Array polyfills to support ES5 features in older browsers.
         @namespace Ember
         @property ArrayPolyfills
       */
       Ember.ArrayPolyfills = {
         map: arrayMap,
         forEach: arrayForEach,
         indexOf: arrayIndexOf
       };
     if (Ember.SHIM_ES5) {
       if (!Array.prototype.map) {
-...
     Ember.Error = function() {
       var tmp = Error.apply(this, arguments);
       // Adds a `stack` property to the given error object that will yield the
       // stack trace at the time captureStackTrace was called.
       // When collecting the stack trace all frames above the topmost call
       // to this function, including that call, will be left out of the
       // stack trace.
       // This is useful because we can hide Ember implementation details
       // that are not very helpful for the user.
       if (Error.captureStackTrace) {
         Error.captureStackTrace(this, Ember.Error);
+      }
       // Unfortunately errors are not enumerable in Chrome (at least), so `for prop in tmp` doesn't work.
       for (var idx = 0; idx < errorProps.length; idx++) {
         this[errorProps[idx]] = tmp[errorProps[idx]];
-...
     Ember.onerror = null;
     /**
       @private
       Wrap code block in a try/catch if `Ember.onerror` is set.
       @private
       @method handleErrors
       @for Ember
       @param {Function} func
-...
     */
     /**
       @private
       Prefix used for guids through out Ember.
       @private
     */
     Ember.GUID_PREFIX = 'ember';
-...
     var MANDATORY_SETTER = Ember.ENV.MANDATORY_SETTER;
     /**
       @private
       A unique key used to assign guids and other private metadata to objects.
       If you inspect an object in your browser debugger you will often see these.
       They can be safely ignored.
-...
       On browsers that support it, these properties are added with enumeration
       disabled so they won't show up when you iterate over your properties.
       @private
       @property GUID_KEY
       @for Ember
       @type String
-...
     };
     /**
       @private
       Generates a new guid, optionally saving the guid to the object that you
       pass in. You will rarely need to use this method. Instead you should
       call `Ember.guidFor(obj)`, which return an existing guid if available.
       @private
       @method generateGuid
       @for Ember
       @param {Object} [obj] Object the guid will be used for. If passed in, the guid will
-...
     };
     /**
       @private
       Returns a unique id for the object. If the object does not yet have a guid,
       one will be assigned to it. You can call this on any object,
       `Ember.Object`-based or not, but be aware that it will add a `_guid`
-...
       You can also use this method on DOM Element objects.
       @private
       @method guidFor
       @for Ember
       @param {Object} obj any object, string, number, Element, or primitive
-...
     // META
     //
     var META_DESC = {
     var META_DESC = Ember.META_DESC = {
       writable:    true,
       configurable: false,
       enumerable:  false,
-...
     */
     Ember.META_KEY = META_KEY;
     // Placeholder for non-writable metas.
     var EMPTY_META = {
       descs: {},
       watching: {}
     };
     if (MANDATORY_SETTER) { EMPTY_META.values = {}; }
     Ember.EMPTY_META = EMPTY_META;
     if (Object.freeze) Object.freeze(EMPTY_META);
     var isDefinePropertySimulated = Ember.platform.defineProperty.isSimulated;
     function Meta(obj) {
-...
       this.source = obj;
+    }
     Meta.prototype = {
       descs: null,
       deps: null,
       watching: null,
       listeners: null,
       cache: null,
       source: null,
       mixins: null,
       bindings: null,
       chains: null,
       chainWatchers: null,
       values: null,
       proto: null
     };
     if (isDefinePropertySimulated) {
       // on platforms that don't support enumerable false
       // make meta fail jQuery.isPlainObject() to hide from
-...
       Meta.prototype.toJSON = function () { };
+    }
     // Placeholder for non-writable metas.
     var EMPTY_META = new Meta(null);
     if (MANDATORY_SETTER) { EMPTY_META.values = {}; }
     Ember.EMPTY_META = EMPTY_META;
     /**
       Retrieves the meta hash for an object. If `writable` is true ensures the
       hash is writable for this object as well.
-...
     };
     /**
       @private
       Wraps the passed function so that `this._super` will point to the superFunc
       when the function is invoked. This is the primitive we use to implement
       calls to super.
       @private
       @method wrap
       @for Ember
       @param {Function} func The function to call
-...
           | 'undefined'   | Undefined value                                      |
           | 'function'    | A function                                           |
           | 'array'       | An instance of Array                                 |
           | 'regexp'      | An instance of RegExp                                |
           | 'date'        | An instance of Date                                  |
           | 'class'       | An Ember class (created using Ember.Object.extend()) |
           | 'instance'    | An Ember object instance                             |
           | 'error'       | An instance of the Error object                      |
-...
       Ember.typeOf(new Boolean(true));      // 'boolean'
       Ember.typeOf(Ember.makeArray);        // 'function'
       Ember.typeOf([1,2,90]);               // 'array'
       Ember.typeOf(/abc/);                  // 'regexp'
       Ember.typeOf(new Date());             // 'date'
       Ember.typeOf(Ember.Object.extend());  // 'class'
       Ember.typeOf(Ember.Object.create());  // 'instance'
       Ember.typeOf(new Error('teamocil'));  // 'error'
-...
       } else if (ret === 'object') {
         if (item instanceof Error) ret = 'error';
         else if (Ember.Object && item instanceof Ember.Object) ret = 'instance';
         else ret = 'object';
         else if (item instanceof Date) ret = 'date';
+      }
       return ret;
     };
     /**
       Convenience method to inspect an object. This method will attempt to
       convert the object into a useful string description.
       It is a pretty simple implementation. If you want something more robust,
       use something like JSDump: https://github.com/NV/jsDump
       @method inspect
       @for Ember
       @param {Object} obj The object you want to inspect.
       @return {String} A description of the object
     */
     Ember.inspect = function(obj) {
       var type = Ember.typeOf(obj);
       if (type === 'array') {
         return '[' + obj + ']';
+      }
       if (type !== 'object') {
         return obj + '';
+      }
       var v, ret = [];
       for(var key in obj) {
         if (obj.hasOwnProperty(key)) {
           v = obj[key];
           if (v === 'toString') { continue; } // ignore useless items
           if (Ember.typeOf(v) === 'function') { v = "function() { ... }"; }
           ret.push(key + ": " + v);
+        }
+      }
       return "{" + ret.join(", ") + "}";
     };
     })();
-...
     (function() {
     var map, forEach, indexOf, splice;
     var map, forEach, indexOf, splice, filter;
     map     = Array.prototype.map     || Ember.ArrayPolyfills.map;
     forEach = Array.prototype.forEach || Ember.ArrayPolyfills.forEach;
     indexOf = Array.prototype.indexOf || Ember.ArrayPolyfills.indexOf;
     filter = Array.prototype.filter || Ember.ArrayPolyfills.filter;
     splice = Array.prototype.splice;
     /**
      * Defines some convenience methods for working with Enumerables.
      * `Ember.EnumerableUtils` uses `Ember.ArrayPolyfills` when necessary.
+     *
      * @class EnumerableUtils
      * @namespace Ember
      * @static
      * */
     var utils = Ember.EnumerableUtils = {
       /**
        * Calls the map function on the passed object with a specified callback. This
        * uses `Ember.ArrayPolyfill`'s-map method when necessary.
+       *
        * @method map
        * @param {Object} obj The object that should be mapped
        * @param {Function} callback The callback to execute
        * @param {Object} thisArg Value to use as this when executing *callback*
+       *
        * @return {Array} An array of mapped values.
        */
       map: function(obj, callback, thisArg) {
         return obj.map ? obj.map.call(obj, callback, thisArg) : map.call(obj, callback, thisArg);
       },
       /**
        * Calls the forEach function on the passed object with a specified callback. This
        * uses `Ember.ArrayPolyfill`'s-forEach method when necessary.
+       *
        * @method forEach
        * @param {Object} obj The object to call forEach on
        * @param {Function} callback The callback to execute
        * @param {Object} thisArg Value to use as this when executing *callback*
+       *
        */
       forEach: function(obj, callback, thisArg) {
         return obj.forEach ? obj.forEach.call(obj, callback, thisArg) : forEach.call(obj, callback, thisArg);
       },
       /**
        * Calls the filter function on the passed object with a specified callback. This
        * uses `Ember.ArrayPolyfill`'s-filter method when necessary.
+       *
        * @method filter
        * @param {Object} obj The object to call filter on
        * @param {Function} callback The callback to execute
        * @param {Object} thisArg Value to use as this when executing *callback*
+       *
        * @return {Array} An array containing the filtered values
        */
       filter: function(obj, callback, thisArg) {
         return obj.filter ? obj.filter.call(obj, callback, thisArg) : filter.call(obj, callback, thisArg);
       },
       /**
        * Calls the indexOf function on the passed object with a specified callback. This
        * uses `Ember.ArrayPolyfill`'s-indexOf method when necessary.
+       *
        * @method indexOf
        * @param {Object} obj The object to call indexOn on
        * @param {Function} callback The callback to execute
        * @param {Object} index The index to start searching from
+       *
        */
       indexOf: function(obj, element, index) {
         return obj.indexOf ? obj.indexOf.call(obj, element, index) : indexOf.call(obj, element, index);
       },
       /**
        * Returns an array of indexes of the first occurrences of the passed elements
        * on the passed object.
+       *
        * ```javascript
        *  var array = [1, 2, 3, 4, 5];
        *  Ember.EnumerableUtils.indexesOf(array, [2, 5]); // [1, 4]
+       *
        *  var fubar = "Fubarr";
        *  Ember.EnumerableUtils.indexesOf(fubar, ['b', 'r']); // [2, 4]
        * ```
+       *
        * @method indexesOf
        * @param {Object} obj The object to check for element indexes
        * @param {Array} elements The elements to search for on *obj*
+       *
        * @return {Array} An array of indexes.
+       *
        */
       indexesOf: function(obj, elements) {
         return elements === undefined ? [] : utils.map(elements, function(item) {
           return utils.indexOf(obj, item);
         });
       },
       /**
        * Adds an object to an array. If the array already includes the object this
        * method has no effect.
+       *
        * @method addObject
        * @param {Array} array The array the passed item should be added to
        * @param {Object} item The item to add to the passed array
+       *
        * @return 'undefined'
        */
       addObject: function(array, item) {
         var index = utils.indexOf(array, item);
         if (index === -1) { array.push(item); }
       },
       /**
        * Removes an object from an array. If the array does not contain the passed
        * object this method has no effect.
+       *
        * @method removeObject
        * @param {Array} array The array to remove the item from.
        * @param {Object} item The item to remove from the passed array.
+       *
        * @return 'undefined'
        */
       removeObject: function(array, item) {
         var index = utils.indexOf(array, item);
         if (index !== -1) { array.splice(index, 1); }
-...
         return ret;
       },
       /**
        * Replaces objects in an array with the passed objects.
+       *
        * ```javascript
        *   var array = [1,2,3];
        *   Ember.EnumerableUtils.replace(array, 1, 2, [4, 5]); // [1, 4, 5]
+       *
        *   var array = [1,2,3];
        *   Ember.EnumerableUtils.replace(array, 1, 1, [4, 5]); // [1, 4, 5, 3]
+       *
        *   var array = [1,2,3];
        *   Ember.EnumerableUtils.replace(array, 10, 1, [4, 5]); // [1, 2, 3, 4, 5]
        * ```
+       *
        * @method replace
        * @param {Array} array The array the objects should be inserted into.
        * @param {Number} idx Starting index in the array to replace. If *idx* >=
        * length, then append to the end of the array.
        * @param {Number} amt Number of elements that should be remove from the array,
        * starting at *idx*
        * @param {Array} objects An array of zero or more objects that should be
        * inserted into the array at *idx*
+       *
        * @return {Array} The changed array.
        */
       replace: function(array, idx, amt, objects) {
         if (array.replace) {
           return array.replace(idx, amt, objects);
-...
+        }
       },
       /**
        * Calculates the intersection of two arrays. This method returns a new array
        * filled with the records that the two passed arrays share with each other.
        * If there is no intersection, an empty array will be returned.
+       *
        * ```javascript
        * var array1 = [1, 2, 3, 4, 5];
        * var array2 = [1, 3, 5, 6, 7];
+       *
        * Ember.EnumerableUtils.intersection(array1, array2); // [1, 3, 5]
+       *
        * var array1 = [1, 2, 3];
        * var array2 = [4, 5, 6];
+       *
        * Ember.EnumerableUtils.intersection(array1, array2); // []
        * ```
+       *
        * @method intersection
        * @param {Array} array1 The first array
        * @param {Array} array2 The second array
+       *
        * @return {Array} The intersection of the two passed arrays.
        */
       intersection: function(array1, array2) {
         var intersection = [];
-...
+    }
     /**
       @private
       Normalizes a target/path pair to reflect that actual target/path that should
       be observed, etc. This takes into account passing in global property
       paths (i.e. a path beginning with a captial letter not defined on the
       target) and * separators.
       @private
       @method normalizeTuple
       @for Ember
       @param {Object} target The current target. May be `null`.
-...
+      }
       // must return some kind of path to be valid else other things will break.
       if (!path || path.length===0) throw new Ember.Error('Invalid Path');
       if (!path || path.length===0) throw new Ember.Error('Path cannot be empty');
       return [ target, path ];
     };
-...
+    }
     /**
       @private
       Suspend listener during callback.
       This should only be used by the target of the event listener
-...
       an object might suspend its property change listener while it is
       setting that property.
       @private
       @method suspendListener
       @for Ember
       @param obj
-...
+    }
     /**
       @private
       Suspends multiple listeners during a callback.
       @private
       @method suspendListeners
       @for Ember
       @param obj
-...
+    }
     /**
       @private
       Return a list of currently watched events
       @private
       @method watchedEvents
       @for Ember
       @param obj
-...
       is skipped, and once listeners are removed. A listener without
       a target is executed on the passed object. If an array of actions
       is not passed, the actions stored on the passed object are invoked.
       @method sendEvent
       @for Ember
       @param obj
-...
       Define a property as a function that should be executed when
       a specified event or events are triggered.
           var Job = Ember.Object.extend({
             logCompleted: Ember.on('completed', function(){
               console.log('Job completed!');
             })
           });
           var job = Job.create();
           Ember.sendEvent(job, 'completed'); // Logs "Job completed!"
       ``` javascript
       var Job = Ember.Object.extend({
         logCompleted: Ember.on('completed', function(){
           console.log('Job completed!');
         })
       });
       var job = Job.create();
       Ember.sendEvent(job, 'completed'); // Logs "Job completed!"
      ```
       @method on
       @for Ember
-...
     (function() {
     var metaFor = Ember.meta,
     var META_KEY = Ember.META_KEY,
         guidFor = Ember.guidFor,
         tryFinally = Ember.tryFinally,
         sendEvent = Ember.sendEvent,
-...
       @return {void}
     */
     function propertyWillChange(obj, keyName) {
       var m = metaFor(obj, false),
           watching = m.watching[keyName] > 0 || keyName === 'length',
           proto = m.proto,
           desc = m.descs[keyName];
       var m = obj[META_KEY],
           watching = (m && m.watching[keyName] > 0) || keyName === 'length',
           proto = m && m.proto,
           desc = m && m.descs[keyName];
       if (!watching) { return; }
       if (proto === obj) { return; }
-...
       @return {void}
     */
     function propertyDidChange(obj, keyName) {
       var m = metaFor(obj, false),
           watching = m.watching[keyName] > 0 || keyName === 'length',
           proto = m.proto,
           desc = m.descs[keyName];
       var m = obj[META_KEY],
           watching = (m && m.watching[keyName] > 0) || keyName === 'length',
           proto = m && m.proto,
           desc = m && m.descs[keyName];
       if (proto === obj) { return; }
-...
+    }
     function chainsDidChange(obj, keyName, m, suppressEvents) {
       if (!(m.hasOwnProperty('chainWatchers') &&
       if (!(m && m.hasOwnProperty('chainWatchers') &&
             m.chainWatchers[keyName])) {
         return;
+      }
-...
       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.
-...
           if (value !== currentValue) {
             Ember.propertyWillChange(obj, keyName);
             if (MANDATORY_SETTER) {
               if (currentValue === undefined && !(keyName in obj)) {
               if ((currentValue === undefined && !(keyName in obj)) || !obj.propertyIsEnumerable(keyName)) {
                 Ember.defineProperty(obj, keyName, null, value); // setup mandatory setter
               } else {
                 meta.values[keyName] = value;
-...
       keyName = path.slice(path.lastIndexOf('.') + 1);
       // get the first part of the part
       path    = path.slice(0, path.length-(keyName.length+1));
       path    = (path === keyName) ? keyName : path.slice(0, path.length-(keyName.length+1));
       // unless the path is this, look up the first part to
       // get the root
-...
+      }
       if (!keyName || keyName.length === 0) {
         throw new Ember.Error('You passed an empty path');
         throw new Ember.Error('Property set failed: You passed an empty path');
+      }
       if (!root) {
         if (tolerant) { return; }
         else { throw new Ember.Error('Object in path '+path+' could not be found or was destroyed.'); }
         else { throw new Ember.Error('Property set failed: object in path "'+path+'" could not be found or was destroyed.'); }
+      }
       return set(root, keyName, value);
-...
     (function() {
     function consoleMethod(name) {
       var consoleObj;
       var consoleObj, logToConsole;
       if (Ember.imports.console) {
         consoleObj = Ember.imports.console;
       } else if (typeof console !== 'undefined') {
-...
       if (method) {
         // Older IE doesn't support apply, but Chrome needs it
         if (method.apply) {
           return function() {
           logToConsole = function() {
             method.apply(consoleObj, arguments);
           };
           logToConsole.displayName = 'console.' + name;
           return logToConsole;
         } else {
           return function() {
             var message = Array.prototype.join.call(arguments, ', ');
-...
        @param {*} arguments
       */
       log:   consoleMethod('log')   || Ember.K,
       /**
        Prints the arguments to the console with a warning icon.
        You can pass as many arguments as you want and they will be joined together with a space.
-...
        @param {*} arguments
       */
       warn:  consoleMethod('warn')  || Ember.K,
       /**
        Prints the arguments to the console with an error icon, red text and a stack race.
        Prints the arguments to the console with an error icon, red text and a stack trace.
        You can pass as many arguments as you want and they will be joined together with a space.
         ```javascript
-...
        @param {*} arguments
       */
       error: consoleMethod('error') || Ember.K,
       /**
        Logs the arguments to the console.
        You can pass as many arguments as you want and they will be joined together with a space.
-...
        @param {*} arguments
       */
       info:  consoleMethod('info')  || Ember.K,
       /**
        Logs the arguments to the console in blue text.
        You can pass as many arguments as you want and they will be joined together with a space.
-...
        @param {*} arguments
       */
       debug: consoleMethod('debug') || consoleMethod('info') || Ember.K,
       /**
        If the value passed into Ember.Logger.assert is not truthy it will throw an error with a stack trace.
       /**
        If the value passed into `Ember.Logger.assert` is not truthy it will throw an error with a stack trace.
         ```javascript
         Ember.Logger.assert(true); // undefined
-...
     };
     /**
       @private
       NOTE: This is a low-level method used by other parts of the API. You almost
       never want to call this method directly. Instead you should use
       `Ember.mixin()` to define new properties.
-...
       }).property('firstName', 'lastName'));
       ```
       @private
       @method defineProperty
       @for Ember
       @param {Object} obj the object to define this property on. This may be a prototype.
-...
         } else {
           obj[keyName] = undefined; // make enumerable
+        }
       } else {
           } else {
         descs[keyName] = undefined; // shadow descriptor in proto
         if (desc == null) {
           value = data;
-...
         MANDATORY_SETTER = Ember.ENV.MANDATORY_SETTER,
         o_defineProperty = Ember.platform.defineProperty;
     Ember.watchKey = function(obj, keyName) {
     Ember.watchKey = function(obj, keyName, meta) {
       // can't watch length on Array - it is special...
       if (keyName === 'length' && typeOf(obj) === 'array') { return; }
       var m = metaFor(obj), watching = m.watching;
       var m = meta || metaFor(obj), watching = m.watching;
       // activate watching first time
       if (!watching[keyName]) {
-...
           m.values[keyName] = obj[keyName];
           o_defineProperty(obj, keyName, {
             configurable: true,
             enumerable: true,
             enumerable: obj.propertyIsEnumerable(keyName),
             set: Ember.MANDATORY_SETTER_FUNCTION,
             get: Ember.DEFAULT_GETTER_FUNCTION(keyName)
           });
-...
     };
     Ember.unwatchKey = function(obj, keyName) {
       var m = metaFor(obj), watching = m.watching;
     Ember.unwatchKey = function(obj, keyName, meta) {
       var m = meta || metaFor(obj), watching = m.watching;
       if (watching[keyName] === 1) {
         watching[keyName] = 0;
-...
         if (MANDATORY_SETTER && keyName in obj) {
           o_defineProperty(obj, keyName, {
             configurable: true,
             enumerable: true,
             writable: true,
             value: m.values[keyName]
             enumerable: obj.propertyIsEnumerable(keyName),
             set: function(val) {
               // redefine to set as enumerable
               o_defineProperty(obj, keyName, {
                 configurable: true,
                 writable: true,
                 enumerable: true,
                 value: val
               });
               delete m.values[keyName];
             },
             get: Ember.DEFAULT_GETTER_FUNCTION(keyName)
           });
           delete m.values[keyName];
+        }
       } else if (watching[keyName] > 1) {
         watching[keyName]--;
-...
         warn = Ember.warn,
         watchKey = Ember.watchKey,
         unwatchKey = Ember.unwatchKey,
         FIRST_KEY = /^([^\.\*]+)/;
         FIRST_KEY = /^([^\.\*]+)/,
         META_KEY = Ember.META_KEY;
     function firstKey(path) {
       return path.match(FIRST_KEY)[0];
-...
       if (!nodes[keyName]) { nodes[keyName] = []; }
       nodes[keyName].push(node);
       watchKey(obj, keyName);
       watchKey(obj, keyName, m);
+    }
     var removeChainWatcher = Ember.removeChainWatcher = function(obj, keyName, node) {
       if (!obj || 'object' !== typeof obj) { return; } // nothing to do
       var m = metaFor(obj, false);
       if (!m.hasOwnProperty('chainWatchers')) { return; } // nothing to do
       var m = obj[META_KEY];
       if (m && !m.hasOwnProperty('chainWatchers')) { return; } // nothing to do
       var nodes = m.chainWatchers;
       var nodes = m && m.chainWatchers;
       if (nodes[keyName]) {
       if (nodes && nodes[keyName]) {
         nodes = nodes[keyName];
         for (var i = 0, l = nodes.length; i < l; i++) {
           if (nodes[i] === node) { nodes.splice(i, 1); }
+        }
+      }
       unwatchKey(obj, keyName);
       unwatchKey(obj, keyName, m);
     };
     // A ChainNode watches a single key on an object. If you provide a starting
-...
     function lazyGet(obj, key) {
       if (!obj) return undefined;
       var meta = metaFor(obj, false);
       var meta = obj[META_KEY];
       // check if object meant only to be a prototype
       if (meta.proto === obj) return undefined;
       if (meta && meta.proto === obj) return undefined;
       if (key === "@each") return get(obj, key);
       // if a CP only return cached value
       var desc = meta.descs[key];
       var desc = meta && meta.descs[key];
       if (desc && desc._cacheable) {
         if (key in meta.cache) {
           return meta.cache[key];
-...
     };
     Ember.finishChains = function(obj) {
       var m = metaFor(obj, false), chains = m.chains;
       // We only create meta if we really have to
       var m = obj[META_KEY], chains = m && m.chains;
       if (chains) {
         if (chains.value() !== obj) {
           m.chains = chains = chains.copy(obj);
           metaFor(obj).chains = chains = chains.copy(obj);
         } else {
           chains.didChange(null);
+        }
         chains.didChange(null);
+      }
     };
-...
     (function() {
     /**
       @module ember-metal
     */
       */
     var forEach = Ember.EnumerableUtils.forEach,
     BRACE_EXPANSION = /^((?:[^\.]*\.)*)\{(.*)\}$/;
     /**
       Expands `pattern`, invoking `callback` for each expansion.
       The only pattern supported is brace-expansion, anything else will be passed
       once to `callback` directly. Brace expansion can only appear at the end of a
       pattern, for example as the last item in a chain.
       Example
       ```js
       function echo(arg){ console.log(arg); }
       Ember.expandProperties('foo.bar', echo);        //=> 'foo.bar'
       Ember.expandProperties('{foo,bar}', echo);      //=> 'foo', 'bar'
       Ember.expandProperties('foo.{bar,baz}', echo);  //=> 'foo.bar', 'foo.baz'
       Ember.expandProperties('{foo,bar}.baz', echo);  //=> '{foo,bar}.baz'
       ```
       @method
       @private
       @param {string} pattern The property pattern to expand.
       @param {function} callback The callback to invoke.  It is invoked once per
       expansion, and is passed the expansion.
       */
     Ember.expandProperties = function (pattern, callback) {
       var match, prefix, list;
       if (match = BRACE_EXPANSION.exec(pattern)) {
         prefix = match[1];
         list = match[2];
         forEach(list.split(','), function (suffix) {
           callback(prefix + suffix);
         });
       } else {
         callback(pattern);
+      }
     };
     })();
-...
     // get the chains for the current object. If the current object has
     // chains inherited from the proto they will be cloned and reconfigured for
     // the current object.
     function chainsFor(obj) {
       var m = metaFor(obj), ret = m.chains;
     function chainsFor(obj, meta) {
       var m = meta || metaFor(obj), ret = m.chains;
       if (!ret) {
         ret = m.chains = new ChainNode(null, null, obj);
       } else if (ret.value() !== obj) {
-...
       return ret;
+    }
     Ember.watchPath = function(obj, keyPath) {
     Ember.watchPath = function(obj, keyPath, meta) {
       // can't watch length on Array - it is special...
       if (keyPath === 'length' && typeOf(obj) === 'array') { return; }
       var m = metaFor(obj), watching = m.watching;
       var m = meta || metaFor(obj), watching = m.watching;
       if (!watching[keyPath]) { // activate watching first time
         watching[keyPath] = 1;
         chainsFor(obj).add(keyPath);
         chainsFor(obj, m).add(keyPath);
       } else {
         watching[keyPath] = (watching[keyPath] || 0) + 1;
+      }
     };
     Ember.unwatchPath = function(obj, keyPath) {
       var m = metaFor(obj), watching = m.watching;
     Ember.unwatchPath = function(obj, keyPath, meta) {
       var m = meta || metaFor(obj), watching = m.watching;
       if (watching[keyPath] === 1) {
         watching[keyPath] = 0;
         chainsFor(obj).remove(keyPath);
         chainsFor(obj, m).remove(keyPath);
       } else if (watching[keyPath] > 1) {
         watching[keyPath]--;
+      }
-...
         generateGuid = Ember.generateGuid,
         IS_PATH = /[\.\*]/;
     // returns true if the passed path is just a keyName
     function isKeyName(path) {
       return path==='*' || !IS_PATH.test(path);
+    }
     /**
       @private
       Starts watching a property on an object. Whenever the property changes,
       invokes `Ember.propertyWillChange` and `Ember.propertyDidChange`. This is the
       primitive used by observers and dependent keys; usually you will never call
       this method directly but instead use higher level methods like
       `Ember.addObserver()`
       @private
       @method watch
       @for Ember
       @param obj
       @param {String} keyName
     */
     Ember.watch = function(obj, _keyPath) {
     Ember.watch = function(obj, _keyPath, m) {
       // can't watch length on Array - it is special...
       if (_keyPath === 'length' && typeOf(obj) === 'array') { return; }
         if (isKeyName(_keyPath)) {
           watchKey(obj, _keyPath);
         } else {
           watchPath(obj, _keyPath);
+        }
       if (isKeyName(_keyPath)) {
         watchKey(obj, _keyPath, m);
       } else {
         watchPath(obj, _keyPath, m);
+      }
     };
     Ember.isWatching = function isWatching(obj, key) {
-...
     Ember.watch.flushPending = Ember.flushPendingChains;
     Ember.unwatch = function(obj, _keyPath) {
     Ember.unwatch = function(obj, _keyPath, m) {
       // can't watch length on Array - it is special...
       if (_keyPath === 'length' && typeOf(obj) === 'array') { return; }
         if (isKeyName(_keyPath)) {
           unwatchKey(obj, _keyPath);
         } else {
           unwatchPath(obj, _keyPath);
+        }
       if (isKeyName(_keyPath)) {
         unwatchKey(obj, _keyPath, m);
       } else {
         unwatchPath(obj, _keyPath, m);
+      }
     };
     /**
       @private
       Call on an object when you first beget it from another object. This will
       setup any chained watchers on the object instance as needed. This method is
       safe to call multiple times.
       @private
       @method rewatch
       @for Ember
       @param obj
     */
     Ember.rewatch = function(obj) {
       var m = metaFor(obj, false), chains = m.chains;
       var m = obj[META_KEY], chains = m && m.chains;
       // make sure the object has its own guid.
       if (GUID_KEY in obj && !obj.hasOwnProperty(GUID_KEY)) {
-...
         watch = Ember.watch,
         unwatch = Ember.unwatch;
     var expandProperties = Ember.expandProperties;
     // ..........................................................
     // DEPENDENT KEYS
-...
         // Increment the number of times depKey depends on keyName.
         keys[keyName] = (keys[keyName] || 0) + 1;
         // Watch the depKey
         watch(obj, depKey);
         watch(obj, depKey, meta);
+      }
+    }
-...
         // Increment the number of times depKey depends on keyName.
         keys[keyName] = (keys[keyName] || 0) - 1;
         // Watch the depKey
         unwatch(obj, depKey);
         unwatch(obj, depKey, meta);
+      }
+    }
-...
     */
     function ComputedProperty(func, opts) {
       this.func = func;
         this._dependentKeys = opts && opts.dependentKeys;
       this._cacheable = (opts && opts.cacheable !== undefined) ? opts.cacheable : true;
       this._dependentKeys = opts && opts.dependentKeys;
       this._readOnly = opts && (opts.readOnly !== undefined || !!opts.readOnly);
+    }
-...
     var ComputedPropertyPrototype = ComputedProperty.prototype;
     /**
       Properties are cacheable by default. Computed property will automatically
       cache the return value of your function until one of the dependent keys changes.
-...
       mode the computed property will not automatically cache the return value.
       ```javascript
       MyApp.outsideService = Ember.Object.create({
       MyApp.outsideService = Ember.Object.extend({
         value: function() {
           return OutsideService.getValue();
         }.property().volatile()
       });
       }).create();
       ```
       @method volatile
-...
       mode the computed property will throw an error when set.
       ```javascript
       MyApp.person = Ember.Object.create({
       MyApp.Person = Ember.Object.extend({
         guid: function() {
           return 'guid-guid-guid';
         }.property().readOnly()
       });
       MyApp.person = MyApp.Person.create();
       MyApp.person.set('guid', 'new-guid'); // will throw an exception
       ```
-...
       arguments containing key paths that this computed property depends on.
       ```javascript
       MyApp.president = Ember.Object.create({
       MyApp.President = Ember.Object.extend({
         fullName: Ember.computed(function() {
           return this.get('firstName') + ' ' + this.get('lastName');
-...
           // and lastName
         }).property('firstName', 'lastName')
       });
       MyApp.president = MyApp.President.create({
         firstName: 'Barack',
         lastName: 'Obama',
       });
       MyApp.president.get('fullName'); // Barack Obama
       ```
       @method property
-...
       @chainable
     */
     ComputedPropertyPrototype.property = function() {
       var addArg;
       var args;
       var args = [];
       var addArg = function (property) {
         args.push(property);
       };
       args = [];
       for (var i = 0, l = arguments.length; i < l; i++) {
           args.push(arguments[i]);
         expandProperties(arguments[i], addArg);
+      }
       this._dependentKeys = args;
         this._dependentKeys = args;
       return this;
     };
-...
           funcArgLength, cachedValue, ret;
       if (this._readOnly) {
         throw new Ember.Error('Cannot Set: ' + keyName + ' on: ' + obj.toString() );
         throw new Ember.Error('Cannot Set: ' + keyName + ' on: ' + Ember.inspect(obj));
+      }
       this._suspended = obj;
-...
       @return {Object} the cached value
     */
     Ember.cacheFor = function cacheFor(obj, key) {
       var cache = metaFor(obj, false).cache;
       var meta = obj[META_KEY],
           cache = meta && meta.cache;
       if (cache && key in cache) {
         return cache[key];
-...
       return ret;
+    }
     function registerComputed(name, macro) {
       Ember.computed[name] = function(dependentKey) {
         var args = a_slice.call(arguments);
         return Ember.computed(dependentKey, function() {
           return macro.apply(this, args);
         });
     var registerComputed, registerComputedWithProperties;
       registerComputed = function (name, macro) {
         Ember.computed[name] = function(dependentKey) {
           var args = a_slice.call(arguments);
           return Ember.computed(dependentKey, function() {
             return macro.apply(this, args);
           });
         };
       };
+    }
     function registerComputedWithProperties(name, macro) {
       Ember.computed[name] = function() {
         var properties = a_slice.call(arguments);
       registerComputedWithProperties = function(name, macro) {
         Ember.computed[name] = function() {
           var properties = a_slice.call(arguments);

... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff