rasputin 0.13.2 → 0.14.0

data/vendor/assets/javascripts/ember-precompiler.js

@@ -15,17 +15,10 @@ console.log = console.info = console.warn = console.error = function(){};
 var jQuery = function() { return jQuery; };
 jQuery.ready = function() { return jQuery; };
 jQuery.inArray = function() { return jQuery; };
+jQuery.jquery = "1.7.1";
 var $ = jQuery;
 
-// Precompiler
-var EmberHandlebars = {
-  precompile: function(string) {
-    // Copied from the Ember codebase. This will need to be updated as Ember updates...
-    var ast = Handlebars.parse(string);
-    var options = { data: true, stringParams: true };
-    var environment = new Ember.Handlebars.Compiler().compile(ast, options);
-    var templateSpec = new Ember.Handlebars.JavaScriptCompiler().compile(environment, options, undefined, true);
-
-    return templateSpec.toString();
-  }
-};
+// Ember
+function precompileEmberHandlebars(string) {
+  return Ember.Handlebars.precompile(string).toString();
+}

data/vendor/assets/javascripts/ember.js

@@ -1608,7 +1608,7 @@ if ('undefined' === typeof Ember) {
 /**
   @namespace
   @name Ember
-  @version 0.9.3
+  @version 0.9.4
 
   All Ember methods and functions are defined inside of this namespace.
   You generally should not add new properties to this namespace as it may be
@@ -1640,10 +1640,10 @@ if ('undefined' !== typeof window) {
 /**
   @static
   @type String
-  @default '0.9.3'
+  @default '0.9.4'
   @constant
 */
-Ember.VERSION = '0.9.3';
+Ember.VERSION = '0.9.4';
 
 /**
   @static
@@ -1664,6 +1664,12 @@ Ember.ENV = 'undefined' === typeof ENV ? {} : ENV;
 */
 Ember.K = function() { return this; };
 
+/**
+  @namespace
+  @name window
+  @description The global window object
+*/
+
 /**
   Define an assertion that will throw an exception if the condition is not 
   met.  Ember build tools will remove any calls to ember_assert() when 
@@ -1729,11 +1735,15 @@ Ember.Logger = window.console || { log: Ember.K, warn: Ember.K, error: Ember.K }
   @class
 
   Platform specific methods and feature detectors needed by the framework.
+
+  @name Ember.platform
 */
 var platform = Ember.platform = {} ;
 
 /**
   Identical to Object.create().  Implements if not available natively.
+  @memberOf Ember.platform
+  @name create
 */
 platform.create = Object.create;
 
@@ -1831,6 +1841,8 @@ if (defineProperty) {
   Identical to Object.defineProperty().  Implements as much functionality
   as possible if not available natively.
 
+  @memberOf Ember.platform
+  @name defineProperty
   @param {Object} obj The object to modify
   @param {String} keyName property name to modify
   @param {Object} desc descriptor hash
@@ -1840,6 +1852,9 @@ platform.defineProperty = defineProperty;
 
 /**
   Set to true if the platform supports native getters and setters.
+
+  @memberOf Ember.platform
+  @name hasPropertyAccessors
 */
 platform.hasPropertyAccessors = true;
 
@@ -2028,8 +2043,6 @@ if (Object.freeze) Object.freeze(EMPTY_META);
   @returns {Hash}
 */
 Ember.meta = function meta(obj, writable) {
-  
-  ember_assert("You must pass an object to Ember.meta. This was probably called from Ember internals, so you probably called a Ember method with undefined that was expecting an object", obj != undefined);
 
   var ret = obj[META_KEY];
   if (writable===false) return ret || EMPTY_META;
@@ -2218,6 +2231,7 @@ var meta = Ember.meta;
 
 var get, set;
 
+/** @private */
 get = function get(obj, keyName) {
   if (keyName === undefined && 'string' === typeof obj) {
     keyName = obj;
@@ -2232,6 +2246,7 @@ get = function get(obj, keyName) {
   return ret;
 };
 
+/** @private */
 set = function set(obj, keyName, value) {
   if (('object'===typeof obj) && !(keyName in obj)) {
     if ('function' === typeof obj.setUnknownProperty) {
@@ -2372,8 +2387,8 @@ function getPath(target, path) {
 }
 
 var TUPLE_RET = [];
-var IS_GLOBAL = /^([A-Z$]|([0-9][A-Z$])).*[\.\*]/;
-var IS_GLOBAL_SET = /^([A-Z$]|([0-9][A-Z$])).*[\.\*]?/;
+var IS_GLOBAL = /^([A-Z$]|([0-9][A-Z$]))/;
+var IS_GLOBAL_PATH = /^([A-Z$]|([0-9][A-Z$])).*[\.\*]/;
 var HAS_THIS  = /^this[\.\*]/;
 var FIRST_KEY = /^([^\.\*]+)/;
 
@@ -2384,7 +2399,7 @@ function firstKey(path) {
 // assumes path is already normalized
 function normalizeTuple(target, path) {
   var hasThis  = HAS_THIS.test(path),
-      isGlobal = !hasThis && IS_GLOBAL.test(path),
+      isGlobal = !hasThis && IS_GLOBAL_PATH.test(path),
       key;
 
   if (!target || isGlobal) target = window;
@@ -2449,9 +2464,14 @@ Ember.normalizeTuple = function(target, path) {
 
 Ember.normalizeTuple.primitive = normalizeTuple;
 
-Ember.getPath = function(root, path) {
-  var hasThis, hasStar, isGlobal;
+Ember.getPath = function(root, path, _checkGlobal) {
+  var hasThis, hasStar, isGlobal, ret;
   
+  // Helpers that operate with 'this' within an #each
+  if (path === '') {
+    return root;
+  }
+
   if (!path && 'string'===typeof root) {
     path = root;
     root = null;
@@ -2467,14 +2487,26 @@ Ember.getPath = function(root, path) {
   // detect complicated paths and normalize them
   path = normalizePath(path);
   hasThis  = HAS_THIS.test(path);
-  isGlobal = !hasThis && IS_GLOBAL.test(path);
-  if (!root || hasThis || isGlobal || hasStar) {
+
+  if (!root || hasThis || hasStar) {
+    if (root && root !== window && IS_GLOBAL.test(path)) {
+      console.warn("Fetching globals with Ember.getPath is deprecated", root, path);
+    }
+
     var tuple = normalizeTuple(root, path);
     root = tuple[0];
     path = tuple[1];
-  } 
-  
-  return getPath(root, path);
+    tuple.length = 0;
+  }
+
+  ret = getPath(root, path);
+
+  if (ret === undefined && root !== window && !hasThis && IS_GLOBAL.test(path) && _checkGlobal !== false) {
+    console.warn("Fetching globals with Ember.getPath is deprecated", root, path);
+    return Ember.getPath(window, path);
+  } else {
+    return ret;
+  }
 };
 
 Ember.setPath = function(root, path, value, tolerant) {
@@ -2488,22 +2520,30 @@ Ember.setPath = function(root, path, value, tolerant) {
   
   path = normalizePath(path);
   if (path.indexOf('*')>0) {
+    if (root && root !== window && IS_GLOBAL.test(path)) {
+      console.warn("Setting globals with Ember.setPath is deprecated", path);
+    };
+
     var tuple = normalizeTuple(root, path);
     root = tuple[0];
     path = tuple[1];
+    tuple.length = 0;
   }
 
   if (path.indexOf('.') > 0) {
     keyName = path.slice(path.lastIndexOf('.')+1);
     path    = path.slice(0, path.length-(keyName.length+1));
-    if (!HAS_THIS.test(path) && IS_GLOBAL_SET.test(path) && path.indexOf('.')<0) {
-      root = window[path]; // special case only works during set...
-    } else if (path !== 'this') {
-      root = Ember.getPath(root, path);
+    if (path !== 'this') {
+      // Remove the `false` when we're done with this deprecation
+      root = Ember.getPath(root, path, false);
+      if (!root && IS_GLOBAL.test(path)) {
+        console.warn("Setting globals with Ember.setPath is deprecated", path);
+        root = Ember.getPath(window, path);
+      }
     }
 
   } else {
-    if (IS_GLOBAL_SET.test(path)) throw new Error('Invalid Path');
+    if (IS_GLOBAL.test(path)) throw new Error('Invalid Path');
     keyName = path;
   }
   
@@ -2735,7 +2775,9 @@ function xformForArgs(args) {
   return function (target, method, params) {
     var obj = params[0], keyName = changeKey(params[1]), val;
     var copy_args = args.slice();
-    if (method.length>2) val = Ember.getPath(obj, keyName);
+    if (method.length>2) {
+      val = Ember.getPath(Ember.isGlobalPath(keyName) ? window : obj, keyName);
+    }
     copy_args.unshift(obj, keyName, val);
     method.apply(target, copy_args);
   };
@@ -3138,9 +3180,10 @@ function hasDesc(descs, keyName) {
       }).property('firstName', 'lastName').cacheable());
 */
 Ember.defineProperty = function(obj, keyName, desc, val) {
-  var m = meta(obj, false), descs = m.descs, watching = m.watching[keyName]>0;
+  var m = meta(obj, false), descs = m.descs, watching = m.watching[keyName]>0, override = true;
 
   if (val === undefined) {
+    override = false;
     val = hasDesc(descs, keyName) ? descs[keyName].teardown(obj, keyName) : obj[keyName];
   } else if (hasDesc(descs, keyName)) {
     descs[keyName].teardown(obj, keyName);
@@ -3161,7 +3204,11 @@ Ember.defineProperty = function(obj, keyName, desc, val) {
     if (descs[keyName]) meta(obj).descs[keyName] = null;
     o_defineProperty(obj, keyName, desc);
   }
-  
+
+  // if key is being watched, override chains that
+  // were initialized with the prototype
+  if (override && watching) Ember.overrideChains(obj, keyName, m);
+
   return this;
 };
 
@@ -3218,19 +3265,6 @@ Ember.createPrototype = function(obj, props) {
   if (META_KEY in ret) Ember.rewatch(ret); // setup watch chains if needed.
   return ret;
 };
-  
-
-/**
-  Tears down the meta on an object so that it can be garbage collected.
-  Multiple calls will have no effect.
-  
-  @param {Object} obj  the object to destroy
-  @returns {void}
-*/
-Ember.destroy = function(obj) {
-  if (obj[META_KEY]) obj[META_KEY] = null; 
-};
-
 
 })({});
 
@@ -3249,6 +3283,7 @@ var normalizeTuple = Ember.normalizeTuple.primitive;
 var normalizePath  = Ember.normalizePath;
 var SIMPLE_PROPERTY = Ember.SIMPLE_PROPERTY;
 var GUID_KEY = Ember.GUID_KEY;
+var META_KEY = Ember.META_KEY;
 var notifyObservers = Ember.notifyObservers;
 
 var FIRST_KEY = /^([^\.\*]+)/;
@@ -3265,17 +3300,17 @@ function isKeyName(path) {
 
 // ..........................................................
 // DEPENDENT KEYS
-// 
+//
 
 var DEP_SKIP = { __emberproto__: true }; // skip some keys and toString
-function iterDeps(methodName, obj, depKey, seen) {
-  
+function iterDeps(method, obj, depKey, seen, meta) {
+
   var guid = guidFor(obj);
   if (!seen[guid]) seen[guid] = {};
   if (seen[guid][depKey]) return ;
   seen[guid][depKey] = true;
-  
-  var deps = meta(obj, false).deps, method = Ember[methodName];
+
+  var deps = meta.deps;
   deps = deps && deps[depKey];
   if (deps) {
     for(var key in deps) {
@@ -3289,18 +3324,18 @@ function iterDeps(methodName, obj, depKey, seen) {
 var WILL_SEEN, DID_SEEN;
 
 // called whenever a property is about to change to clear the cache of any dependent keys (and notify those properties of changes, etc...)
-function dependentKeysWillChange(obj, depKey) {
+function dependentKeysWillChange(obj, depKey, meta) {
   var seen = WILL_SEEN, top = !seen;
   if (top) seen = WILL_SEEN = {};
-  iterDeps('propertyWillChange', obj, depKey, seen);
+  iterDeps(propertyWillChange, obj, depKey, seen, meta);
   if (top) WILL_SEEN = null;
 }
 
 // called whenever a property has just changed to update dependent keys
-function dependentKeysDidChange(obj, depKey) {
+function dependentKeysDidChange(obj, depKey, meta) {
   var seen = DID_SEEN, top = !seen;
   if (top) seen = DID_SEEN = {};
-  iterDeps('propertyDidChange', obj, depKey, seen);
+  iterDeps(propertyDidChange, obj, depKey, seen, meta);
   if (top) DID_SEEN = null;
 }
 
@@ -3436,6 +3471,7 @@ Wp.add = function(path) {
   // put into a queue and try to connect later.
   } else if (!tuple[0]) {
     pendingQueue.push([this, path]);
+    tuple.length = 0;
     return;
 
   // global path, and object already exists
@@ -3446,6 +3482,7 @@ Wp.add = function(path) {
     path = tuple[1];
   }
 
+  tuple.length = 0;
   this.chain(key, path, src, separator);
 };
 
@@ -3470,6 +3507,7 @@ Wp.remove = function(path) {
     path = tuple[1];
   }
 
+  tuple.length = 0;
   this.unchain(key, path);
 };
 
@@ -3545,7 +3583,7 @@ Wp.chainDidChange = function(chain, path, depth) {
   }
 };
 
-Wp.didChange = function() {
+Wp.didChange = function(suppressEvent) {
   // invalidate my own value first.
   if (this._watching) {
     var obj = this._parent.value();
@@ -3567,10 +3605,12 @@ Wp.didChange = function() {
   if (chains) {
     for(var key in chains) {
       if (!chains.hasOwnProperty(key)) continue;
-      chains[key].didChange();
+      chains[key].didChange(suppressEvent);
     }
   }
 
+  if (suppressEvent) return;
+
   // and finally tell parent about my path changing...
   if (this._parent) this._parent.chainDidChange(this, this._key, 1);
 };
@@ -3590,26 +3630,30 @@ function chainsFor(obj) {
 
 
 
-function notifyChains(obj, keyName, methodName) {
-  var m = meta(obj, false);
+function notifyChains(obj, m, keyName, methodName, arg) {
   var nodes = m.chainWatchers;
+
   if (!nodes || nodes.__emberproto__ !== obj) return; // nothing to do
 
   nodes = nodes[keyName];
   if (!nodes) return;
-  
+
   for(var key in nodes) {
     if (!nodes.hasOwnProperty(key)) continue;
-    nodes[key][methodName](obj, keyName);
+    nodes[key][methodName](arg);
   }
 }
 
-function chainsWillChange(obj, keyName) {
-  notifyChains(obj, keyName, 'willChange');
+Ember.overrideChains = function(obj, keyName, m) {
+  notifyChains(obj, m, keyName, 'didChange', true);
 }
 
-function chainsDidChange(obj, keyName) {
-  notifyChains(obj, keyName, 'didChange');
+function chainsWillChange(obj, keyName, m) {
+  notifyChains(obj, m, keyName, 'willChange');
+}
+
+function chainsDidChange(obj, keyName, m) {
+  notifyChains(obj, m, keyName, 'didChange');
 }
 
 // ..........................................................
@@ -3732,12 +3776,12 @@ Ember.rewatch = function(obj) {
     
   @returns {void}
 */
-Ember.propertyWillChange = function(obj, keyName) {
+var propertyWillChange = Ember.propertyWillChange = function(obj, keyName) {
   var m = meta(obj, false), proto = m.proto, desc = m.descs[keyName];
   if (proto === obj) return ;
   if (desc && desc.willChange) desc.willChange(obj, keyName);
-  dependentKeysWillChange(obj, keyName);
-  chainsWillChange(obj, keyName);
+  dependentKeysWillChange(obj, keyName, m);
+  chainsWillChange(obj, keyName, m);
   Ember.notifyBeforeObservers(obj, keyName);
 };
 
@@ -3758,15 +3802,56 @@ Ember.propertyWillChange = function(obj, keyName) {
     
   @returns {void}
 */
-Ember.propertyDidChange = function(obj, keyName) {
+var propertyDidChange = Ember.propertyDidChange = function(obj, keyName) {
   var m = meta(obj, false), proto = m.proto, desc = m.descs[keyName];
   if (proto === obj) return ;
   if (desc && desc.didChange) desc.didChange(obj, keyName);
-  dependentKeysDidChange(obj, keyName);
-  chainsDidChange(obj, keyName);
+  dependentKeysDidChange(obj, keyName, m);
+  chainsDidChange(obj, keyName, m);
   Ember.notifyObservers(obj, keyName);
 };
 
+var NODE_STACK = []
+
+/**
+  Tears down the meta on an object so that it can be garbage collected.
+  Multiple calls will have no effect.
+  
+  @param {Object} obj  the object to destroy
+  @returns {void}
+*/
+Ember.destroy = function (obj) {
+  var meta = obj[META_KEY], node, nodes, key, nodeObject;
+  if (meta) {
+    obj[META_KEY] = null;
+    // remove chainWatchers to remove circular references that would prevent GC
+    node = meta.chains;
+    if (node) {
+      NODE_STACK.push(node);
+      // process tree
+      while (NODE_STACK.length > 0) {
+        node = NODE_STACK.pop();
+        // push children
+        nodes = node._chains;
+        if (nodes) {
+          for (key in nodes) {
+            if (nodes.hasOwnProperty(key)) {
+              NODE_STACK.push(nodes[key]);
+            }
+          }
+        }
+        // remove chainWatcher in node object
+        if (node._watching) {
+          nodeObject = node._object;
+          if (nodeObject) {
+            removeChainWatcher(nodeObject, node._key, node);
+          }
+        }
+      }
+    }
+  }
+};
+
 })({});
 
 
@@ -3802,8 +3887,20 @@ function invoke(target, method, args, ignore) {
   if (args && ignore>0) {
     args = args.length>ignore ? slice.call(args, ignore) : null;
   }
-  // IE8's Function.prototype.apply doesn't accept undefined/null arguments.
-  return method.apply(target || this, args || []);
+
+  // Unfortunately in some browsers we lose the backtrace if we rethrow the existing error,
+  // so in the event that we don't have an `onerror` handler we don't wrap in a try/catch
+  if ('function' === typeof Ember.onerror) {
+    try {
+      // IE8's Function.prototype.apply doesn't accept undefined/null arguments.
+      return method.apply(target || this, args || []);
+    } catch (error) {
+      Ember.onerror(error);
+    }
+  } else {
+    // IE8's Function.prototype.apply doesn't accept undefined/null arguments.
+    return method.apply(target || this, args || []);
+  }
 }
 
 
@@ -3948,8 +4045,11 @@ Ember.run = run = function(target, method) {
 
   var ret, loop;
   run.begin();
-  if (target || method) ret = invoke(target, method, arguments, 2);
-  run.end();
+  try {
+    if (target || method) ret = invoke(target, method, arguments, 2);
+  } finally {
+    run.end();
+  }
   return ret;
 };
 
@@ -4257,11 +4357,17 @@ Ember.run.cancel = function(timer) {
   delete timers[timer];
 };
 
-
 // ..........................................................
 // DEPRECATED API
 //
 
+/**
+  @namespace
+  @name Ember.RunLoop
+  @deprecated
+  @description Compatibility for Ember.run
+*/
+
 /**
   @deprecated
   @method
@@ -4394,7 +4500,8 @@ var NOT = {
 var get     = Ember.get,
     getPath = Ember.getPath,
     setPath = Ember.setPath,
-    guidFor = Ember.guidFor;
+    guidFor = Ember.guidFor,
+    isGlobalPath = Ember.isGlobalPath;
 
 // Applies a binding's transformations against a value.
 function getTransformedValue(binding, val, obj, dir) {
@@ -4422,9 +4529,18 @@ function empty(val) {
   return val===undefined || val===null || val==='' || (Ember.isArray(val) && get(val, 'length')===0) ;
 }
 
+function getPathWithGlobals(obj, path) {
+  return getPath(isGlobalPath(path) ? window : obj, path);
+}
+
 function getTransformedFromValue(obj, binding) {
-  var operation = binding._operation;
-  var fromValue = operation ? operation(obj, binding._from, binding._operand) : getPath(obj, binding._from);
+  var operation = binding._operation,
+      fromValue;
+  if (operation) {
+    fromValue = operation(obj, binding._from, binding._operand);
+  } else {
+    fromValue = getPathWithGlobals(obj, binding._from);
+  }
   return getTransformedValue(binding, fromValue, obj, 'to');
 }
 
@@ -4434,177 +4550,17 @@ function getTransformedToValue(obj, binding) {
 }
 
 var AND_OPERATION = function(obj, left, right) {
-  return getPath(obj, left) && getPath(obj, right);
+  return getPathWithGlobals(obj, left) && getPathWithGlobals(obj, right);
 };
 
 var OR_OPERATION = function(obj, left, right) {
-  return getPath(obj, left) || getPath(obj, right);
+  return getPathWithGlobals(obj, left) || getPathWithGlobals(obj, right);
 };
 
 // ..........................................................
 // BINDING
 //
 
-/**
-  @class
-
-  A binding simply connects the properties of two objects so that whenever the
-  value of one property changes, the other property will be changed also. You
-  do not usually work with Binding objects directly but instead describe
-  bindings in your class definition using something like:
-
-        valueBinding: "MyApp.someController.title"
-
-  This will create a binding from `MyApp.someController.title` to the `value`
-  property of your object instance automatically. Now the two values will be
-  kept in sync.
-
-  ## Customizing Your Bindings
-
-  In addition to synchronizing values, bindings can also perform some basic
-  transforms on values. These transforms can help to make sure the data fed
-  into one object always meets the expectations of that object regardless of
-  what the other object outputs.
-
-  To customize a binding, you can use one of the many helper methods defined
-  on Ember.Binding like so:
-
-        valueBinding: Ember.Binding.single("MyApp.someController.title")
-
-  This will create a binding just like the example above, except that now the
-  binding will convert the value of `MyApp.someController.title` to a single
-  object (removing any arrays) before applying it to the `value` property of
-  your object.
-
-  You can also chain helper methods to build custom bindings like so:
-
-        valueBinding: Ember.Binding.single("MyApp.someController.title").notEmpty("(EMPTY)")
-
-  This will force the value of MyApp.someController.title to be a single value
-  and then check to see if the value is "empty" (null, undefined, empty array,
-  or an empty string). If it is empty, the value will be set to the string
-  "(EMPTY)".
-
-  ## One Way Bindings
-
-  One especially useful binding customization you can use is the `oneWay()`
-  helper. This helper tells Ember that you are only interested in
-  receiving changes on the object you are binding from. For example, if you
-  are binding to a preference and you want to be notified if the preference
-  has changed, but your object will not be changing the preference itself, you
-  could do:
-
-        bigTitlesBinding: Ember.Binding.oneWay("MyApp.preferencesController.bigTitles")
-
-  This way if the value of MyApp.preferencesController.bigTitles changes the
-  "bigTitles" property of your object will change also. However, if you
-  change the value of your "bigTitles" property, it will not update the
-  preferencesController.
-
-  One way bindings are almost twice as fast to setup and twice as fast to
-  execute because the binding only has to worry about changes to one side.
-
-  You should consider using one way bindings anytime you have an object that
-  may be created frequently and you do not intend to change a property; only
-  to monitor it for changes. (such as in the example above).
-
-  ## Adding Custom Transforms
-
-  In addition to using the standard helpers provided by Ember, you can
-  also defined your own custom transform functions which will be used to
-  convert the value. To do this, just define your transform function and add
-  it to the binding with the transform() helper. The following example will
-  not allow Integers less than ten. Note that it checks the value of the
-  bindings and allows all other values to pass:
-
-        valueBinding: Ember.Binding.transform(function(value, binding) {
-          return ((Ember.typeOf(value) === 'number') && (value < 10)) ? 10 : value;
-        }).from("MyApp.someController.value")
-
-  If you would like to instead use this transform on a number of bindings,
-  you can also optionally add your own helper method to Ember.Binding. This
-  method should simply return the value of `this.transform()`. The example
-  below adds a new helper called `notLessThan()` which will limit the value to
-  be not less than the passed minimum:
-
-      Ember.Binding.reopen({
-        notLessThan: function(minValue) {
-          return this.transform(function(value, binding) {
-            return ((Ember.typeOf(value) === 'number') && (value < minValue)) ? minValue : value;
-          });
-        }
-      });
-
-  You could specify this in your core.js file, for example. Then anywhere in
-  your application you can use it to define bindings like so:
-
-        valueBinding: Ember.Binding.from("MyApp.someController.value").notLessThan(10)
-
-  Also, remember that helpers are chained so you can use your helper along
-  with any other helpers. The example below will create a one way binding that
-  does not allow empty values or values less than 10:
-
-        valueBinding: Ember.Binding.oneWay("MyApp.someController.value").notEmpty().notLessThan(10)
-
-  ## How to Manually Adding Binding
-
-  All of the examples above show you how to configure a custom binding, but
-  the result of these customizations will be a binding template, not a fully
-  active binding. The binding will actually become active only when you
-  instantiate the object the binding belongs to. It is useful however, to
-  understand what actually happens when the binding is activated.
-
-  For a binding to function it must have at least a "from" property and a "to"
-  property. The from property path points to the object/key that you want to
-  bind from while the to path points to the object/key you want to bind to.
-
-  When you define a custom binding, you are usually describing the property
-  you want to bind from (such as "MyApp.someController.value" in the examples
-  above). When your object is created, it will automatically assign the value
-  you want to bind "to" based on the name of your binding key. In the
-  examples above, during init, Ember objects will effectively call
-  something like this on your binding:
-
-        binding = Ember.Binding.from(this.valueBinding).to("value");
-
-  This creates a new binding instance based on the template you provide, and
-  sets the to path to the "value" property of the new object. Now that the
-  binding is fully configured with a "from" and a "to", it simply needs to be
-  connected to become active. This is done through the connect() method:
-
-        binding.connect(this);
-
-  Note that when you connect a binding you pass the object you want it to be
-  connected to.  This object will be used as the root for both the from and
-  to side of the binding when inspecting relative paths.  This allows the
-  binding to be automatically inherited by subclassed objects as well.
-
-  Now that the binding is connected, it will observe both the from and to side
-  and relay changes.
-
-  If you ever needed to do so (you almost never will, but it is useful to
-  understand this anyway), you could manually create an active binding by
-  using the Ember.bind() helper method. (This is the same method used by
-  to setup your bindings on objects):
-
-        Ember.bind(MyApp.anotherObject, "value", "MyApp.someController.value");
-
-  Both of these code fragments have the same effect as doing the most friendly
-  form of binding creation like so:
-
-        MyApp.anotherObject = Ember.Object.create({
-          valueBinding: "MyApp.someController.value",
-
-          // OTHER CODE FOR THIS OBJECT...
-
-        });
-
-  Ember's built in binding creation method makes it easy to automatically
-  create bindings for you. You should always use the highest-level APIs
-  available, even if you understand how to it works underneath.
-
-  @since Ember 0.9
-*/
 var K = function() {};
 var Binding = function(toPath, fromPath) {
   var self;
@@ -4627,7 +4583,7 @@ var Binding = function(toPath, fromPath) {
 
 K.prototype = Binding.prototype;
 
-Binding.prototype = {
+Binding.prototype = /** @scope Ember.Binding.prototype */ {
   // ..........................................................
   // CONFIG
   //
@@ -4951,7 +4907,7 @@ Binding.prototype = {
 
     // get the direction of the binding for the object we are
     // synchronizing from
-    var guid = guidFor(obj), direction = this[guid], val, transformedValue;
+    var guid = guidFor(obj), direction = this[guid];
 
     var fromPath = this._from, toPath = this._to;
 
@@ -4965,13 +4921,13 @@ Binding.prototype = {
 
     // if we're synchronizing from the remote object...
     if (direction === 'fwd') {
-      if (log) { Ember.Logger.log(' ', this.toString(), val, '->', fromValue, obj); }
-      Ember.trySetPath(obj, toPath, fromValue);
+      if (log) { Ember.Logger.log(' ', this.toString(), toValue, '->', fromValue, obj); }
+      Ember.trySetPath(Ember.isGlobalPath(toPath) ? window : obj, toPath, fromValue);
 
     // if we're synchronizing *to* the remote object
     } else if (direction === 'back') {// && !this._oneWay) {
-      if (log) { Ember.Logger.log(' ', this.toString(), val, '<-', fromValue, obj); }
-      Ember.trySetPath(obj, fromPath, toValue);
+      if (log) { Ember.Logger.log(' ', this.toString(), toValue, '<-', fromValue, obj); }
+      Ember.trySetPath(Ember.isGlobalPath(fromPath) ? window : obj, fromPath, toValue);
     }
   }
 
@@ -4985,7 +4941,8 @@ function mixinProperties(to, from) {
   }
 }
 
-mixinProperties(Binding, {
+mixinProperties(Binding,
+/** @scope Ember.Binding */ {
 
   /**
     @see Ember.Binding.prototype.from
@@ -5103,13 +5060,182 @@ mixinProperties(Binding, {
 
 });
 
-Ember.Binding = Binding;
-
 /**
-  Global helper method to create a new binding.  Just pass the root object
-  along with a to and from path to create and connect the binding.  The new
-  binding object will be returned which you can further configure with
-  transforms and other conditions.
+  @class
+
+  A binding simply connects the properties of two objects so that whenever the
+  value of one property changes, the other property will be changed also. You
+  do not usually work with Binding objects directly but instead describe
+  bindings in your class definition using something like:
+
+        valueBinding: "MyApp.someController.title"
+
+  This will create a binding from `MyApp.someController.title` to the `value`
+  property of your object instance automatically. Now the two values will be
+  kept in sync.
+
+  ## Customizing Your Bindings
+
+  In addition to synchronizing values, bindings can also perform some basic
+  transforms on values. These transforms can help to make sure the data fed
+  into one object always meets the expectations of that object regardless of
+  what the other object outputs.
+
+  To customize a binding, you can use one of the many helper methods defined
+  on Ember.Binding like so:
+
+        valueBinding: Ember.Binding.single("MyApp.someController.title")
+
+  This will create a binding just like the example above, except that now the
+  binding will convert the value of `MyApp.someController.title` to a single
+  object (removing any arrays) before applying it to the `value` property of
+  your object.
+
+  You can also chain helper methods to build custom bindings like so:
+
+        valueBinding: Ember.Binding.single("MyApp.someController.title").notEmpty("(EMPTY)")
+
+  This will force the value of MyApp.someController.title to be a single value
+  and then check to see if the value is "empty" (null, undefined, empty array,
+  or an empty string). If it is empty, the value will be set to the string
+  "(EMPTY)".
+
+  ## One Way Bindings
+
+  One especially useful binding customization you can use is the `oneWay()`
+  helper. This helper tells Ember that you are only interested in
+  receiving changes on the object you are binding from. For example, if you
+  are binding to a preference and you want to be notified if the preference
+  has changed, but your object will not be changing the preference itself, you
+  could do:
+
+        bigTitlesBinding: Ember.Binding.oneWay("MyApp.preferencesController.bigTitles")
+
+  This way if the value of MyApp.preferencesController.bigTitles changes the
+  "bigTitles" property of your object will change also. However, if you
+  change the value of your "bigTitles" property, it will not update the
+  preferencesController.
+
+  One way bindings are almost twice as fast to setup and twice as fast to
+  execute because the binding only has to worry about changes to one side.
+
+  You should consider using one way bindings anytime you have an object that
+  may be created frequently and you do not intend to change a property; only
+  to monitor it for changes. (such as in the example above).
+
+  ## Adding Custom Transforms
+
+  In addition to using the standard helpers provided by Ember, you can
+  also defined your own custom transform functions which will be used to
+  convert the value. To do this, just define your transform function and add
+  it to the binding with the transform() helper. The following example will
+  not allow Integers less than ten. Note that it checks the value of the
+  bindings and allows all other values to pass:
+
+        valueBinding: Ember.Binding.transform(function(value, binding) {
+          return ((Ember.typeOf(value) === 'number') && (value < 10)) ? 10 : value;
+        }).from("MyApp.someController.value")
+
+  If you would like to instead use this transform on a number of bindings,
+  you can also optionally add your own helper method to Ember.Binding. This
+  method should simply return the value of `this.transform()`. The example
+  below adds a new helper called `notLessThan()` which will limit the value to
+  be not less than the passed minimum:
+
+      Ember.Binding.reopen({
+        notLessThan: function(minValue) {
+          return this.transform(function(value, binding) {
+            return ((Ember.typeOf(value) === 'number') && (value < minValue)) ? minValue : value;
+          });
+        }
+      });
+
+  You could specify this in your core.js file, for example. Then anywhere in
+  your application you can use it to define bindings like so:
+
+        valueBinding: Ember.Binding.from("MyApp.someController.value").notLessThan(10)
+
+  Also, remember that helpers are chained so you can use your helper along
+  with any other helpers. The example below will create a one way binding that
+  does not allow empty values or values less than 10:
+
+        valueBinding: Ember.Binding.oneWay("MyApp.someController.value").notEmpty().notLessThan(10)
+
+  Finally, it's also possible to specify bi-directional transforms. To do this,
+  you can pass a hash to `transform` with `to` and `from`. In the following
+  example, we are expecting a lowercase string that we want to transform to
+  uppercase.
+
+        valueBinding: Ember.Binding.transform({
+          to:   function(value, binding) { return value.toUpperCase(); },
+          from: function(value, binding) { return value.toLowerCase(); }
+
+  ## How to Manually Adding Binding
+
+  All of the examples above show you how to configure a custom binding, but
+  the result of these customizations will be a binding template, not a fully
+  active binding. The binding will actually become active only when you
+  instantiate the object the binding belongs to. It is useful however, to
+  understand what actually happens when the binding is activated.
+
+  For a binding to function it must have at least a "from" property and a "to"
+  property. The from property path points to the object/key that you want to
+  bind from while the to path points to the object/key you want to bind to.
+
+  When you define a custom binding, you are usually describing the property
+  you want to bind from (such as "MyApp.someController.value" in the examples
+  above). When your object is created, it will automatically assign the value
+  you want to bind "to" based on the name of your binding key. In the
+  examples above, during init, Ember objects will effectively call
+  something like this on your binding:
+
+        binding = Ember.Binding.from(this.valueBinding).to("value");
+
+  This creates a new binding instance based on the template you provide, and
+  sets the to path to the "value" property of the new object. Now that the
+  binding is fully configured with a "from" and a "to", it simply needs to be
+  connected to become active. This is done through the connect() method:
+
+        binding.connect(this);
+
+  Note that when you connect a binding you pass the object you want it to be
+  connected to.  This object will be used as the root for both the from and
+  to side of the binding when inspecting relative paths.  This allows the
+  binding to be automatically inherited by subclassed objects as well.
+
+  Now that the binding is connected, it will observe both the from and to side
+  and relay changes.
+
+  If you ever needed to do so (you almost never will, but it is useful to
+  understand this anyway), you could manually create an active binding by
+  using the Ember.bind() helper method. (This is the same method used by
+  to setup your bindings on objects):
+
+        Ember.bind(MyApp.anotherObject, "value", "MyApp.someController.value");
+
+  Both of these code fragments have the same effect as doing the most friendly
+  form of binding creation like so:
+
+        MyApp.anotherObject = Ember.Object.create({
+          valueBinding: "MyApp.someController.value",
+
+          // OTHER CODE FOR THIS OBJECT...
+
+        });
+
+  Ember's built in binding creation method makes it easy to automatically
+  create bindings for you. You should always use the highest-level APIs
+  available, even if you understand how to it works underneath.
+
+  @since Ember 0.9
+*/
+Ember.Binding = Binding;
+
+/**
+  Global helper method to create a new binding.  Just pass the root object
+  along with a to and from path to create and connect the binding.  The new
+  binding object will be returned which you can further configure with
+  transforms and other conditions.
 
   @param {Object} obj
     The root object of the transform.
@@ -5210,6 +5336,9 @@ function ComputedProperty(func, opts) {
   this._dependentKeys = opts && opts.dependentKeys;
 }
 
+/**
+  @constructor
+*/
 Ember.ComputedProperty = ComputedProperty;
 ComputedProperty.prototype = new Ember.Descriptor();
 
@@ -5265,6 +5394,10 @@ function mkCpSetter(keyName, desc) {
   };
 }
 
+/**
+  @extends Ember.ComputedProperty
+  @private
+*/
 var Cp = ComputedProperty.prototype;
 
 /**
@@ -5434,6 +5567,7 @@ var array_Slice = Array.prototype.slice;
 
 */
 
+/** @private */
 var metaPath = Ember.metaPath;
 
 // Gets the set of all actions, keyed on the guid of each action's
@@ -5505,6 +5639,8 @@ function invokeEvents(targetSet, params) {
   parameters passed to an observer. if you pass an xform function, it will
   be invoked and is able to translate event listener parameters into the form
   that observers are expecting.
+
+  @name Ember.addListener
 */
 function addListener(obj, eventName, target, method, xform) {
   ember_assert("You must pass at least an object and event name to Ember.addListener", !!obj && !!eventName);
@@ -5563,7 +5699,6 @@ function watchedEvents(obj) {
 }
 
 function sendEvent(obj, eventName) {
-  ember_assert("You must pass an object and event name to Ember.sendEvent", !!obj && !!eventName);
 
   // first give object a chance to handle it
   if (obj !== Ember && 'function' === typeof obj.sendEvent) {
@@ -5639,6 +5774,7 @@ var Mixin, MixinDelegate, REQUIRED, Alias;
 var classToString, superClassString;
 
 var a_map = Array.prototype.map;
+var a_slice = Array.prototype.slice;
 var EMPTY_META = {}; // dummy for non-writable meta
 var META_SKIP = { __emberproto__: true, __ember_count__: true };
 
@@ -5886,17 +6022,21 @@ function applyMixin(obj, mixins, partial) {
 }
 
 Ember.mixin = function(obj) {
-  var args = Array.prototype.slice.call(arguments, 1);
+  var args = a_slice.call(arguments, 1);
   return applyMixin(obj, args, false);
 };
 
 
+/**
+  @constructor
+  @name Ember.Mixin
+*/
 Mixin = function() { return initMixin(this, arguments); };
 
 Mixin._apply = applyMixin;
 
 Mixin.applyPartial = function(obj) {
-  var args = Array.prototype.slice.call(arguments, 1);
+  var args = a_slice.call(arguments, 1);
   return applyMixin(obj, args, true);
 };
 
@@ -5935,15 +6075,17 @@ Mixin.prototype.reopen = function() {
 
 var TMP_ARRAY = [];
 Mixin.prototype.apply = function(obj) {
-  TMP_ARRAY.length=0;
   TMP_ARRAY[0] = this;
-  return applyMixin(obj, TMP_ARRAY, false);
+  var ret = applyMixin(obj, TMP_ARRAY, false);
+  TMP_ARRAY.length=0;
+  return ret;
 };
 
 Mixin.prototype.applyPartial = function(obj) {
-  TMP_ARRAY.length=0;
   TMP_ARRAY[0] = this;
-  return applyMixin(obj, TMP_ARRAY, true);
+  var ret = applyMixin(obj, TMP_ARRAY, true);
+  TMP_ARRAY.length=0;
+  return ret;
 };
 
 function _detect(curMixin, targetMixin, seen) {
@@ -5968,7 +6110,7 @@ Mixin.prototype.detect = function(obj) {
 
 Mixin.prototype.without = function() {
   var ret = new Mixin(this);
-  ret._without = Array.prototype.slice.call(arguments);
+  ret._without = a_slice.call(arguments);
   return ret;
 };
 
@@ -6025,6 +6167,9 @@ function findNamespaces() {
   if (Namespace.PROCESSED) { return; }
 
   for (var prop in window) {
+    //  get(window.globalStorage, 'isNamespace') would try to read the storage for domain isNamespace and cause exception in Firefox.
+    // globalStorage is a storage obsoleted by the WhatWG storage specification. See https://developer.mozilla.org/en/DOM/Storage#globalStorage
+    if (prop === "globalStorage" && window.StorageList && window.globalStorage instanceof window.StorageList) { continue; }
     // Unfortunately, some versions of IE don't support window.hasOwnProperty
     if (window.hasOwnProperty && !window.hasOwnProperty(prop)) { continue; }
 
@@ -6130,13 +6275,13 @@ Ember.MixinDelegate = MixinDelegate;
 //
 
 Ember.observer = function(func) {
-  var paths = Array.prototype.slice.call(arguments, 1);
+  var paths = a_slice.call(arguments, 1);
   func.__ember_observes__ = paths;
   return func;
 };
 
 Ember.beforeObserver = function(func) {
-  var paths = Array.prototype.slice.call(arguments, 1);
+  var paths = a_slice.call(arguments, 1);
   func.__ember_observesBefore__ = paths;
   return func;
 };
@@ -6174,6 +6319,7 @@ Ember.beforeObserver = function(func) {
 // 
 
 var get = Ember.get, set = Ember.set;
+var a_slice = Array.prototype.slice;
 
 var contexts = [];
 function popCtx() {
@@ -6186,9 +6332,11 @@ function pushCtx(ctx) {
 }
 
 function iter(key, value) {
+  var valueProvided = arguments.length === 2;
+
   function i(item) {
     var cur = get(item, key);
-    return value===undefined ? !!cur : value===cur;
+    return valueProvided ? value===cur : !!cur;
   } 
   return i ;
 }
@@ -6283,6 +6431,13 @@ Ember.Enumerable = Ember.Mixin.create( /** @lends Ember.Enumerable */ {
     If your enumerable is empty, this method should return undefined.
 
     @returns {Object} the object or undefined
+
+    @example
+    var arr = ["a", "b", "c"];
+    arr.firstObject(); => "a"
+
+    var arr = [];
+    arr.firstObject(); => undefined
   */
   firstObject: Ember.computed(function() {
     if (get(this, 'length')===0) return undefined ;
@@ -6293,12 +6448,21 @@ Ember.Enumerable = Ember.Mixin.create( /** @lends Ember.Enumerable */ {
     ret = this.nextObject(0, null, context);
     pushCtx(context);
     return ret ;
-  }).property('[]').cacheable(),
+  }).property(),
 
   /**
-    Helper method returns the last object from a collection.
+    Helper method returns the last object from a collection. If your enumerable
+    contains only one object, this method should always return that object.
+    If your enumerable is empty, this method should return undefined.
 
-    @returns {Object} the object or undefined
+    @returns {Object} the last object or undefined
+
+    @example
+    var arr = ["a", "b", "c"];
+    arr.lastObject(); => "c"
+
+    var arr = [];
+    arr.lastObject(); => undefined
   */
   lastObject: Ember.computed(function() {
     var len = get(this, 'length');
@@ -6314,8 +6478,7 @@ Ember.Enumerable = Ember.Mixin.create( /** @lends Ember.Enumerable */ {
       pushCtx(context);
       return last;
     }
-    
-  }).property('[]').cacheable(),
+  }).property(),
 
   /**
     Returns true if the passed object can be found in the receiver.  The
@@ -6370,18 +6533,13 @@ Ember.Enumerable = Ember.Mixin.create( /** @lends Ember.Enumerable */ {
   },
 
   /**
-    Retrieves the named value on each member object. This is more efficient
-    than using one of the wrapper methods defined here. Objects that
-    implement Ember.Observable will use the get() method, otherwise the property
-    will be accessed directly.
+    Alias for mapProperty
 
-    @param {String} key The key to retrieve
-    @returns {Array} Extracted values
+    @params key {String} name of the property
+    @returns {Array} The mapped array.
   */
   getEach: function(key) {
-    return this.map(function(item) {
-      return get(item, key);
-    });
+    return this.mapProperty(key);
   },
 
   /**
@@ -6486,7 +6644,7 @@ Ember.Enumerable = Ember.Mixin.create( /** @lends Ember.Enumerable */ {
     @returns {Array} filtered array
   */
   filterProperty: function(key, value) {
-    return this.filter(iter(key, value));
+    return this.filter(iter.apply(this, arguments));
   },
 
   /**
@@ -6541,7 +6699,7 @@ Ember.Enumerable = Ember.Mixin.create( /** @lends Ember.Enumerable */ {
     @returns {Object} found item or null
   */
   findProperty: function(key, value) {
-    return this.find(iter(key, value));
+    return this.find(iter.apply(this, arguments));
   },
 
   /**
@@ -6586,7 +6744,7 @@ Ember.Enumerable = Ember.Mixin.create( /** @lends Ember.Enumerable */ {
     @returns {Array} filtered array
   */
   everyProperty: function(key, value) {
-    return this.every(iter(key, value));
+    return this.every(iter.apply(this, arguments));
   },
 
 
@@ -6632,7 +6790,7 @@ Ember.Enumerable = Ember.Mixin.create( /** @lends Ember.Enumerable */ {
     @returns {Boolean} true
   */
   someProperty: function(key, value) {
-    return this.some(iter(key, value));
+    return this.some(iter.apply(this, arguments));
   },
 
   /**
@@ -6688,7 +6846,7 @@ Ember.Enumerable = Ember.Mixin.create( /** @lends Ember.Enumerable */ {
   */
   invoke: function(methodName) {
     var args, ret = [];
-    if (arguments.length>1) args = Array.prototype.slice.call(arguments, 1);
+    if (arguments.length>1) args = a_slice.call(arguments, 1);
     
     this.forEach(function(x, idx) { 
       var method = x && x[methodName];
@@ -6702,7 +6860,7 @@ Ember.Enumerable = Ember.Mixin.create( /** @lends Ember.Enumerable */ {
 
   /**
     Simply converts the enumerable into a genuine array.  The order is not 
-    gauranteed.  Corresponds to the method implemented by Prototype.
+    guaranteed.  Corresponds to the method implemented by Prototype.
 
     @returns {Array} the enumerable as an array.
   */
@@ -6843,7 +7001,6 @@ Ember.Enumerable = Ember.Mixin.create( /** @lends Ember.Enumerable */ {
     if (removing === -1) removing = null;
     if (adding   === -1) adding   = null;
     
-    Ember.propertyWillChange(this, '[]');
     if (hasDelta) Ember.propertyWillChange(this, 'length');
     Ember.sendEvent(this, '@enumerable:before', removing, adding);
 
@@ -6891,7 +7048,6 @@ Ember.Enumerable = Ember.Mixin.create( /** @lends Ember.Enumerable */ {
     
     Ember.sendEvent(this, '@enumerable:change', removing, adding);
     if (hasDelta) Ember.propertyDidChange(this, 'length');
-    Ember.propertyDidChange(this, '[]');
 
     return this ;
   }
@@ -7031,11 +7187,23 @@ Ember.Array = Ember.Mixin.create(Ember.Enumerable, /** @scope Ember.Array.protot
   },
 
   /**
-    Returns the index for a particular object in the index.
+    Returns the index of the given object's first occurrence.
+    If no startAt argument is given, the starting location to
+    search is 0. If it's negative, will count backward from 
+    the end of the array. Returns -1 if no match is found.
 
     @param {Object} object the item to search for
-    @param {NUmber} startAt optional starting location to search, default 0
-    @returns {Number} index of -1 if not found
+    @param {Number} startAt optional starting location to search, default 0
+    @returns {Number} index or -1 if not found
+
+    @example
+    var arr = ["a", "b", "c", "d", "a"];
+    arr.indexOf("a");      =>  0
+    arr.indexOf("z");      => -1
+    arr.indexOf("a", 2);   =>  4
+    arr.indexOf("a", -1);  =>  4
+    arr.indexOf("b", 3);   => -1
+    arr.indexOf("a", 100); => -1
   */
   indexOf: function(object, startAt) {
     var idx, len = get(this, 'length');
@@ -7050,16 +7218,28 @@ Ember.Array = Ember.Mixin.create(Ember.Enumerable, /** @scope Ember.Array.protot
   },
 
   /**
-    Returns the last index for a particular object in the index.
+    Returns the index of the given object's last occurrence.
+    If no startAt argument is given, the search starts from
+    the last position. If it's negative, will count backward 
+    from the end of the array. Returns -1 if no match is found.
 
     @param {Object} object the item to search for
-    @param {NUmber} startAt optional starting location to search, default 0
-    @returns {Number} index of -1 if not found
+    @param {Number} startAt optional starting location to search, default 0
+    @returns {Number} index or -1 if not found
+
+    @example
+    var arr = ["a", "b", "c", "d", "a"];
+    arr.lastIndexOf("a");      =>  4
+    arr.lastIndexOf("z");      => -1
+    arr.lastIndexOf("a", 2);   =>  0
+    arr.lastIndexOf("a", -1);  =>  4
+    arr.lastIndexOf("b", 3);   =>  1
+    arr.lastIndexOf("a", 100); =>  4
   */
   lastIndexOf: function(object, startAt) {
     var idx, len = get(this, 'length');
 
-    if (startAt === undefined) startAt = len-1;
+    if (startAt === undefined || startAt >= len) startAt = len-1;
     if (startAt < 0) startAt += len;
 
     for(idx=startAt;idx>=0;idx--) {
@@ -7704,11 +7884,12 @@ Ember.Observable = Ember.Mixin.create(/** @scope Ember.Observable.prototype */ {
     @returns {Ember.Observable}
   */
   setProperties: function(hash) {
-    Ember.beginPropertyChanges(this);
-    for(var prop in hash) {
-      if (hash.hasOwnProperty(prop)) set(this, prop, hash[prop]);
-    }
-    Ember.endPropertyChanges(this);
+    var self = this;
+    Ember.changeProperties(function(){
+      for(var prop in hash) {
+        if (hash.hasOwnProperty(prop)) set(self, prop, hash[prop]);
+      }
+    });
     return this;
   },
 
@@ -7981,7 +8162,8 @@ function makeCtor() {
 
 var CoreObject = makeCtor();
 
-CoreObject.PrototypeMixin = Ember.Mixin.create({
+CoreObject.PrototypeMixin = Ember.Mixin.create(
+/** @scope Ember.CoreObject */ {
 
   reopen: function() {
     Ember.Mixin._apply(this, arguments, true);
@@ -8019,7 +8201,7 @@ CoreObject.PrototypeMixin = Ember.Mixin.create({
     @private
   */
   _scheduledDestroy: function() {
-    this[Ember.META_KEY] = null;
+    Ember.destroy(this);
   },
 
   bind: function(to, from) {
@@ -8111,6 +8293,9 @@ var ClassMixin = Ember.Mixin.create({
 CoreObject.ClassMixin = ClassMixin;
 ClassMixin.apply(CoreObject);
 
+/**
+  @class
+*/
 Ember.CoreObject = CoreObject;
 
 
@@ -8239,14 +8424,13 @@ Ember.none = function(obj) {
 };
 
 /**
-  Verifies that a value is either null or an empty string. Return false if
-  the object is not a string.
+  Verifies that a value is null or an empty string | array | function.
 
   @param {Object} obj Value to test
   @returns {Boolean}
 */
 Ember.empty = function(obj) {
-  return obj === null || obj === undefined || obj === '';
+  return obj === null || obj === undefined || (obj.length === 0 && typeof obj !== 'function');
 };
 
 /**
@@ -8518,12 +8702,15 @@ Ember.Error.prototype = Ember.create(Error.prototype);
 var STRING_DASHERIZE_REGEXP = (/[ _]/g);
 var STRING_DASHERIZE_CACHE = {};
 var STRING_DECAMELIZE_REGEXP = (/([a-z])([A-Z])/g);
-  
+var STRING_CAMELIZE_REGEXP = (/(\-|_|\s)+(.)?/g);
+var STRING_UNDERSCORE_REGEXP_1 = (/([a-z\d])([A-Z]+)/g);
+var STRING_UNDERSCORE_REGEXP_2 = (/\-|\s+/g);
+
 /**
-  Defines the hash of localized strings for the current language.  Used by 
+  Defines the hash of localized strings for the current language.  Used by
   the `Ember.String.loc()` helper.  To localize, add string values to this
   hash.
-  
+
   @property {String}
 */
 Ember.STRINGS = {};
@@ -8532,7 +8719,7 @@ Ember.STRINGS = {};
   Defines string helper methods including string formatting and localization.
   Unless Ember.EXTEND_PROTOTYPES = false these methods will also be added to the
   String.prototype as well.
-  
+
   @namespace
 */
 Ember.String = {
@@ -8567,35 +8754,35 @@ Ember.String = {
 
   /**
     Formats the passed string, but first looks up the string in the localized
-    strings hash.  This is a convenient way to localize text.  See 
+    strings hash.  This is a convenient way to localize text.  See
     `Ember.String.fmt()` for more information on formatting.
-    
+
     Note that it is traditional but not required to prefix localized string
     keys with an underscore or other character so you can easily identify
     localized strings.
-    
+
     # Example Usage
-    
+
         @javascript@
         Ember.STRINGS = {
           '_Hello World': 'Bonjour le monde',
           '_Hello %@ %@': 'Bonjour %@ %@'
         };
-        
+
         Ember.String.loc("_Hello World");
         => 'Bonjour le monde';
-        
+
         Ember.String.loc("_Hello %@ %@", ["John", "Smith"]);
         => "Bonjour John Smith";
-        
-        
-        
+
+
+
     @param {String} str
       The string to format
-    
+
     @param {Array} formats
       Optional array of parameters to interpolate into string.
-      
+
     @returns {String} formatted string
   */
   loc: function(str, formats) {
@@ -8607,12 +8794,12 @@ Ember.String = {
     Splits a string into separate units separated by spaces, eliminating any
     empty strings in the process.  This is a convenience method for split that
     is mostly useful when applied to the String.prototype.
-    
+
     # Example Usage
-    
+
         @javascript@
-        Ember.String.w("alpha beta gamma").forEach(function(key) { 
-          console.log(key); 
+        Ember.String.w("alpha beta gamma").forEach(function(key) {
+          console.log(key);
         });
         > alpha
         > beta
@@ -8620,11 +8807,11 @@ Ember.String = {
 
     @param {String} str
       The string to split
-      
+
     @returns {String} split string
   */
   w: function(str) { return str.split(/\s+/); },
-  
+
   /**
     Converts a camelized string into all lower case separated by underscores.
 
@@ -8668,13 +8855,52 @@ Ember.String = {
     }
 
     return ret;
-  }
-};
-
-
+  },
 
+  /**
+    Converts a dasherized string or a string with spaces or underscores into
+    camelized string.
 
-})({});
+    h2. Examples
+
+    | *Input String* | *Output String* |
+    | my favorite items | myFavoriteItems |
+    | css-class-name | cssClassName |
+    | action_name | actionName |
+    | innerHTML | innerHTML |
+
+    @returns {String} the camelized string.
+  */
+  camelize: function(str) {
+    return str.replace(STRING_CAMELIZE_REGEXP, function(match, separator, chr) {
+      return chr ? chr.toUpperCase() : '';
+    });
+  },
+
+  /**
+    More general than decamelize, converts a dasherized or camelcased string or a string with spaces into
+    all lower case separated by undescores.
+
+    h2. Examples
+
+    | *Input String* | *Output String* |
+    | my favorite items | my_favorite_items |
+    | css-class-name | css_class_name |
+    | action_name | action_name |
+    | innerHTML | inner_html |
+
+    @returns {String} the camelized string.
+  */
+  underscore: function(str) {
+    return str.replace(STRING_UNDERSCORE_REGEXP_1, '$1_$2').
+      replace(STRING_UNDERSCORE_REGEXP_2, '_').toLowerCase();
+  }
+};
+
+
+
+
+})({});
 
 
 (function(exports) {
@@ -8700,7 +8926,8 @@ var get = Ember.get, set = Ember.set;
 
   @since Ember 0.9
 */
-Ember.Copyable = Ember.Mixin.create({
+Ember.Copyable = Ember.Mixin.create(
+/** @scope Ember.Copyable.prototype */ {
 
   /**
     Override to return a copy of the receiver.  Default implementation raises
@@ -8809,7 +9036,8 @@ var get = Ember.get, set = Ember.set;
 
   @since Ember 0.9
 */
-Ember.Freezable = Ember.Mixin.create({
+Ember.Freezable = Ember.Mixin.create(
+/** @scope Ember.Freezable.prototype */ {
 
   /**
     Set to YES when the object is frozen.  Use this property to detect whether
@@ -9219,6 +9447,12 @@ Ember.Set.create = function(items) {
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
 Ember.CoreObject.subclasses = new Ember.Set();
+
+/**
+  @class
+  @extends Ember.CoreObject
+  @extends Ember.Observable
+*/
 Ember.Object = Ember.CoreObject.extend(Ember.Observable);
 
 
@@ -9247,7 +9481,8 @@ var get = Ember.get, set = Ember.set;
   @extends Ember.Array
   @extends Ember.MutableArray
 */
-Ember.ArrayProxy = Ember.Object.extend(Ember.MutableArray, {
+Ember.ArrayProxy = Ember.Object.extend(Ember.MutableArray,
+/** @scope Ember.ArrayProxy.prototype */ {
   
   /**
     The content array.  Must be an object that implements Ember.Array and or
@@ -9379,7 +9614,7 @@ Ember.ArrayProxy = Ember.Object.extend(Ember.MutableArray, {
 
   Then, create a view that binds to your new controller:
 
-    {{collection contentBinding="MyApp.listController"}}
+    {{#collection contentBinding="MyApp.listController"}}
       {{content.firstName}} {{content.lastName}}
     {{/collection}}
 
@@ -9409,8 +9644,10 @@ Ember.ArrayController = Ember.ArrayProxy.extend();
 var fmt = Ember.String.fmt,
     w   = Ember.String.w,
     loc = Ember.String.loc,
+    camelize = Ember.String.camelize,
     decamelize = Ember.String.decamelize,
-    dasherize = Ember.String.dasherize;
+    dasherize = Ember.String.dasherize,
+    underscore = Ember.String.underscore;
   
 if (Ember.EXTEND_PROTOTYPES) {
 
@@ -9434,23 +9671,36 @@ if (Ember.EXTEND_PROTOTYPES) {
   String.prototype.loc = function() {
     return loc(this, arguments);
   };
-  
+
+  /**
+    @see Ember.String.camelize
+  */
+  String.prototype.camelize = function() {
+    return camelize(this);
+  };
+
   /**
     @see Ember.String.decamelize
   */
   String.prototype.decamelize = function() {
     return decamelize(this);
   };
-  
+
   /**
     @see Ember.String.dasherize
   */
   String.prototype.dasherize = function() {
     return dasherize(this);
   };
-}
 
+  /**
+    @see Ember.String.underscore
+  */
+  String.prototype.underscore = function() {
+    return underscore(this);
+  };
 
+}
 
 
 })({});
@@ -9463,6 +9713,8 @@ if (Ember.EXTEND_PROTOTYPES) {
 //            Portions ©2008-2011 Apple Inc. All rights reserved.
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
+var a_slice = Array.prototype.slice;
+
 if (Ember.EXTEND_PROTOTYPES) {
 
   Function.prototype.property = function() {
@@ -9471,12 +9723,12 @@ if (Ember.EXTEND_PROTOTYPES) {
   };
 
   Function.prototype.observes = function() {
-    this.__ember_observes__ = Array.prototype.slice.call(arguments);
+    this.__ember_observes__ = a_slice.call(arguments);
     return this;
   };
 
   Function.prototype.observesBefore = function() {
-    this.__ember_observesBefore__ = Array.prototype.slice.call(arguments);
+    this.__ember_observesBefore__ = a_slice.call(arguments);
     return this;
   };
 
@@ -9617,7 +9869,7 @@ Ember.Comparable = Ember.Mixin.create( /** @scope Ember.Comparable.prototype */{
 
 
 (function(exports) {
-var get = Ember.get, set = Ember.set;
+var get = Ember.get, set = Ember.set, getPath = Ember.getPath;
 
 Ember.TargetActionSupport = Ember.Mixin.create({
   target: null,
@@ -9627,7 +9879,10 @@ Ember.TargetActionSupport = Ember.Mixin.create({
     var target = get(this, 'target');
 
     if (Ember.typeOf(target) === "string") {
-      return Ember.getPath(this, target);
+      // TODO: Remove the false when deprecation is done
+      var value = getPath(this, target, false);
+      if (value === undefined) { value = getPath(window, target); }
+      return value;
     } else {
       return target;
     }
@@ -9638,14 +9893,21 @@ Ember.TargetActionSupport = Ember.Mixin.create({
         target = get(this, 'targetObject');
 
     if (target && action) {
+      var ret;
+      
       if (typeof target.send === 'function') {
-        target.send(action, this);
+        ret = target.send(action, this);
       } else {
         if (typeof action === 'string') {
           action = target[action];
         }
-        action.call(target, this);
+        ret = action.call(target, this);
       }
+      if (ret !== false) ret = true;
+      
+      return ret;
+    } else {
+      return false;
     }
   }
 });
@@ -10069,7 +10331,7 @@ Ember.NativeArray = NativeArray;
 */
 Ember.A = function(arr){
   if (arr === undefined) { arr = []; }
-  return Ember.NativeArray.apply(Array.prototype.slice.apply(arr));
+  return Ember.NativeArray.apply(arr);
 };
 
 /**
@@ -10080,6 +10342,8 @@ Ember.A = function(arr){
 */
 Ember.NativeArray.activate = function() {
   NativeArray.apply(Array.prototype);
+
+  Ember.A = function(arr) { return arr || []; }
 };
 
 if (Ember.EXTEND_PROTOTYPES) Ember.NativeArray.activate();
@@ -10210,7 +10474,7 @@ Ember._RenderBuffer = Ember.Object.extend(
     set(this ,'elementClasses', Ember.A());
     set(this, 'elementAttributes', {});
     set(this, 'elementStyle', {});
-    set(this, 'childBuffers', Ember.A());
+    set(this, 'childBuffers', []);
     set(this, 'elements', {});
   },
 
@@ -10221,7 +10485,7 @@ Ember._RenderBuffer = Ember.Object.extend(
     @returns {Ember.RenderBuffer} this
   */
   push: function(string) {
-    get(this, 'childBuffers').pushObject(String(string));
+    get(this, 'childBuffers').push(String(string));
     return this;
   },
 
@@ -10247,15 +10511,38 @@ Ember._RenderBuffer = Ember.Object.extend(
     return this;
   },
 
+  // duck type attribute functionality like jQuery so a render buffer
+  // can be used like a jQuery object in attribute binding scenarios.
+
   /**
     Adds an attribute which will be rendered to the element.
 
     @param {String} name The name of the attribute
     @param {String} value The value to add to the attribute
-    @returns {Ember.RenderBuffer} this
+    @returns {Ember.RenderBuffer|String} this or the current attribute value
   */
   attr: function(name, value) {
-    get(this, 'elementAttributes')[name] = value;
+    var attributes = get(this, 'elementAttributes');
+
+    if (arguments.length === 1) {
+      return attributes[name]
+    } else {
+      attributes[name] = value;
+    }
+
+    return this;
+  },
+
+  /**
+    Remove an attribute from the list of attributes to render.
+
+    @param {String} name The name of the attribute
+    @returns {Ember.RenderBuffer} this
+  */
+  removeAttr: function(name) {
+    var attributes = get(this, 'elementAttributes');
+    delete attributes[name];
+
     return this;
   },
 
@@ -10333,7 +10620,7 @@ Ember._RenderBuffer = Ember.Object.extend(
   */
   begin: function(tagName) {
     return this.newBuffer(tagName, this, function(buffer) {
-      get(this, 'childBuffers').pushObject(buffer);
+      get(this, 'childBuffers').push(buffer);
     });
   },
 
@@ -10344,7 +10631,7 @@ Ember._RenderBuffer = Ember.Object.extend(
   */
   prepend: function(tagName) {
     return this.newBuffer(tagName, this, function(buffer) {
-      get(this, 'childBuffers').insertAt(0, buffer);
+      get(this, 'childBuffers').splice(0, 0, buffer);
     });
   },
 
@@ -10372,7 +10659,7 @@ Ember._RenderBuffer = Ember.Object.extend(
     return this.newBuffer(tagName, parentBuffer, function(buffer) {
       var siblings = get(parentBuffer, 'childBuffers');
       var index = siblings.indexOf(this);
-      siblings.insertAt(index + 1, buffer);
+      siblings.splice(index + 1, 0, buffer);
     });
   },
 
@@ -10482,10 +10769,15 @@ Ember.EventDispatcher = Ember.Object.extend(
     The root DOM element to which event listeners should be attached. Event
     listeners will be attached to the document unless this is overridden.
 
+    Can be specified as a DOMElement or a selector string.
+
+    The default body is a string since this may be evaluated before document.body
+    exists in the DOM.
+
     @type DOMElement
-    @default document
+    @default 'body'
   */
-  rootElement: document,
+  rootElement: 'body',
 
   /**
     @private
@@ -10536,6 +10828,8 @@ Ember.EventDispatcher = Ember.Object.extend(
 
     rootElement.addClass('ember-application');
 
+    ember_assert('Unable to add "ember-application" class to rootElement. Make sure you the body or an element in the body.', rootElement.is('.ember-application'));
+
     for (event in events) {
       if (events.hasOwnProperty(event)) {
         this.setupHandler(rootElement, event, events[event]);
@@ -10616,17 +10910,9 @@ Ember.EventDispatcher = Ember.Object.extend(
 
   /** @private */
   _bubbleEvent: function(view, evt, eventName) {
-    var result = true, handler,
-        self = this;
-
-      Ember.run(function() {
-        handler = view[eventName];
-        if (Ember.typeOf(handler) === 'function') {
-          result = handler.call(view, evt);
-        }
-      });
-
-    return result;
+    return Ember.run(function() {
+      return view.handleEvent(eventName, evt);
+    });
   },
 
   /** @private */
@@ -10680,10 +10966,14 @@ Ember.Application = Ember.Namespace.extend(
 /** @scope Ember.Application.prototype */{
 
   /**
+    The root DOM element of the Application.
+
+    Can be specified as DOMElement or a selector string.
+
     @type DOMElement
-    @default document
+    @default 'body'
   */
-  rootElement: document,
+  rootElement: 'body',
 
   /**
     @type Ember.EventDispatcher
@@ -10709,21 +10999,35 @@ Ember.Application = Ember.Namespace.extend(
 
     set(this, 'eventDispatcher', eventDispatcher);
 
-    var self = this;
-    Ember.$(document).ready(function() {
-      self.ready();
-    });
+    // jQuery 1.7 doesn't call the ready callback if already ready
+    if (Ember.$.isReady) {
+      this.didBecomeReady();
+    } else {
+      var self = this;
+      Ember.$(document).ready(function() {
+        self.didBecomeReady();
+      });
+    }
 
     this._super();
   },
 
-  ready: function() {
+  /** @private */
+  didBecomeReady: function() {
     var eventDispatcher = get(this, 'eventDispatcher'),
         customEvents    = get(this, 'customEvents');
 
     eventDispatcher.setup(customEvents);
+
+    this.ready();
   },
 
+  /**
+    Called when the Application has become ready.
+    The call will be delayed until the DOM has become ready.
+  */
+  ready: Ember.K,
+
   /** @private */
   destroy: function() {
     get(this, 'eventDispatcher').destroy();
@@ -10772,6 +11076,7 @@ queues.splice(jQuery.inArray('actions', queues)+1, 0, 'render');
 /*globals ember_assert */
 var get = Ember.get, set = Ember.set, addObserver = Ember.addObserver;
 var getPath = Ember.getPath, meta = Ember.meta, fmt = Ember.String.fmt;
+var a_slice = Array.prototype.slice;
 
 var childViewsProperty = Ember.computed(function() {
   var childViews = get(this, '_childViews');
@@ -10910,13 +11215,19 @@ Ember.View = Ember.Object.extend(
     }
   }).property('_parentView'),
 
+  // return the current view, not including virtual views
+  concreteView: Ember.computed(function() {
+    if (!this.isVirtual) { return this; }
+    else { return get(this, 'parentView'); }
+  }).property('_parentView'),
+
   /**
     If false, the view will appear hidden in DOM.
 
     @type Boolean
-    @default true
+    @default null
   */
-  isVisible: true,
+  isVisible: null,
 
   /**
     Array of child views. You should never edit this array directly.
@@ -11063,7 +11374,7 @@ Ember.View = Ember.Object.extend(
         var fn = state[name];
 
         if (fn) {
-          var args = Array.prototype.slice.call(arguments, 1);
+          var args = a_slice.call(arguments, 1);
           args.unshift(this);
 
           return fn.apply(this, args);
@@ -11192,38 +11503,22 @@ Ember.View = Ember.Object.extend(
 
     if (!attributeBindings) { return; }
 
-    attributeBindings.forEach(function(attribute) {
+    attributeBindings.forEach(function(attributeName) {
       // Create an observer to add/remove/change the attribute if the
       // JavaScript property changes.
       var observer = function() {
         elem = this.$();
-        var currentValue = elem.attr(attribute);
-        attributeValue = get(this, attribute);
-
-        type = typeof attributeValue;
+        attributeValue = get(this, attributeName);
 
-        if ((type === 'string' || (type === 'number' && !isNaN(attributeValue))) && attributeValue !== currentValue) {
-          elem.attr(attribute, attributeValue);
-        } else if (attributeValue && type === 'boolean') {
-          elem.attr(attribute, attribute);
-        } else if (!attributeValue) {
-          elem.removeAttr(attribute);
-        }
+        Ember.View.applyAttributeBindings(elem, attributeName, attributeValue)
       };
 
-      addObserver(this, attribute, observer);
+      addObserver(this, attributeName, observer);
 
       // Determine the current value and add it to the render buffer
       // if necessary.
-      attributeValue = get(this, attribute);
-      type = typeof attributeValue;
-
-      if (type === 'string' || type === 'number') {
-        buffer.attr(attribute, attributeValue);
-      } else if (attributeValue && type === 'boolean') {
-        // Apply boolean attributes in the form attribute="attribute"
-        buffer.attr(attribute, attribute);
-      }
+      attributeValue = get(this, attributeName);
+      Ember.View.applyAttributeBindings(buffer, attributeName, attributeValue);
     }, this);
   },
 
@@ -11347,6 +11642,9 @@ Ember.View = Ember.Object.extend(
     // Schedule the DOM element to be created and appended to the given
     // element after bindings have synchronized.
     this._insertElementLater(function() {
+      if (get(this, 'isVisible') === null) {
+        set(this, 'isVisible', true);
+      }
       this.$().appendTo(target);
     });
 
@@ -11467,7 +11765,7 @@ Ember.View = Ember.Object.extend(
   */
   renderBuffer: function(tagName) {
     tagName = tagName || get(this, 'tagName');
-    if (tagName == null) { tagName = tagName || 'div'; }
+    if (tagName == null) { tagName = 'div'; }
 
     return Ember.RenderBuffer(tagName);
   },
@@ -11656,7 +11954,7 @@ Ember.View = Ember.Object.extend(
     // insert a new buffer after the "parent buffer").
     if (parentBuffer) {
       var tagName = get(this, 'tagName');
-      tagName = tagName == null ? 'div' : tagName;
+      if (tagName == null) { tagName = 'div'; }
 
       buffer = parentBuffer[bufferOperation](tagName);
     } else {
@@ -11705,7 +12003,7 @@ Ember.View = Ember.Object.extend(
       buffer.attr('role', role);
     }
 
-    if (!get(this, 'isVisible')) {
+    if (get(this, 'isVisible') === false) {
       buffer.style('display', 'none');
     }
   },
@@ -11845,6 +12143,14 @@ Ember.View = Ember.Object.extend(
     set(this, 'domManager', this.domManagerClass.create({ view: this }));
 
     meta(this)["Ember.View"] = {};
+
+    var viewController = get(this, 'viewController');
+    if (viewController) {
+      viewController = Ember.getPath(viewController);
+      if (viewController) {
+        set(viewController, 'view', this);
+      }
+    }
   },
 
   appendChild: function(view, options) {
@@ -11959,7 +12265,10 @@ Ember.View = Ember.Object.extend(
       view = view.create(attrs || {}, { _parentView: this });
 
       var viewName = attrs && attrs.viewName || view.viewName;
-      if (viewName) { set(this, viewName, view); }
+
+      // don't set the property on a virtual view, as they are invisible to
+      // consumers of the view API
+      if (viewName) { set(get(this, 'concreteView'), viewName, view); }
     } else {
       ember_assert('must pass instance of View', view instanceof Ember.View);
       set(view, '_parentView', this);
@@ -11967,6 +12276,9 @@ Ember.View = Ember.Object.extend(
     return view;
   },
 
+  becameVisible: Ember.K,
+  becameHidden: Ember.K,
+
   /**
     @private
 
@@ -11974,9 +12286,54 @@ Ember.View = Ember.Object.extend(
     element of the actual DOM element.
   */
   _isVisibleDidChange: Ember.observer(function() {
-    this.$().toggle(get(this, 'isVisible'));
+    var isVisible = get(this, 'isVisible');
+
+    this.$().toggle(isVisible);
+
+    if (this._isAncestorHidden()) { return; }
+
+    if (isVisible) {
+      this._notifyBecameVisible();
+    } else {
+      this._notifyBecameHidden();
+    }
   }, 'isVisible'),
 
+  _notifyBecameVisible: function() {
+    this.becameVisible();
+
+    this.forEachChildView(function(view) {
+      var isVisible = get(view, 'isVisible');
+
+      if (isVisible || isVisible === null) {
+        view._notifyBecameVisible();
+      }
+    });
+  },
+
+  _notifyBecameHidden: function() {
+    this.becameHidden();
+    this.forEachChildView(function(view) {
+      var isVisible = get(view, 'isVisible');
+
+      if (isVisible || isVisible === null) {
+        view._notifyBecameHidden();
+      }
+    });
+  },
+
+  _isAncestorHidden: function() {
+    var parent = get(this, 'parentView');
+
+    while (parent) {
+      if (get(parent, 'isVisible') === false) { return true; }
+
+      parent = get(parent, 'parentView');
+    }
+
+    return false;
+  },
+
   clearBuffer: function() {
     this.invokeRecursively(function(view) {
       meta(view)['Ember.View'].buffer = null;
@@ -11991,6 +12348,19 @@ Ember.View = Ember.Object.extend(
         view.transitionTo(state);
       });
     }
+  },
+
+  // .......................................................
+  // EVENT HANDLING
+  //
+
+  /**
+    @private
+
+    Handle events from `Ember.EventDispatcher`
+  */
+  handleEvent: function(eventName, evt) {
+    return this.invokeForState('handleEvent', eventName, evt);
   }
 
 });
@@ -12075,6 +12445,20 @@ Ember.View.views = {};
 // method.
 Ember.View.childViewsProperty = childViewsProperty;
 
+Ember.View.applyAttributeBindings = function(elem, name, value) {
+  var type = typeof value;
+  var currentValue = elem.attr(name);
+
+  // if this changes, also change the logic in ember-handlebars/lib/helpers/binding.js
+  if ((type === 'string' || (type === 'number' && !isNaN(value))) && value !== currentValue) {
+    elem.attr(name, value);
+  } else if (value && type === 'boolean') {
+    elem.attr(name, name);
+  } else if (!value) {
+    elem.removeAttr(name);
+  }
+};
+
 })({});
 
 
@@ -12100,6 +12484,11 @@ Ember.View.states = {
 
     getElement: function() {
       return null;
+    },
+
+    // Handle events from `Ember.EventDispatcher`
+    handleEvent: function() {
+      return true; // continue event propagation
     }
   }
 };
@@ -12296,6 +12685,16 @@ Ember.View.states.hasElement = {
 
     get(view, 'domManager').remove();
     return view;
+  },
+
+  // Handle events from `Ember.EventDispatcher`
+  handleEvent: function(view, eventName, evt) {
+    var handler = view[eventName];
+    if (Ember.typeOf(handler) === 'function') {
+      return handler.call(view, evt);
+    } else {
+      return true; // continue event propagation
+    }
   }
 };
 
@@ -12429,7 +12828,7 @@ Ember.ContainerView = Ember.View.extend({
   },
 
   /**
-    When the container view is destroyer, tear down the child views
+    When the container view is destroyed, tear down the child views
     array observer.
 
     @private
@@ -12456,6 +12855,11 @@ Ember.ContainerView = Ember.View.extend({
     @param {Number} removed the number of child views removed
   **/
   childViewsWillChange: function(views, start, removed) {
+    if (removed === 0) { return; }
+
+    var changedViews = views.slice(start, removed);
+    this.setParentView(changedViews, null);
+
     this.invokeForState('childViewsWillChange', views, start, removed);
   },
 
@@ -12480,10 +12884,19 @@ Ember.ContainerView = Ember.View.extend({
     // No new child views were added; bail out.
     if (added === 0) return;
 
+    var changedViews = views.slice(start, added);
+    this.setParentView(changedViews, this);
+
     // Let the current state handle the changes
     this.invokeForState('childViewsDidChange', views, start, added);
   },
 
+  setParentView: function(views, parentView) {
+    views.forEach(function(view) {
+      set(view, '_parentView', parentView);
+    });
+  },
+
   /**
     Schedules a child view to be inserted into the DOM after bindings have
     finished syncing for this run loop.
@@ -12693,6 +13106,10 @@ Ember.CollectionView = Ember.ContainerView.extend(
         childViews = get(this, 'childViews'),
         addedViews = [], view, item, idx, len, itemTagName;
 
+    if ('string' === typeof itemViewClass) {
+      itemViewClass = Ember.getPath(itemViewClass);
+    }
+
     ember_assert(fmt("itemViewClass must be a subclass of Ember.View, not %@", [itemViewClass]), Ember.View.detect(itemViewClass));
 
     len = content ? get(content, 'length') : 0;
@@ -12772,7 +13189,8 @@ Ember.CollectionView.CONTAINER_MAP = {
 //            Portions ©2008-2011 Apple Inc. All rights reserved.
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
-Ember.$ = jQuery;
+ember_assert("Ember requires jQuery 1.6 or 1.7", window.jQuery && jQuery().jquery.match(/^1\.[67](.\d+)?$/));
+Ember.$ = window.jQuery;
 })({});
 
 (function(exports) {
@@ -12784,14 +13202,50 @@ Ember.State = Ember.Object.extend({
   start: null,
 
   init: function() {
-    Ember.keys(this).forEach(function(name) {
-      var value = this[name];
+    var states = get(this, 'states'), foundStates;
+
+    // As a convenience, loop over the properties
+    // of this state and look for any that are other
+    // Ember.State instances or classes, and move them
+    // to the `states` hash. This avoids having to
+    // create an explicit separate hash.
+
+    if (!states) {
+      states = {};
+      for (var name in this) {
+        if (name === "constructor") { continue; }
+        value = this.setupChild(name, this[name]);
 
-      if (value && value.isState) {
-        set(value, 'parentState', this);
-        set(value, 'name', (get(this, 'name') || '') + '.' + name);
+        if (value) {
+          foundStates = true;
+          states[name] = value;
+        }
       }
-    }, this);
+
+      if (foundStates) { set(this, 'states', states); }
+    } else {
+      for (var name in states) {
+        this.setupChild(name, states[name]);
+      }
+    }
+
+    set(this, 'routes', {});
+  },
+
+  setupChild: function(name, value) {
+    if (!value) { return false; }
+
+    if (Ember.State.detect(value)) {
+      value = value.create();
+    }
+
+    if (value.isState) {
+      set(value, 'parentState', this);
+      set(value, 'name', (get(this, 'name') || '') + '.' + name);
+      return value;
+    }
+
+    return false;
   },
 
   enter: Ember.K,
@@ -12805,29 +13259,20 @@ Ember.State = Ember.Object.extend({
 var get = Ember.get, set = Ember.set, getPath = Ember.getPath, fmt = Ember.String.fmt;
 Ember.LOG_STATE_TRANSITIONS = false;
 
-Ember.StateManager = Ember.State.extend({
+/**
+  @class
+*/
+Ember.StateManager = Ember.State.extend(
+/** @scope Ember.State.prototype */ {
+
   /**
-    When creating a new storyboard, look for a default state to transition
+    When creating a new statemanager, look for a default state to transition
     into. This state can either be named `start`, or can be specified using the
     `initialState` property.
   */
   init: function() {
     this._super();
 
-    var states = get(this, 'states');
-    if (!states) {
-      states = {};
-      Ember.keys(this).forEach(function(name) {
-        var value = get(this, name);
-
-        if (value && value.isState) {
-          states[name] = value;
-        }
-      }, this);
-
-      set(this, 'states', states);
-    }
-
     var initialState = get(this, 'initialState');
 
     if (!initialState && get(this, 'start')) {
@@ -12842,11 +13287,13 @@ Ember.StateManager = Ember.State.extend({
   currentState: null,
 
   /**
+    @property
+
     If the current state is a view state or the descendent of a view state,
     this property will be the view associated with it. If there is no
     view state active in this state manager, this value will be null.
   */
-  currentView: SC.computed(function() {
+  currentView: Ember.computed(function() {
     var currentState = get(this, 'currentState'),
         view;
 
@@ -12872,7 +13319,7 @@ Ember.StateManager = Ember.State.extend({
     var action = currentState[event];
 
     if (action) {
-      if (log) { console.log(fmt("STORYBOARDS: Sending event '%@' to state %@.", [event, currentState.name])); }
+      if (log) { console.log(fmt("STATEMANAGER: Sending event '%@' to state %@.", [event, currentState.name])); }
       action.call(currentState, this, context);
     } else {
       var parentState = get(currentState, 'parentState');
@@ -12880,28 +13327,72 @@ Ember.StateManager = Ember.State.extend({
     }
   },
 
+  findStatesByRoute: function(state, route) {
+    if (!route || route === "") { return undefined; }
+    var r = route.split('.'), ret = [];
+
+    for (var i=0, len = r.length; i < len; i += 1) {
+      var states = get(state, 'states') ;
+
+      if (!states) { return undefined; }
+
+      var s = get(states, r[i]);
+      if (s) { state = s; ret.push(s); }
+      else { return undefined; }
+    }
+
+    return ret;
+  },
+
   goToState: function(name) {
+    if (Ember.empty(name)) { return; }
+
     var currentState = get(this, 'currentState') || this, state, newState;
 
-    var exitStates = Ember.A();
+    var exitStates = [], enterStates;
 
-    newState = getPath(currentState, name);
     state = currentState;
 
-    if (!newState) {
+    if (state.routes[name]) {
+      // cache hit
+      exitStates = state.routes[name].exitStates;
+      enterStates = state.routes[name].enterStates;
+      state = state.routes[name].futureState;
+    } else {
+      // cache miss
+
+      newState = this.findStatesByRoute(currentState, name);
+
       while (state && !newState) {
-        exitStates[Ember.guidFor(state)] = state;
-        exitStates.push(state);
+        exitStates.unshift(state);
 
         state = get(state, 'parentState');
         if (!state) {
-          state = get(this, 'states');
+          newState = this.findStatesByRoute(this, name);
+          if (!newState) { return; }
+        }
+        newState = this.findStatesByRoute(state, name);
+      }
+
+      enterStates = newState.slice(0), exitStates = exitStates.slice(0);
+
+      if (enterStates.length > 0) {
+        state = enterStates[enterStates.length - 1];
+
+        while (enterStates.length > 0 && enterStates[0] === exitStates[0]) {
+          enterStates.shift();
+          exitStates.shift();
         }
-        newState = getPath(state, name);
       }
+
+      currentState.routes[name] = {
+        exitStates: exitStates,
+        enterStates: enterStates,
+        futureState: state
+      };
     }
 
-    this.enterState(state, name, exitStates);
+    this.enterState(exitStates, enterStates, state);
   },
 
   getState: function(name) {
@@ -12938,37 +13429,28 @@ Ember.StateManager = Ember.State.extend({
     if (!async) { transition.resume(); }
   },
 
-  enterState: function(parent, name, exitStates) {
+  enterState: function(exitStates, enterStates, state) {
     var log = Ember.LOG_STATE_TRANSITIONS;
 
-    var parts = name.split("."), state = parent, enterStates = Ember.A();
-
-    parts.forEach(function(name) {
-      state = state[name];
-
-      var guid = Ember.guidFor(state);
-
-      if (guid in exitStates) {
-        exitStates.removeObject(state);
-        delete exitStates[guid];
-      } else {
-        enterStates.push(state);
-      }
-    });
-
     var stateManager = this;
 
     this.asyncEach(exitStates, function(state, transition) {
       state.exit(stateManager, transition);
     }, function() {
       this.asyncEach(enterStates, function(state, transition) {
-        if (log) { console.log("STORYBOARDS: Entering " + state.name); }
+        if (log) { console.log("STATEMANAGER: Entering " + state.name); }
         state.enter(stateManager, transition);
       }, function() {
-        var startState = state, enteredState;
+        var startState = state, enteredState, initialSubstate;
+
+        initialSubstate = get(startState, 'initialSubstate');
+
+        if (!initialSubstate) {
+          initialSubstate = 'start';
+        }
 
         // right now, start states cannot be entered asynchronously
-        while (startState = get(startState, 'start')) {
+        while (startState = get(startState, initialSubstate)) {
           enteredState = startState;
           startState.enter(stateManager);
         }
@@ -12989,10 +13471,25 @@ Ember.ViewState = Ember.State.extend({
   isViewState: true,
 
   enter: function(stateManager) {
-    var view = get(this, 'view');
+    var view = get(this, 'view'), root, childViews;
 
     if (view) {
-      view.appendTo(stateManager.get('rootElement') || 'body');
+      if (Ember.View.detect(view)) {
+        view = view.create();
+        set(this, 'view', view);
+      }
+
+      ember_assert('view must be an Ember.View', view instanceof Ember.View);
+
+      root = stateManager.get('rootView');
+
+      if (root) {
+        childViews = get(root, 'childViews');
+        childViews.pushObject(view);
+      } else {
+        root = stateManager.get('rootElement') || 'body';
+        view.appendTo(root);
+      }
     }
   },
 
@@ -13000,18 +13497,27 @@ Ember.ViewState = Ember.State.extend({
     var view = get(this, 'view');
 
     if (view) {
-      view.remove();
+      // If the view has a parent view, then it is
+      // part of a view hierarchy and should be removed
+      // from its parent.
+      if (get(view, 'parentView')) {
+        view.removeFromParent();
+      } else {
+
+        // Otherwise, the view is a "root view" and
+        // was appended directly to the DOM.
+        view.remove();
+      }
     }
   }
 });
 
-
 })({});
 
 
 (function(exports) {
 // ==========================================================================
-// Project:  Ember Storyboards
+// Project:  Ember Statecharts
 // Copyright: ©2011 Living Social Inc. and contributors.
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
@@ -13437,6 +13943,17 @@ Ember.ViewState = Ember.State.extend({
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
 /*globals Handlebars */
+/**
+  @namespace
+  @name Handlebars
+  @private
+*/
+
+/**
+  @namespace
+  @name Handlebars.helpers
+  @description Helpers for Handlebars templates
+*/
 
 /**
   @class
@@ -13462,12 +13979,6 @@ Ember.ViewState = Ember.State.extend({
   Note that you won't usually need to use Ember.Handlebars yourself. Instead, use
   Ember.View, which takes care of integration into the view layer for you.
 */
-/**
-  @namespace
-
-  Ember Handlebars is an extension to Handlebars that makes the built-in
-  Handlebars helpers and {{mustaches}} binding-aware.
-*/
 Ember.Handlebars = Ember.create(Handlebars);
 
 Ember.Handlebars.helpers = Ember.create(Handlebars.helpers);
@@ -13511,7 +14022,7 @@ Ember.Handlebars.Compiler.prototype.mustache = function(mustache) {
   if (mustache.params.length || mustache.hash) {
     return Handlebars.Compiler.prototype.mustache.call(this, mustache);
   } else {
-    var id = new Handlebars.AST.IdNode(['bind']);
+    var id = new Handlebars.AST.IdNode(['_triageMustache']);
 
     // Update the mustache node to include a hash value indicating whether the original node
     // was escaped. This will allow us to properly escape values when the underlying value
@@ -13525,6 +14036,19 @@ Ember.Handlebars.Compiler.prototype.mustache = function(mustache) {
   }
 };
 
+/**
+  Used for precompilation of Ember Handlebars templates. This will not be used during normal
+  app execution.
+
+  @param {String} string The template to precompile
+*/
+Ember.Handlebars.precompile = function(string) {
+  var ast = Handlebars.parse(string);
+  var options = { data: true, stringParams: true };
+  var environment = new Ember.Handlebars.Compiler().compile(ast, options);
+  return new Ember.Handlebars.JavaScriptCompiler().compile(environment, options, undefined, true);
+};
+
 /**
   The entry point for Ember Handlebars. This replaces the default Handlebars.compile and turns on
   template-local data and String parameters.
@@ -13540,6 +14064,21 @@ Ember.Handlebars.compile = function(string) {
   return Handlebars.template(templateSpec);
 };
 
+/**
+  Lookup both on root and on window
+
+  @param {Object} root The object to look up the property on
+  @param {String} path The path to be lookedup
+*/
+Ember.Handlebars.getPath = function(root, path) {
+  // TODO: Remove this `false` when the `getPath` globals support is removed
+  var value = Ember.getPath(root, path, false);
+  if (value === undefined && root !== window && Ember.isGlobalPath(path)) {
+    value = Ember.getPath(window, path);
+  }
+  return value;
+};
+
 /**
   Registers a helper in Handlebars that will be called if no property with the
   given name can be found on the current context object, and no helper with
@@ -13609,11 +14148,11 @@ Ember.Checkbox = Ember.View.extend({
 // Copyright: ©2011 Strobe Inc. and contributors.
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
-/** @class */
-
 var get = Ember.get, set = Ember.set;
 
-Ember.TextSupport = Ember.Mixin.create({
+/** @class */
+Ember.TextSupport = Ember.Mixin.create(
+/** @scope Ember.TextSupport.prototype */ {
 
   value: "",
 
@@ -13626,17 +14165,14 @@ Ember.TextSupport = Ember.Mixin.create({
 
   focusOut: function(event) {
     this._elementValueDidChange();
-    return false;
   },
 
   change: function(event) {
     this._elementValueDidChange();
-    return false;
   },
 
   keyUp: function(event) {
     this.interpretKeyEvents(event);
-    return false;
   },
 
   /**
@@ -13651,7 +14187,7 @@ Ember.TextSupport = Ember.Mixin.create({
   },
 
   _elementValueDidChange: function() {
-    set(this, 'value', this.$().val() || '');
+    set(this, 'value', this.$().val());
   }
 
 });
@@ -13670,10 +14206,12 @@ Ember.TextSupport.KEY_EVENTS = {
 // Copyright: ©2011 Strobe Inc. and contributors.
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
-/** @class */
-
 var get = Ember.get, set = Ember.set;
 
+/**
+  @class
+  @extends Ember.TextSupport
+*/
 Ember.TextField = Ember.View.extend(Ember.TextSupport,
   /** @scope Ember.TextField.prototype */ {
 
@@ -13681,14 +14219,7 @@ Ember.TextField = Ember.View.extend(Ember.TextSupport,
 
   tagName: "input",
   attributeBindings: ['type', 'value'],
-  type: "text",
-
-  /**
-    @private
-  */
-  _updateElementValue: function() {
-    this.$().val(get(this, 'value'));
-  }
+  type: "text"
 
 });
 
@@ -13708,11 +14239,26 @@ Ember.Button = Ember.View.extend(Ember.TargetActionSupport, {
   classNameBindings: ['isActive'],
 
   tagName: 'button',
-  attributeBindings: ['type', 'disabled'],
-  type: 'button',
-  disabled: false,
+
   propagateEvents: false,
 
+  attributeBindings: ['type', 'disabled', 'href'],
+
+  // Defaults to 'button' if tagName is 'input' or 'button'
+  type: Ember.computed(function(key, value) {
+    var tagName = this.get('tagName');
+    if (value !== undefined) { this._type = value; }
+    if (this._type !== undefined) { return this._type; }
+    if (tagName === 'input' || tagName === 'button') { return 'button'; }
+  }).property('tagName').cacheable(),
+
+  disabled: false,
+
+  // Allow 'a' tags to act like buttons
+  href: Ember.computed(function() {
+    return this.get('tagName') === 'a' ? '#' : null;
+  }).property('tagName').cacheable(),
+
   mouseDown: function() {
     if (!get(this, 'disabled')) {
       set(this, 'isActive', true);
@@ -13738,7 +14284,6 @@ Ember.Button = Ember.View.extend(Ember.TargetActionSupport, {
 
   mouseUp: function(event) {
     if (get(this, 'isActive')) {
-
       // Actually invoke the button's target and action.
       // This method comes from the Ember.TargetActionSupport mixin.
       this.triggerAction();
@@ -13750,16 +14295,30 @@ Ember.Button = Ember.View.extend(Ember.TargetActionSupport, {
     return get(this, 'propagateEvents');
   },
 
+  keyDown: function(event) {
+    // Handle space or enter
+    if (event.keyCode === 13 || event.keyCode === 32) {
+      this.mouseDown();
+    }
+  },
+
+  keyUp: function(event) {
+    // Handle space or enter
+    if (event.keyCode === 13 || event.keyCode === 32) {
+      this.mouseUp();
+    }
+  },
+
   // TODO: Handle proper touch behavior.  Including should make inactive when
   // finger moves more than 20x outside of the edge of the button (vs mouse
   // which goes inactive as soon as mouse goes out of edges.)
 
   touchStart: function(touch) {
-    this.mouseDown(touch);
+    return this.mouseDown(touch);
   },
 
   touchEnd: function(touch) {
-    this.mouseUp(touch);
+    return this.mouseUp(touch);
   }
 });
 
@@ -13772,11 +14331,14 @@ Ember.Button = Ember.View.extend(Ember.TargetActionSupport, {
 // Copyright: ©2011 Strobe Inc. and contributors.
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
-/** @class */
-
 var get = Ember.get, set = Ember.set;
 
-Ember.TextArea = Ember.View.extend(Ember.TextSupport, {
+/**
+  @class
+  @extends Ember.TextSupport
+*/
+Ember.TextArea = Ember.View.extend(Ember.TextSupport,
+/** @scope Ember.TextArea.prototype */ {
 
   classNames: ['ember-text-area'],
 
@@ -13808,11 +14370,11 @@ Ember.TabContainerView = Ember.View.extend();
 var get = Ember.get, getPath = Ember.getPath;
 
 Ember.TabPaneView = Ember.View.extend({
-  tabsContainer: SC.computed(function() {
+  tabsContainer: Ember.computed(function() {
     return this.nearestInstanceOf(Ember.TabContainerView);
   }).property(),
 
-  isVisible: SC.computed(function() {
+  isVisible: Ember.computed(function() {
     return get(this, 'viewName') === getPath(this, 'tabsContainer.currentView');
   }).property('tabsContainer.currentView')
 });
@@ -13824,7 +14386,7 @@ Ember.TabPaneView = Ember.View.extend({
 var get = Ember.get, setPath = Ember.setPath;
 
 Ember.TabView = Ember.View.extend({
-  tabsContainer: SC.computed(function() {
+  tabsContainer: Ember.computed(function() {
     return this.nearestInstanceOf(Ember.TabContainerView);
   }).property(),
 
@@ -13840,6 +14402,93 @@ Ember.TabView = Ember.View.extend({
 })({});
 
 
+(function(exports) {
+var set = Ember.set, get = Ember.get, getPath = Ember.getPath;
+
+Ember.Select = Ember.View.extend({
+  tagName: 'select',
+  template: Ember.Handlebars.compile(
+    '{{#if prompt}}<option>{{prompt}}</option>{{/if}}' +
+    '{{#each content}}{{view Ember.SelectOption contentBinding="this"}}{{/each}}'
+  ),
+
+  content: null,
+  selection: null,
+  prompt: null,
+
+  optionLabelPath: 'content',
+  optionValuePath: 'content',
+
+
+  didInsertElement: function() {
+    var selection = get(this, 'selection');
+
+    if (selection) { this.selectionDidChange(); }
+
+    this.change();
+  },
+
+  change: function() {
+    var selectedIndex = this.$()[0].selectedIndex,
+        content = get(this, 'content'),
+        prompt = get(this, 'prompt');
+
+    if (!content) { return; }
+    if (prompt && selectedIndex === 0) { set(this, 'selection', null); return; }
+
+    if (prompt) { selectedIndex -= 1; }
+    set(this, 'selection', content.objectAt(selectedIndex));
+  },
+
+  selectionDidChange: Ember.observer(function() {
+    var el = this.$()[0],
+        content = get(this, 'content'),
+        selection = get(this, 'selection'),
+        selectionIndex = content.indexOf(selection),
+        prompt = get(this, 'prompt');
+
+    if (prompt) { selectionIndex += 1; }
+    if (el) { el.selectedIndex = selectionIndex; }
+  }, 'selection')
+});
+
+Ember.SelectOption = Ember.View.extend({
+  tagName: 'option',
+  template: Ember.Handlebars.compile("{{label}}"),
+  attributeBindings: ['value'],
+
+  init: function() {
+    this.labelPathDidChange();
+    this.valuePathDidChange();
+
+    this._super();
+  },
+
+  labelPathDidChange: Ember.observer(function() {
+    var labelPath = getPath(this, 'parentView.optionLabelPath');
+
+    if (!labelPath) { return; }
+
+    Ember.defineProperty(this, 'label', Ember.computed(function() {
+      return getPath(this, labelPath);
+    }).property(labelPath).cacheable());
+  }, 'parentView.optionLabelPath'),
+
+  valuePathDidChange: Ember.observer(function() {
+    var valuePath = getPath(this, 'parentView.optionValuePath');
+
+    if (!valuePath) { return; }
+
+    Ember.defineProperty(this, 'value', Ember.computed(function() {
+      return getPath(this, valuePath);
+    }).property(valuePath).cacheable());
+  }, 'parentView.optionValuePath')
+});
+
+
+})({});
+
+
 (function(exports) {
 // ==========================================================================
 // Project:   Ember Handlebar Views
@@ -13935,7 +14584,7 @@ Ember.Metamorph = Ember.Mixin.create({
 // ==========================================================================
 /*globals Handlebars */
 
-var get = Ember.get, set = Ember.set, getPath = Ember.getPath;
+var get = Ember.get, set = Ember.set, getPath = Ember.Handlebars.getPath;
 /**
   @ignore
   @private
@@ -14006,6 +14655,29 @@ Ember._BindableSpanView = Ember.View.extend(Ember.Metamorph,
   */
   property: null,
 
+  normalizedValue: Ember.computed(function() {
+    var property = get(this, 'property'),
+        context  = get(this, 'previousContext'),
+        valueNormalizer = get(this, 'valueNormalizerFunc'),
+        result;
+
+    // Use the current context as the result if no
+    // property is provided.
+    if (property === '') {
+      result = context;
+    } else {
+      result = getPath(context, property);
+    }
+
+    return valueNormalizer ? valueNormalizer(result) : result;
+  }).property('property', 'previousContext', 'valueNormalizerFunc'),
+
+  rerenderIfNeeded: function() {
+    if (!get(this, 'isDestroyed') && get(this, 'normalizedValue') !== this._lastNormalizedValue) {
+      this.rerender();
+    }
+  },
+
   /**
     Determines which template to invoke, sets up the correct state based on
     that logic, then invokes the default Ember.View `render` implementation.
@@ -14028,23 +14700,14 @@ Ember._BindableSpanView = Ember.View.extend(Ember.Metamorph,
     var escape = get(this, 'isEscaped');
 
     var shouldDisplay = get(this, 'shouldDisplayFunc'),
-        property = get(this, 'property'),
         preserveContext = get(this, 'preserveContext'),
         context = get(this, 'previousContext');
 
     var inverseTemplate = get(this, 'inverseTemplate'),
         displayTemplate = get(this, 'displayTemplate');
 
-    var result;
-
-
-    // Use the current context as the result if no
-    // property is provided.
-    if (property === '') {
-      result = context;
-    } else {
-      result = getPath(context, property);
-    }
+    var result = get(this, 'normalizedValue');
+    this._lastNormalizedValue = result;
 
     // First, test the conditional to see if we should
     // render the template or not.
@@ -14095,12 +14758,15 @@ Ember._BindableSpanView = Ember.View.extend(Ember.Metamorph,
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
 /*globals Handlebars */
-var get = Ember.get, getPath = Ember.getPath, set = Ember.set, fmt = Ember.String.fmt;
+var get = Ember.get, getPath = Ember.Handlebars.getPath, set = Ember.set, fmt = Ember.String.fmt;
+
+var EmberHandlebars = Ember.Handlebars, helpers = EmberHandlebars.helpers;
+var helpers = EmberHandlebars.helpers;
 
 (function() {
   // Binds a property into the DOM. This will create a hook in DOM that the
-  // KVO system will look for and upate if the property changes.
-  var bind = function(property, options, preserveContext, shouldDisplay) {
+  // KVO system will look for and update if the property changes.
+  var bind = function(property, options, preserveContext, shouldDisplay, valueNormalizer) {
     var data = options.data,
         fn = options.fn,
         inverse = options.inverse,
@@ -14115,6 +14781,7 @@ var get = Ember.get, getPath = Ember.getPath, set = Ember.set, fmt = Ember.Strin
       var bindView = view.createChildView(Ember._BindableSpanView, {
         preserveContext: preserveContext,
         shouldDisplayFunc: shouldDisplay,
+        valueNormalizerFunc: valueNormalizer,
         displayTemplate: fn,
         inverseTemplate: inverse,
         property: property,
@@ -14124,15 +14791,9 @@ var get = Ember.get, getPath = Ember.getPath, set = Ember.set, fmt = Ember.Strin
 
       view.appendChild(bindView);
 
-      var observer, invoker;
-
-      observer = function(){
-        // Double check since sometimes the view gets destroyed after this observer is already queued
-        if (!get(bindView, 'isDestroyed')) { bindView.rerender(); }
-      };
-
-      invoker = function() {
-        Ember.run.once(observer);
+      /** @private */
+      var observer = function() {
+        Ember.run.once(bindView, 'rerenderIfNeeded');
       };
 
       // Observes the given property on the context and
@@ -14140,7 +14801,7 @@ var get = Ember.get, getPath = Ember.getPath, set = Ember.set, fmt = Ember.Strin
       // is an empty string, we are printing the current context
       // object ({{this}}) so updating it is not our responsibility.
       if (property !== '') {
-        Ember.addObserver(ctx, property, invoker);
+        Ember.addObserver(ctx, property, observer);
       }
     } else {
       // The object is not observable, so just render it out and
@@ -14149,6 +14810,30 @@ var get = Ember.get, getPath = Ember.getPath, set = Ember.set, fmt = Ember.Strin
     }
   };
 
+  /**
+    '_triageMustache' is used internally select between a binding and helper for 
+    the given context. Until this point, it would be hard to determine if the 
+    mustache is a property reference or a regular helper reference. This triage
+    helper resolves that.
+
+    This would not be typically invoked by directly.
+
+    @private
+    @name Handlebars.helpers._triageMustache
+    @param {String} property Property/helperID to triage
+    @param {Function} fn Context to provide for rendering
+    @returns {String} HTML string
+  */
+  EmberHandlebars.registerHelper('_triageMustache', function(property, fn) {
+    ember_assert("You cannot pass more than one argument to the _triageMustache helper", arguments.length <= 2);
+    if (helpers[property]) {
+      return helpers[property].call(this, fn);
+    }
+    else {
+      return helpers.bind.apply(this, arguments);
+    }
+  });
+
   /**
     `bind` can be used to display a value, then update that value if it 
     changes. For example, if you wanted to print the `title` property of 
@@ -14169,7 +14854,7 @@ var get = Ember.get, getPath = Ember.getPath, set = Ember.set, fmt = Ember.Strin
     @param {Function} fn Context to provide for rendering
     @returns {String} HTML string
   */
-  Ember.Handlebars.registerHelper('bind', function(property, fn) {
+  EmberHandlebars.registerHelper('bind', function(property, fn) {
     ember_assert("You cannot pass more than one argument to the bind helper", arguments.length <= 2);
 
     var context = (fn.contexts && fn.contexts[0]) || this;
@@ -14193,16 +14878,17 @@ var get = Ember.get, getPath = Ember.getPath, set = Ember.set, fmt = Ember.Strin
     @param {Function} fn Context to provide for rendering
     @returns {String} HTML string
   */
-  Ember.Handlebars.registerHelper('boundIf', function(property, fn) {
+  EmberHandlebars.registerHelper('boundIf', function(property, fn) {
     var context = (fn.contexts && fn.contexts[0]) || this;
-
-    return bind.call(context, property, fn, true, function(result) {
+    var func = function(result) {
       if (Ember.typeOf(result) === 'array') {
         return get(result, 'length') !== 0;
       } else {
         return !!result;
       }
-    } );
+    };
+
+    return bind.call(context, property, fn, true, func, func);
   });
 })();
 
@@ -14212,11 +14898,11 @@ var get = Ember.get, getPath = Ember.getPath, set = Ember.set, fmt = Ember.Strin
   @param {Hash} options
   @returns {String} HTML string
 */
-Ember.Handlebars.registerHelper('with', function(context, options) {
+EmberHandlebars.registerHelper('with', function(context, options) {
   ember_assert("You must pass exactly one argument to the with helper", arguments.length == 2);
   ember_assert("You must pass a block to the with helper", options.fn && options.fn !== Handlebars.VM.noop);
 
-  return Ember.Handlebars.helpers.bind.call(options.contexts[0], context, options);
+  return helpers.bind.call(options.contexts[0], context, options);
 });
 
 
@@ -14226,11 +14912,11 @@ Ember.Handlebars.registerHelper('with', function(context, options) {
   @param {Hash} options
   @returns {String} HTML string
 */
-Ember.Handlebars.registerHelper('if', function(context, options) {
+EmberHandlebars.registerHelper('if', function(context, options) {
   ember_assert("You must pass exactly one argument to the if helper", arguments.length == 2);
   ember_assert("You must pass a block to the if helper", options.fn && options.fn !== Handlebars.VM.noop);
 
-  return Ember.Handlebars.helpers.boundIf.call(options.contexts[0], context, options);
+  return helpers.boundIf.call(options.contexts[0], context, options);
 });
 
 /**
@@ -14239,7 +14925,7 @@ Ember.Handlebars.registerHelper('if', function(context, options) {
   @param {Hash} options
   @returns {String} HTML string
 */
-Ember.Handlebars.registerHelper('unless', function(context, options) {
+EmberHandlebars.registerHelper('unless', function(context, options) {
   ember_assert("You must pass exactly one argument to the unless helper", arguments.length == 2);
   ember_assert("You must pass a block to the unless helper", options.fn && options.fn !== Handlebars.VM.noop);
 
@@ -14248,7 +14934,7 @@ Ember.Handlebars.registerHelper('unless', function(context, options) {
   options.fn = inverse;
   options.inverse = fn;
 
-  return Ember.Handlebars.helpers.boundIf.call(options.contexts[0], context, options);
+  return helpers.boundIf.call(options.contexts[0], context, options);
 });
 
 /**
@@ -14261,7 +14947,7 @@ Ember.Handlebars.registerHelper('unless', function(context, options) {
   @param {Hash} options
   @returns {String} HTML string
 */
-Ember.Handlebars.registerHelper('bindAttr', function(options) {
+EmberHandlebars.registerHelper('bindAttr', function(options) {
 
   var attrs = options.hash;
 
@@ -14279,7 +14965,7 @@ Ember.Handlebars.registerHelper('bindAttr', function(options) {
   // Handle classes differently, as we can bind multiple classes
   var classBindings = attrs['class'];
   if (classBindings !== null && classBindings !== undefined) {
-    var classResults = Ember.Handlebars.bindClasses(this, classBindings, view, dataId);
+    var classResults = EmberHandlebars.bindClasses(this, classBindings, view, dataId);
     ret.push('class="' + classResults.join(' ') + '"');
     delete attrs['class'];
   }
@@ -14299,6 +14985,7 @@ Ember.Handlebars.registerHelper('bindAttr', function(options) {
 
     var observer, invoker;
 
+    /** @private */
     observer = function observer() {
       var result = getPath(ctx, property);
 
@@ -14315,22 +15002,10 @@ Ember.Handlebars.registerHelper('bindAttr', function(options) {
         return;
       }
 
-      var currentValue = elem.attr(attr);
-
-      // A false result will remove the attribute from the element. This is
-      // to support attributes such as disabled, whose presence is meaningful.
-      if (result === false && currentValue) {
-        elem.removeAttr(attr);
-
-      // Likewise, a true result will set the attribute's name as the value.
-      } else if (result === true && currentValue !== attr) {
-        elem.attr(attr, attr);
-
-      } else if (currentValue !== result) {
-        elem.attr(attr, result);
-      }
+      Ember.View.applyAttributeBindings(elem, attr, result);
     };
 
+    /** @private */
     invoker = function() {
       Ember.run.once(observer);
     };
@@ -14340,21 +15015,19 @@ Ember.Handlebars.registerHelper('bindAttr', function(options) {
     // unique data id and update the attribute to the new value.
     Ember.addObserver(ctx, property, invoker);
 
-    // Use the attribute's name as the value when it is YES
-    if (value === true) {
-      value = attr;
-    }
+    // if this changes, also change the logic in ember-views/lib/views/view.js
+    var type = typeof value;
 
-    // Do not add the attribute when the value is false
-    if (value !== false) {
-      // Return the current value, in the form src="foo.jpg"
+    if ((type === 'string' || (type === 'number' && !isNaN(value)))) {
       ret.push(attr + '="' + value + '"');
+    } else if (value && type === 'boolean') {
+      ret.push(attr + '="' + attr + '"');
     }
   }, this);
 
   // Add the unique identifier
   ret.push('data-bindAttr-' + dataId + '="' + dataId + '"');
-  return new Ember.Handlebars.SafeString(ret.join(' '));
+  return new EmberHandlebars.SafeString(ret.join(' '));
 });
 
 /**
@@ -14383,7 +15056,7 @@ Ember.Handlebars.registerHelper('bindAttr', function(options) {
 
   @returns {Array} An array of class names to add
 */
-Ember.Handlebars.bindClasses = function(context, classBindings, view, bindAttrId) {
+EmberHandlebars.bindClasses = function(context, classBindings, view, bindAttrId) {
   var ret = [], newClass, value, elem;
 
   // Helper method to retrieve the property from the context and
@@ -14391,9 +15064,10 @@ Ember.Handlebars.bindClasses = function(context, classBindings, view, bindAttrId
   // a Boolean or not.
   var classStringForProperty = function(property) {
     var split = property.split(':'),
-        property = split[0],
         className = split[1];
 
+    property = split[0];
+
     var val = getPath(context, property);
 
     // If value is a Boolean and true, return the dasherized property
@@ -14432,6 +15106,7 @@ Ember.Handlebars.bindClasses = function(context, classBindings, view, bindAttrId
 
     // Set up an observer on the context. If the property changes, toggle the
     // class name.
+    /** @private */
     observer = function() {
       // Get the current value of the property
       newClass = classStringForProperty(binding);
@@ -14458,6 +15133,7 @@ Ember.Handlebars.bindClasses = function(context, classBindings, view, bindAttrId
       }
     };
 
+    /** @private */
     invoker = function() {
       Ember.run.once(observer);
     };
@@ -14540,15 +15216,10 @@ Ember.Handlebars.ViewHelper = Ember.Object.create({
       if (Ember.IS_BINDING.test(prop)) {
         path = options[prop];
         if (!Ember.isGlobalPath(path)) {
-          // Binding to parentViews was previously deprecated. In most cases it shouldn't be necessary, but since
-          // there are a few valid use cases and most people have broken the parentView habit, we're no longer
-          // providing a warning about it.
-          if (!PARENT_VIEW_PATH.test(path)) {
-            if (path === 'this') {
-              options[prop] = 'bindingContext';
-            } else {
-              options[prop] = 'bindingContext.'+path;
-            }
+          if (path === 'this') {
+            options[prop] = 'bindingContext';
+          } else {
+            options[prop] = 'bindingContext.'+path;
           }
         }
       }
@@ -14570,7 +15241,7 @@ Ember.Handlebars.ViewHelper = Ember.Object.create({
         newView;
 
     if ('string' === typeof path) {
-      newView = Ember.getPath(thisContext, path);
+      newView = Ember.Handlebars.getPath(thisContext, path);
       ember_assert("Unable to find view at path '" + path + "'", !!newView);
     } else {
       newView = path;
@@ -14622,7 +15293,7 @@ Ember.Handlebars.registerHelper('view', function(path, options) {
 /*globals Handlebars ember_assert */
 
 // TODO: Don't require all of this module
-var get = Ember.get, fmt = Ember.String.fmt;
+var get = Ember.get, getPath = Ember.Handlebars.getPath, fmt = Ember.String.fmt;
 
 /**
   @name Handlebars.helpers.collection
@@ -14647,7 +15318,7 @@ Ember.Handlebars.registerHelper('collection', function(path, options) {
   // If passed a path string, convert that into an object.
   // Otherwise, just default to the standard class.
   var collectionClass;
-  collectionClass = path ? Ember.getPath(this, path) : Ember.CollectionView;
+  collectionClass = path ? getPath(this, path) : Ember.CollectionView;
   ember_assert(fmt("%@ #collection: Could not find %@", data.view, path), !!collectionClass);
 
   var hash = options.hash, itemHash = {}, match;
@@ -14656,7 +15327,7 @@ Ember.Handlebars.registerHelper('collection', function(path, options) {
   var itemViewClass, itemViewPath = hash.itemViewClass;
   var collectionPrototype = get(collectionClass, 'proto');
   delete hash.itemViewClass;
-  itemViewClass = itemViewPath ? Ember.getPath(collectionPrototype, itemViewPath) : collectionPrototype.itemViewClass;
+  itemViewClass = itemViewPath ? getPath(collectionPrototype, itemViewPath) : collectionPrototype.itemViewClass;
   ember_assert(fmt("%@ #collection: Could not find %@", data.view, itemViewPath), !!itemViewClass);
 
   // Go through options passed to the {{collection}} helper and extract options
@@ -14714,7 +15385,7 @@ Ember.Handlebars.registerHelper('collection', function(path, options) {
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
 /*globals Handlebars */
-var getPath = Ember.getPath;
+var getPath = Ember.Handlebars.getPath;
 
 /**
   `unbound` allows you to output a property without binding. *Important:* The 
@@ -14827,6 +15498,64 @@ Ember.Handlebars.registerHelper('template', function(name, options) {
 })({});
 
 
+(function(exports) {
+var EmberHandlebars = Ember.Handlebars, getPath = Ember.Handlebars.getPath;
+
+var ActionHelper = EmberHandlebars.ActionHelper = {};
+
+ActionHelper.registerAction = function(actionName, eventName, target, view) {
+  var actionId = (++jQuery.uuid).toString(),
+      existingHandler = view[eventName],
+      handler;
+
+  if (existingHandler) {
+    var handler = function(event) {
+      var ret;
+      if ($(event.target).closest('[data-ember-action]').attr('data-ember-action') === actionId) {
+        ret = target[actionName](event);
+      }
+      return ret !== false ? existingHandler.call(view, event) : ret;
+    };
+  } else {
+    var handler = function(event) {
+      if ($(event.target).closest('[data-ember-action]').attr('data-ember-action') === actionId) {
+        return target[actionName](event);
+      }
+    };
+  }
+
+  view[eventName] = handler;
+
+  view.reopen({
+    rerender: function() {
+      if (existingHandler) {
+        view[eventName] = existingHandler;
+      } else {
+        view[eventName] = null;
+      }
+      return this._super();
+    }
+  });
+
+  return actionId;
+};
+
+EmberHandlebars.registerHelper('action', function(actionName, options) {
+  var hash = options.hash || {},
+      eventName = options.hash.on || "click",
+      view = options.data.view,
+      target;
+
+  if (view.isVirtual) { view = view.get('parentView'); }
+  target = options.hash.target ? getPath(this, options.hash.target) : view;
+
+  var actionId = ActionHelper.registerAction(actionName, eventName, target, view);
+  return new EmberHandlebars.SafeString('data-ember-action="' + actionId + '"');
+});
+
+})({});
+
+
 (function(exports) {
 // ==========================================================================
 // Project:   Ember Handlebar Views
@@ -14851,8 +15580,8 @@ Ember.Handlebars.registerHelper('template', function(name, options) {
 // with Ember's Handlebars and are suitable for use as a view's template.
 // Those with type="text/x-raw-handlebars" will be compiled with regular
 // Handlebars and are suitable for use in views' computed properties.
-Ember.Handlebars.bootstrap = function() {
-  Ember.$('script[type="text/html"], script[type="text/x-handlebars"], script[type="text/x-raw-handlebars"]')
+Ember.Handlebars.bootstrap = function(ctx) {
+  Ember.$('script[type="text/html"], script[type="text/x-handlebars"], script[type="text/x-raw-handlebars"]', ctx)
     .each(function() {
     // Get a reference to the script tag
     var script = Ember.$(this),
@@ -14864,7 +15593,7 @@ Ember.Handlebars.bootstrap = function() {
       // id if no name is found.
       templateName = script.attr('data-template-name') || script.attr('id'),
       template = compile(script.html()),
-      view, viewPath;
+      view, viewPath, tagName;
 
     if (templateName) {
       // For templates which have a name, we save them and then remove them from the DOM
@@ -14889,8 +15618,13 @@ Ember.Handlebars.bootstrap = function() {
       viewPath = script.attr('data-view');
       view = viewPath ? Ember.getPath(viewPath) : Ember.View;
 
+      // Users can optionally specify a custom tag name to use by setting the
+      // data-tag-name attribute on the script tag.
+      tagName = script.attr('data-tag-name');
+
       view = view.create({
-        template: template
+        template: template,
+        tagName: (tagName) ? tagName : undefined
       });
 
       view._insertElementLater(function() {
@@ -14903,7 +15637,11 @@ Ember.Handlebars.bootstrap = function() {
   });
 };
 
-Ember.$(document).ready(Ember.Handlebars.bootstrap);
+Ember.$(document).ready(
+  function(){
+    Ember.Handlebars.bootstrap( Ember.$(document) );
+  }
+);
 
 })({});