Prior to this change, a setter that exists on the prototype of the
object was not detected and was effectively clobbered.

This change updates `handleMandatorySetter` to check both the objects
own descriptors and its prototypes descriptors.

Also removed the guard for `Object.getOwnPropertyDescriptor` since all
supported platforms are ES5.

…ide.

[DOC beta] Add link to `Ember.Component#defaultLayout` deprecation guide.

Contextual components show a message when passed null or unknown component
paths.

QUnit 1.19 was released and changed the way the npm package exports its
value (it no longer sets up `global.QUnit` and all the assertion methods
automatically).

This updates to a better pattern of importing `QUnit` and using the
`assert` argument for assertions.

This flag is no longer needed now that this feature is out of beta.

Fix node tests.

…ponents

[BUGFIX] Fix contextual components handling invalid component paths

allow @Protected in JSCS

Remove `ember-registry-container-reform` feature flag.

When specifying `postionalParams` like this:

```javascript
App.FooBarComponent = Ember.Component.extend();

App.FooBarComponent.reopenClass({
  positionalParams: 'allTheThings'
});
```

You should be able to avoid using positional params by specifying
`allTheThings` as a hash argument:

```hbs
{{foo-bar allTheThings=blah}}
```

Unfortunately, we were triggering an assertion that you used a positional
param that conflicted with a hash param.  This change fixes that
assertion by avoiding doing any work when no params are specified.

…al-params

[BUGFIX release] Ensure rest arg positionalParams can be omitted.

the build

updates per feedback

…erating

[BUGFIX Beta] Move warn api doc to a place where it gets picked up by the build

Due to the nature of `positionalParams`, it is trivial to supply
`params` as a hash argument to `{{link-to}}` instead of ordered args
(this allows truly dynamic link's). However, if `{{link-to params=foo}}`
is used `params` will be a `MutableCell` and the current code throws an
error in that circumstance.

*tldr;* `this.attrs` should be avoided. It is quite a 🧌 in
non-`GlimmerComponent`'s.

Cleanup meta

Due to values in `this.attrs` being either a `MutableCell` or the actual
value, many flags in `link-to` would not function properly when provided
a bound property.

remove extra comma

When compute is called it is expected that object is an actual Object,
sometimes the object is a Bool or String and yet we continue down the stack look
values up on it even though the result will be undefined. This change
bails out early if `object` is a Bool or String.

[BUGFIX beta] Allow usage of bound properties in {{link-to}}.

[PERF] Bail on get if type does not have accessors

We check to see if a function contains `_super` / `.call` / `.apply`
before attempting to super wrap a given method (this saves quite a bit
of extra super wrapping for functions that do not need it).
Unfortunately, a number of platforms that we support do not support
calling `func.toString()` so we attempt to detect this and fall back
to always super wrap everything mode.

We have roughly this code (from
[here](https://github.com/emberjs/ember.js/blob/b4718218dbe5ffe7736c485a594248b20977c621/packages/ember-metal/lib/utils.js#L257-L271))
to detect if we can call `toString()` and get the original source:

```javascript
  let sourceAvailable = (function() {
    return this;
  }).toString().indexOf('return this;') > -1;
```

This works perfectly for development builds, but unfortunately not
when minified.  Take a look at the minified source and you will see why:

```javascript
var e=function(){return this}.toString().indexOf("return this;")>-1;
```

Note that minifier has stripped the trailing semicolon from the function
body we are attempting to check against, but sadly our `indexOf` check
still contains the semicolon!

**tldr;** We super wrap every function in uglified builds.

---

This commit removes the trailing semicolon from the source check, and
adds a test that should hopefully allow us to detect if this is
accidentally reintroduced.

…thing

[BUGFIX release] Fix uglification introduced bug with super wrapping.

…f SafeString for `null` / `undefined`

Currently, `Ember.String.htmlSafe()` returns a just String, not HTML Safe.
We expect it is a safe string.

Update README.md, Fix Guides link

[BUGFIX release] `Ember.String.htmlSafe()` should return a instance of SafeString for `null` / `undefined`

…ters

[BUGFIX beta] Mandatory setter should check prototype descriptors.

Since these are server-side scenarios, we should be testing them in node
to more accurately replicated the target environment.

Access property only once during `Ember.get`

…publiv

observer should be public

Consider paths with dots in them for rendering as a component.

Move FastBoot and resource-discovery tests to node

[CLEANUP beta] Remove keys.js

According to https://github.com/emberjs/ember.js/blob/master/CONTRIBUTING.md: 'All examples in code blocks must be aligned'

[DOC] Fix alignment in examples

It didn't seem that importing `ember-routing` is required.

add assertions for tagless component event handlers

[CLEANUP beta] - Remove unnecessary module

[FEATURE ember-contextual-components] dot-path

Make Ember.compare public

Add missing @SInCE tags for the 1.12, 1.13 and 2.1 releases.

[DOC] Add `npm install` troubleshooting section

`Ember.isPresent(false)` returns `true`

[skip ci]

[DOC release] Update `Ember.isPresent(false)` example

The commented out `event` argument has an escaping backslash
in the closing comment tag, which is unexpected. Since the
argument is not used it is just removed.

[DOC release] Removes extraneous backslash in code snipper

… version

As discussed in Ember core team meeting on 2015-10-23.

Prior to 2.3 branching into beta we need to evaluate the local lookup
feature to ensure that contextual components land within one version of
local lookup. If it looks like local lookup will not land by 2.4 (before
branching 2.3.0-beta.1) this feature will be delayed. This timing should
not be an issue.

…nents

[FEATURE ember-contextual-components] Enable by default.

Most of the examples for `Ember.isEmpty` are similar to that from `Ember.isBlank` (https://github.com/emberjs/ember.js/blob/v2.1.0/packages/ember-metal/lib/is_blank.js#L3). Examples for white space are missing.

Test white space in `Ember.isEmpty`

As discussed in Ember core team meeting on 2015-10-23.

…run-loop

[BUGFIX beta] Ensure closure actions are wrapped in a run loop.

…age-changes

update deprecation messages in scheduleRevalidate to mention accurate version

[DOC Release] Document `Ember.getWithDefault`

fix build

Bump RSVP dependency

Remove `ember-htmlbars-each-with-index`.
It is already landed by cc26fb7.

[DOC release] Update FEATURES.md

…ponents

When merging two parameters hashes coming from components/closure components we
want them to be merged into a new hash. This refactors does not only make this
happen but it changes `mergeHash` into `mergeInNewHah` to be explicit about
this.

Fix emberjs#12537

[BUGFIX canary] Create new hash when merging parameters hashes in components

[DOC] Update CHANGELOG.md

The `ember-testing-checkbox-helpers` feature hasn't gained traction and
should be considered a failure as an Ember.js feature.

The helpers have been extracted into [thoughtbot/ralphs-little-helpers].

[thoughtbot/ralphs-little-helpers]: thoughtbot/ralphs-little-helpers#9

Remove `ember-testing-checkbox-helpers` feature

We know the array length in advance so we should set it.

Proof:
http://jsperf.com/literal-vs-new-23/9

Added Slack badge

Revert "Added Slack badge"

…helpers.

Use a symbol to obscure the owner property.

…tainer` during `lookup`.

This change represents the final brick needed to wall off the
`Container` as fully private.

The Container no longer injects itself into every object that it looks
up. Instead, it uses the new `setOwner` helper to inject the "owner",
which can then be retrieved from any object using the new `getOwner`
helper.

The current net effect is that an app instance is injected into every
looked up object instead of that app instance's container. This
provides clean, public access to methods exposed by the app
instance's ContainerProxy and RegistryProxy methods. It also guarantees
that the only supported path to get to a Container or Registry is
through a proxied method. This guarantee is important because it allows
for owner-specific logic to be placed in proxy methods.

In the future, other classes, such as Engine (coming soon), may mix in
ContainerProxy and thus have the potential to be "owners".

This work is behind the `ember-container-inject-owner` flag. Without
this flag enabled, the Container will continue to inject itself directly
into objects that it instantiates (as `container`).

[FEATURE ember-registry-container-reform] WIP: Inject `owner` instead of `container` during `lookup`.

Ensure owner is set during component creation.

Good:

```js
const FOO = 'FOO';
```

Bad:

```js
function derp() {
  const FOO = 'FOO';
}

if (false) {
  const BLAH = 'BLAH';
}
```

…nents-documentation

[DOC canary] Add documentation for contextual components