Allow a template explicitly set on a view to be used when rendering a route.
add test for user provided template on a view
Make sets during init behave the same as create(props)

If you were relying on set during init to trigger
an observer please move it to an on('init') function
which runs after the object is fully initialized.
Consider `controllerName` in Ember.Route#render()

The previously introduced `controllerName` on a route hasn't been
considered when resolving the controller which shall be used within
`Ember.Route#render()`.
Merge pull request #3215 from sly7-7/patch-2

fix typo
Remove some commented test code.
Moves documentation of `TextField` and `Checkbox` to handlebars controls
Merge pull request #3134 from southpolesteve/master

Improve default model handleing of serialize hook
Merge pull request #3217 from trek/move-documentation-for-inputs-to-handelbars-controls

Moves documentation of `TextField` and `Checkbox` to handlebars controls
Stop building to the latest-builds and release-builds branches
Rename linkTo to link-To.

This is a soft deprecation. linkTo is still aliased.

Conflicts:
	packages/ember-routing/lib/helpers/link_to.js
	packages/ember/tests/helpers/link_to_test.js
Rename bindAttr to bind-attr.

This is a soft deprecation. bindAttr is still aliased.
clear factoryCache on-unregister
createChildView should throw a TypeError if no view or viewName was provided
inject Component's layoutName
Update docs to reflect #3177
Merge pull request #3222 from gdub22/hash-location-replaceUrl

Update docs to reflect #3177
Add `Ember.TrackedArray`.

`Ember.TrackedArray` is a data structure for lazily computing indexes of items
in arrays after mutations.

Useful in eg `Ember.ReduceComputed`.
Add `Ember.SubArray`.

Adds a specialized version of `Ember.TrackedArray` for tracking indexes of items
in arrays that are filtered versions of other arrays.
Add `Ember.reduceComputed`, `Ember.arrayComputed`.

Reduce computed properties and computed properties that reduce an enumerable.
Array computed properties are reduce computed properties whose value happens to
be an array.

Reduce computed properties use one-at-a-time semantics to make computations from
arrays pleasant to write without making it easy to introduce O(n²) runtime for
something that only requires O(n).

They can be chained together and retain their O(n) semantics.

A simple example:

```js
  var obj = Ember.Object.createWithMixins({
    items: Ember.A([{
      fname: "Jaime", lname: "Lannister", age: 34
    }, {
      fname: "Cersei", lname: "Lannister", age: 34
    }, {
      fname: "Robb", lname: "Stark", age: 16
    }, {
      fname: "Bran", lname: "Stark", age: 8
    }]),

    lannisters: Ember.computed.filterProperty('items', 'lname',
'Lannister'),
    lannisterSorting: Ember.A(['fname']),
    sortedLannisters: Ember.computed.sort('lannisters', 'lannisterSorting'),

    starks: Ember.computed.filterProperty('items', 'lname', 'Stark'),
    starkAges: Ember.computed.mapProperty('starks', 'age'),
    oldestStarkAge: Ember.computed.max('starkAges')
  });

  var items = obj.get('items');
  // each computed property will have to process only Tyrion to update, rather
  // than having to look through all of `items` again.
  items.pushObject(Ember.Object.create({
    fname: "Tyrion", lname: "Lannister", age: 26
  }));
```

Sugar functions include:
  - Ember.computed.max
  - Ember.computed.min
  - Ember.computed.map
  - Ember.computed.mapProperty
  - Ember.computed.filter
  - Ember.computed.filterProperty
  - Ember.computed.uniq
  - Ember.computed.intersect
  - Ember.computed.setDiff
  - Ember.computed.sort

They are all implemented with an easily used primitive.  The implementation of
`Ember.computed.min` serves as an example:

```js
  Ember.computed.min = function (dependentKey) {
    return Ember.reduceComputed.call(null, dependentKey, {
      initialValue: Infinity,

      addedItem: function (accumulatedValue, item, changeMeta, instanceMeta) {
        return Math.min(accumulatedValue, item);
      },

      removedItem: function (accumulatedValue, item, changeMeta, instanceMeta) {
        if (item > accumulatedValue) {
          return accumulatedValue;
        }
      }
    });
  };
```