js/libs/ember-1.5.1.js
function(props) {
    var hashName;

    if (!props._actions) {
      Ember.assert("'actions' should not be a function", typeof(props.actions) !== 'function');

      if (typeOf(props.actions) === 'object') {
        hashName = 'actions';
      } else if (typeOf(props.events) === 'object') {
        Ember.deprecate('Action handlers contained in an `events` object are deprecated in favor of putting them in an `actions` object', false);
        hashName = 'events';
      }

      if (hashName) {
        props._actions = Ember.merge(props._actions || {}, props[hashName]);
      }

      delete props[hashName];
    }
  }
function(props) {
    var hashName;

    if (!props._actions) {
      Ember.assert("'actions' should not be a function", typeof(props.actions) !== 'function');

      if (typeOf(props.actions) === 'object') {
        hashName = 'actions';
      } else if (typeOf(props.events) === 'object') {
        Ember.deprecate('Action handlers contained in an `events` object are deprecated in favor of putting them in an `actions` object', false);
        hashName = 'events';
      }

      if (hashName) {
        props._actions = Ember.merge(props._actions || {}, props[hashName]);
      }

      delete props[hashName];
    }
  }
The collection of functions, keyed by name, available on this
`ActionHandler` as action targets.

These functions will be invoked when a matching `{{action}}` is triggered
from within a template and the application's current route is this route.

Actions can also be invoked from other parts of your application
via `ActionHandler#send`.

The `actions` hash will inherit action handlers from
the `actions` hash defined on extended parent classes
or mixins rather than just replace the entire hash, e.g.:

```js
App.CanDisplayBanner = Ember.Mixin.create({
actions: {
displayBanner: function(msg) {
...
}
}
});

App.WelcomeRoute = Ember.Route.extend(App.CanDisplayBanner, {
actions: {
playMusic: function() {
...
}
}
});

`WelcomeRoute`, when active, will be able to respond
to both actions, since the actions hash is merged rather
then replaced when extending mixins / parent classes.
this.send('displayBanner');
this.send('playMusic');
```

Within a Controller, Route, View or Component's action handler,
the value of the `this` context is the Controller, Route, View or
Component object:

```js
App.SongRoute = Ember.Route.extend({
actions: {
myAction: function() {
this.controllerFor("song");
this.transitionTo("other.route");
...
}
}
});
```

It is also possible to call `this._super()` from within an
action handler if it overrides a handler defined on a parent
class or mixin:

Take for example the following routes:

```js
App.DebugRoute = Ember.Mixin.create({
actions: {
debugRouteInformation: function() {
console.debug("trololo");
}
}
});

App.AnnoyingDebugRoute = Ember.Route.extend(App.DebugRoute, {
actions: {
debugRouteInformation: function() {
also call the debugRouteInformation of mixed in App.DebugRoute
this._super();

show additional annoyance
window.alert(...);
}
}
});
```

## Bubbling

By default, an action will stop bubbling once a handler defined
on the `actions` hash handles it. To continue bubbling the action,
you must return `true` from the handler:

```js
App.Router.map(function() {
this.resource("album", function() {
this.route("song");
});
});

App.AlbumRoute = Ember.Route.extend({
actions: {
startPlaying: function() {
}
}
});

App.AlbumSongRoute = Ember.Route.extend({
actions: {
startPlaying: function() {
...

if (actionShouldAlsoBeTriggeredOnParentRoute) {
return true;
}
}
}
});
```

@property actions
@type Hash
@default null
 
Moves `actions` to `_actions` at extend time. Note that this currently
modifies the mixin themselves, which is technically dubious but
is practically of little consequence. This may change in the future.

@private
@method willMergeMixin