Returns a new child of the current container. These children are configured to correctly inherit from the current container.

A hook that can be used to describe how the resolver will attempt to find the factory.

For example, the default Ember .describe returns the full class name (including namespace) where Ember's resolver expects to find the fullName.

A depth first traversal, destroying the container, its descendant containers and all their managed objects.

Iterate and invoke a callback for each local key-value pair.

Defines factory injection rules.

Similar to regular injection rules, but are run against factories, via Container#lookupFactory.

These rules are used to inject objects onto factories when they are looked up.

Two forms of injections are possible:

• Injecting one fullName on another fullName
• Injecting one fullName on a type

Example:

var container = new Container();

container.register('store:main', Store);
container.register('store:secondary', OtherStore);
container.register('model:user', User);
container.register('model:post', Post);

// injecting one fullName on another type
container.factoryInjection('model', 'store', 'store:main');

// injecting one fullName on another fullName
container.factoryInjection('model:post', 'secondaryStore', 'store:secondary');

var UserFactory = container.lookupFactory('model:user');
var PostFactory = container.lookupFactory('model:post');
var store = container.lookup('store:main');

UserFactory.store instanceof Store; //=> true
UserFactory.secondaryStore instanceof OtherStore; //=> false

PostFactory.store instanceof Store; //=> true
PostFactory.secondaryStore instanceof OtherStore; //=> true

// and both models share the same source instance
UserFactory.store === PostFactory.store; //=> true

Retrieve the value given a key, if the value is present at the current level use it, otherwise walk up the parent hierarchy and try again. If no matching key is found, return undefined.

Given a fullName check if the container is aware of its factory or singleton instance.

Check for the existence of given a key, if the key is present at the current level return true, otherwise walk up the parent hierarchy and try again. If no matching key is found, return false.

Defines injection rules.

These rules are used to inject dependencies onto objects when they are instantiated.

Two forms of injections are possible:

• Injecting one fullName on another fullName
• Injecting one fullName on a type

Example:

var container = new Container();

container.register('source:main', Source);
container.register('model:user', User);
container.register('model:post', Post);

// injecting one fullName on another fullName
// eg. each user model gets a post model
container.injection('model:user', 'post', 'model:post');

// injecting one fullName on another type
container.injection('model', 'source', 'source:main');

var user = container.lookup('model:user');
var post = container.lookup('model:post');

user.source instanceof Source; //=> true
post.source instanceof Source; //=> true

user.post instanceof Post; //=> true

// and both models share the same source
user.source === post.source; //=> true

Given a fullName return a corresponding instance.

The default behaviour is for lookup to return a singleton instance. The singleton is scoped to the container, allowing multiple containers to all have their own locally scoped singletons.

var container = new Container();
container.register('api:twitter', Twitter);

var twitter = container.lookup('api:twitter');

twitter instanceof Twitter; // => true

// by default the container will return singletons
var twitter2 = container.lookup('api:twitter');
twitter instanceof Twitter; // => true

twitter === twitter2; //=> true

If singletons are not wanted an optional flag can be provided at lookup.

var container = new Container();
container.register('api:twitter', Twitter);

var twitter = container.lookup('api:twitter', { singleton: false });
var twitter2 = container.lookup('api:twitter', { singleton: false });

twitter === twitter2; //=> false

Given a fullName return the corresponding factory.

A hook to enable custom fullName normalization behaviour

Allow registering options for all factories of a type.

var container = new Container();

// if all of type connection must not be singletons
container.optionsForType('connection', { singleton: false });

container.register('connection:twitter', TwitterConnection);
container.register('connection:facebook', FacebookConnection);

var twitter = container.lookup('connection:twitter');
var twitter2 = container.lookup('connection:twitter');

twitter === twitter2; // => false

var facebook = container.lookup('connection:facebook');
var facebook2 = container.lookup('connection:facebook');

facebook === facebook2; // => false

Registers a factory for later injection.

Example:

var container = new Container();

container.register('model:user', Person, {singleton: false });
container.register('fruit:favorite', Orange);
container.register('communication:main', Email, {singleton: false});

Delete the given key

Transition into another route while replacing the current URL, if possible. This will replace the current history entry instead of adding a new one. Beside that, it is identical to transitionToRoute in all other respects.

aController.replaceRoute('blogPosts');
aController.replaceRoute('blogPosts.recentEntries');

Optionally supply a model for the route in question. The model will be serialized into the URL using the serialize hook of the route:

aController.replaceRoute('blogPost', aPost);

If a literal is passed (such as a number or a string), it will be treated as an identifier instead. In this case, the model hook of the route will be triggered:

aController.replaceRoute('blogPost', 1);

Multiple models will be applied last to first recursively up the resource tree.

App.Router.map(function() {
  this.resource('blogPost', {path:':blogPostId'}, function(){
    this.resource('blogComment', {path: ':blogCommentId'});
  });
});

aController.replaceRoute('blogComment', aPost, aComment);
aController.replaceRoute('blogComment', 1, 13);

It is also possible to pass a URL (a string that starts with a /). This is intended for testing and debugging purposes and should rarely be used in production code.

aController.replaceRoute('/');
aController.replaceRoute('/blog/post/1/comment/13');

Given a fullName return the corresponding factory.

By default resolve will retrieve the factory from its container's registry.

var container = new Container();
container.register('api:twitter', Twitter);

container.resolve('api:twitter') // => Twitter

Optionally the container can be provided with a custom resolver. If provided, resolve will first provide the custom resolver the oppertunity to resolve the fullName, otherwise it will fallback to the registry.

var container = new Container();
container.resolver = function(fullName) {
  // lookup via the module system of choice
};

// the twitter factory is added to the module system
container.resolve('api:twitter') // => Twitter

Sets a key-value pair on the current container. If a parent container, has the same key, once set on a child, the parent and child will diverge as expected.

Set the given value for the given key, at the current level.

Transition the application into another route. The route may be either a single route or route path:

aController.transitionToRoute('blogPosts');
aController.transitionToRoute('blogPosts.recentEntries');

Optionally supply a model for the route in question. The model will be serialized into the URL using the serialize hook of the route:

aController.transitionToRoute('blogPost', aPost);

If a literal is passed (such as a number or a string), it will be treated as an identifier instead. In this case, the model hook of the route will be triggered:

aController.transitionToRoute('blogPost', 1);

Multiple models will be applied last to first recursively up the resource tree.

App.Router.map(function() {
  this.resource('blogPost', {path:':blogPostId'}, function(){
    this.resource('blogComment', {path: ':blogCommentId'});
  });
});

aController.transitionToRoute('blogComment', aPost, aComment);
aController.transitionToRoute('blogComment', 1, 13);

It is also possible to pass a URL (a string that starts with a /). This is intended for testing and debugging purposes and should rarely be used in production code.

aController.transitionToRoute('/');
aController.transitionToRoute('/blog/post/1/comment/13');

See also replaceRoute.

Unregister a fullName

var container = new Container();
container.register('model:user', User);

container.lookup('model:user') instanceof User //=> true

container.unregister('model:user')
container.lookup('model:user') === undefined //=> true