mirror of
https://github.com/Hopiu/angular.js.git
synced 2026-03-18 07:50:22 +00:00
d9abfe8a7e
- added angular.injector(scope, services, instanceCache) which returns inject
- inject method can return, instance, or call function which have $inject
property
- initialize services with $creation=[eager|eager-publish] this means that
only some of the services are now globally accessible
- upgraded $become on scope to use injector hence respect the $inject property
for injection
- $become should not be run multiple times and will most likely be removed
in future version
- added $new on scope to create a child scope
- $inject is respected on constructor function
- simplified scopes so that they no longer have separate __proto__ for
parent, api, behavior and instance this should speed up execution since
scope will now create one __proto__ chain per scope (not three).
BACKWARD COMPATIBILITY WARNING:
- services now need to have $inject instead of inject property for proper
injection this breaks backward compatibility
- not all services are now published into root scope
(only: $location, $cookie, $window)
- if you have widget/directive which uses services on scope
(such as this.$xhr), you will now have to inject that service in
(as it is not published on the root scope anymore)
59 lines
No EOL
2.2 KiB
JavaScript
59 lines
No EOL
2.2 KiB
JavaScript
/**
|
|
* Create an inject method
|
|
* @param providerScope provider's "this"
|
|
* @param providers a function(name) which returns provider function
|
|
* @param cache place where instances are saved for reuse
|
|
* @returns {Function}
|
|
*/
|
|
function createInjector(providerScope, providers, cache) {
|
|
providers = providers || angularService;
|
|
cache = cache || {};
|
|
providerScope = providerScope || {};
|
|
/**
|
|
* injection function
|
|
* @param value: string, array, object or function.
|
|
* @param scope: optional function "this"
|
|
* @param args: optional arguments to pass to function after injection
|
|
* parameters
|
|
* @returns depends on value:
|
|
* string: return an instance for the injection key.
|
|
* array of keys: returns an array of instances.
|
|
* function: look at $inject property of function to determine instances
|
|
* and then call the function with instances and scope. Any
|
|
* additional arguments are passed on to function.
|
|
* object: initialize eager providers and publish them the ones with publish here.
|
|
* none: same as object but use providerScope as place to publish.
|
|
*/
|
|
return function inject(value, scope, args){
|
|
var returnValue, provider, creation;
|
|
if (isString(value)) {
|
|
if (!cache.hasOwnProperty(value)) {
|
|
provider = providers[value];
|
|
if (!provider) throw "Unknown provider for '"+value+"'.";
|
|
cache[value] = inject(provider, providerScope);
|
|
}
|
|
returnValue = cache[value];
|
|
} else if (isArray(value)) {
|
|
returnValue = [];
|
|
foreach(value, function(name) {
|
|
returnValue.push(inject(name));
|
|
});
|
|
} else if (isFunction(value)) {
|
|
returnValue = inject(value.$inject || []);
|
|
returnValue = value.apply(scope, concat(returnValue, arguments, 2));
|
|
} else if (isObject(value)) {
|
|
foreach(providers, function(provider, name){
|
|
creation = provider.$creation;
|
|
if (creation == 'eager') {
|
|
inject(name);
|
|
}
|
|
if (creation == 'eager-published') {
|
|
setter(value, name, inject(name));
|
|
}
|
|
});
|
|
} else {
|
|
returnValue = inject(providerScope);
|
|
}
|
|
return returnValue;
|
|
};
|
|
} |