ember-rails 0.2.3 → 0.2.4

data/vendor/assets/javascripts/ember-dev.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
@@ -2387,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 = /^([^\.\*]+)/;
 
@@ -2399,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;
@@ -2464,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;
@@ -2482,15 +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];
     tuple.length = 0;
   }
-  
-  return getPath(root, path);
+
+  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) {
@@ -2504,6 +2520,10 @@ 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];
@@ -2513,14 +2533,17 @@ Ember.setPath = function(root, path, value, tolerant) {
   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;
   }
   
@@ -2752,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);
   };
@@ -3155,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);
@@ -3178,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;
 };
 
@@ -3235,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; 
-};
-
 
 })({});
 
@@ -3266,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 = /^([^\.\*]+)/;
@@ -3565,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();
@@ -3587,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);
 };
@@ -3610,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 chainsWillChange(obj, keyName, m) {
+  notifyChains(obj, m, keyName, 'willChange');
 }
 
-function chainsDidChange(obj, keyName) {
-  notifyChains(obj, keyName, 'didChange');
+function chainsDidChange(obj, keyName, m) {
+  notifyChains(obj, m, keyName, 'didChange');
 }
 
 // ..........................................................
@@ -3757,7 +3781,7 @@ var propertyWillChange = Ember.propertyWillChange = function(obj, keyName) {
   if (proto === obj) return ;
   if (desc && desc.willChange) desc.willChange(obj, keyName);
   dependentKeysWillChange(obj, keyName, m);
-  chainsWillChange(obj, keyName);
+  chainsWillChange(obj, keyName, m);
   Ember.notifyBeforeObservers(obj, keyName);
 };
 
@@ -3783,10 +3807,51 @@ var propertyDidChange = Ember.propertyDidChange = function(obj, keyName) {
   if (proto === obj) return ;
   if (desc && desc.didChange) desc.didChange(obj, keyName);
   dependentKeysDidChange(obj, keyName, m);
-  chainsDidChange(obj, keyName);
+  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);
+          }
+        }
+      }
+    }
+  }
+};
+
 })({});
 
 
@@ -3822,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 || []);
+  }
 }
 
 
@@ -3968,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;
 };
 
@@ -4420,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) {
@@ -4448,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');
 }
 
@@ -4460,11 +4550,11 @@ 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);
 };
 
 // ..........................................................
@@ -4817,7 +4907,7 @@ Binding.prototype = /** @scope Ember.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;
 
@@ -4831,13 +4921,13 @@ Binding.prototype = /** @scope Ember.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);
     }
   }
 
@@ -5071,6 +5161,15 @@ mixinProperties(Binding,
 
         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
@@ -6068,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; }
 
@@ -6230,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 ;
 }
@@ -6327,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 ;
@@ -6340,9 +6451,18 @@ Ember.Enumerable = Ember.Mixin.create( /** @lends Ember.Enumerable */ {
   }).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');
@@ -6358,7 +6478,6 @@ Ember.Enumerable = Ember.Mixin.create( /** @lends Ember.Enumerable */ {
       pushCtx(context);
       return last;
     }
-    
   }).property(),
 
   /**
@@ -6525,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));
   },
 
   /**
@@ -6580,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));
   },
 
   /**
@@ -6625,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));
   },
 
 
@@ -6671,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));
   },
 
   /**
@@ -6741,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.
   */
@@ -7068,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');
@@ -7087,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--) {
@@ -7741,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;
   },
 
@@ -8057,7 +8201,7 @@ CoreObject.PrototypeMixin = Ember.Mixin.create(
     @private
   */
   _scheduledDestroy: function() {
-    this[Ember.META_KEY] = null;
+    Ember.destroy(this);
   },
 
   bind: function(to, from) {
@@ -9725,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,
@@ -9735,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;
     }
@@ -9746,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;
     }
   }
 });
@@ -10320,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', {});
   },
 
@@ -10331,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;
   },
 
@@ -10466,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);
     });
   },
 
@@ -10477,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);
     });
   },
 
@@ -10505,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);
     });
   },
 
@@ -10615,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
@@ -10669,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]);
@@ -10749,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 */
@@ -10813,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
@@ -10842,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();
@@ -11044,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.
@@ -11465,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);
     });
 
@@ -11585,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);
   },
@@ -11774,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 {
@@ -11823,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');
     }
   },
@@ -11963,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) {
@@ -12077,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);
@@ -12085,6 +12276,9 @@ Ember.View = Ember.Object.extend(
     return view;
   },
 
+  becameVisible: Ember.K,
+  becameHidden: Ember.K,
+
   /**
     @private
 
@@ -12092,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;
@@ -12109,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);
   }
 
 });
@@ -12232,6 +12484,11 @@ Ember.View.states = {
 
     getElement: function() {
       return null;
+    },
+
+    // Handle events from `Ember.EventDispatcher`
+    handleEvent: function() {
+      return true; // continue event propagation
     }
   }
 };
@@ -12428,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
+    }
   }
 };
 
@@ -12561,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
@@ -12588,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);
   },
 
@@ -12612,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.
@@ -12825,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;
@@ -12904,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) {
@@ -12916,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) {
+          foundStates = true;
+          states[name] = value;
+        }
+      }
 
-      if (value && value.isState) {
-        set(value, 'parentState', this);
-        set(value, 'name', (get(this, 'name') || '') + '.' + name);
+      if (foundStates) { set(this, 'states', states); }
+    } else {
+      for (var name in states) {
+        this.setupChild(name, states[name]);
       }
-    }, this);
+    }
+
+    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,
@@ -12951,20 +13273,6 @@ Ember.StateManager = Ember.State.extend(
   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')) {
@@ -12985,7 +13293,7 @@ Ember.StateManager = Ember.State.extend(
     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;
 
@@ -13019,32 +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 = getPath(state, name);
+          newState = this.findStatesByRoute(this, name);
           if (!newState) { return; }
         }
-        newState = getPath(state, name);
+        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();
+        }
       }
+
+      currentState.routes[name] = {
+        exitStates: exitStates,
+        enterStates: enterStates,
+        futureState: state
+      };
     }
 
-    this.enterState(state, name, exitStates);
+    this.enterState(exitStates, enterStates, state);
   },
 
   getState: function(name) {
@@ -13081,24 +13429,9 @@ 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) {
@@ -13138,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);
+      }
     }
   },
 
@@ -13149,12 +13497,21 @@ 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();
+      }
     }
   }
 });
 
-
 })({});
 
 
@@ -13665,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
@@ -13679,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.
@@ -13694,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
@@ -13780,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;
   },
 
   /**
@@ -13805,7 +14187,7 @@ Ember.TextSupport = Ember.Mixin.create(
   },
 
   _elementValueDidChange: function() {
-    set(this, 'value', this.$().val() || '');
+    set(this, 'value', this.$().val());
   }
 
 });
@@ -13837,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"
 
 });
 
@@ -13864,18 +14239,25 @@ Ember.Button = Ember.View.extend(Ember.TargetActionSupport, {
   classNameBindings: ['isActive'],
 
   tagName: 'button',
-  attributeBindings: ['type', 'disabled'],
-  type: 'button',
-  disabled: false,
+
   propagateEvents: false,
 
-  click: function() {
-    // Actually invoke the button's target and action.
-    // This method comes from the Ember.TargetActionSupport mixin.
-    this.triggerAction();
+  attributeBindings: ['type', 'disabled', 'href'],
 
-    return get(this, 'propagateEvents');
-  },
+  // 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')) {
@@ -13902,6 +14284,9 @@ 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();
       set(this, 'isActive', false);
     }
 
@@ -13910,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);
   }
 });
 
@@ -13971,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')
 });
@@ -13987,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(),
 
@@ -14003,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
@@ -14098,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
@@ -14169,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.
@@ -14191,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.
@@ -14258,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,
@@ -14278,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,
@@ -14287,17 +14791,9 @@ var get = Ember.get, getPath = Ember.getPath, set = Ember.set, fmt = Ember.Strin
 
       view.appendChild(bindView);
 
-      var observer, invoker;
-
-      /** @private */
-      observer = function(){
-        // Double check since sometimes the view gets destroyed after this observer is already queued
-        if (!get(bindView, 'isDestroyed')) { bindView.rerender(); }
-      };
-
       /** @private */
-      invoker = function() {
-        Ember.run.once(observer);
+      var observer = function() {
+        Ember.run.once(bindView, 'rerenderIfNeeded');
       };
 
       // Observes the given property on the context and
@@ -14305,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
@@ -14314,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 
@@ -14334,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;
@@ -14358,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);
   });
 })();
 
@@ -14377,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);
 });
 
 
@@ -14391,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);
 });
 
 /**
@@ -14404,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);
 
@@ -14413,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);
 });
 
 /**
@@ -14426,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;
 
@@ -14444,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'];
   }
@@ -14506,7 +15027,7 @@ Ember.Handlebars.registerHelper('bindAttr', function(options) {
 
   // Add the unique identifier
   ret.push('data-bindAttr-' + dataId + '="' + dataId + '"');
-  return new Ember.Handlebars.SafeString(ret.join(' '));
+  return new EmberHandlebars.SafeString(ret.join(' '));
 });
 
 /**
@@ -14535,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
@@ -14543,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
@@ -14719,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;
@@ -14771,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
@@ -14796,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;
@@ -14805,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
@@ -14863,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 
@@ -14976,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
@@ -15000,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),
@@ -15013,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
@@ -15038,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() {
@@ -15052,7 +15637,11 @@ Ember.Handlebars.bootstrap = function() {
   });
 };
 
-Ember.$(document).ready(Ember.Handlebars.bootstrap);
+Ember.$(document).ready(
+  function(){
+    Ember.Handlebars.bootstrap( Ember.$(document) );
+  }
+);
 
 })({});