1215 lines
33 KiB
PHP
Executable File
1215 lines
33 KiB
PHP
Executable File
<?php
|
|
|
|
namespace Illuminate\Container;
|
|
|
|
use Closure;
|
|
use ArrayAccess;
|
|
use ReflectionClass;
|
|
use ReflectionMethod;
|
|
use ReflectionFunction;
|
|
use ReflectionParameter;
|
|
use InvalidArgumentException;
|
|
use Illuminate\Contracts\Container\Container as ContainerContract;
|
|
use Illuminate\Contracts\Container\BindingResolutionException as BindingResolutionContractException;
|
|
|
|
class Container implements ArrayAccess, ContainerContract
|
|
{
|
|
/**
|
|
* The current globally available container (if any).
|
|
*
|
|
* @var static
|
|
*/
|
|
protected static $instance;
|
|
|
|
/**
|
|
* An array of the types that have been resolved.
|
|
*
|
|
* @var array
|
|
*/
|
|
protected $resolved = [];
|
|
|
|
/**
|
|
* The container's bindings.
|
|
*
|
|
* @var array
|
|
*/
|
|
protected $bindings = [];
|
|
|
|
/**
|
|
* The container's shared instances.
|
|
*
|
|
* @var array
|
|
*/
|
|
protected $instances = [];
|
|
|
|
/**
|
|
* The registered type aliases.
|
|
*
|
|
* @var array
|
|
*/
|
|
protected $aliases = [];
|
|
|
|
/**
|
|
* The extension closures for services.
|
|
*
|
|
* @var array
|
|
*/
|
|
protected $extenders = [];
|
|
|
|
/**
|
|
* All of the registered tags.
|
|
*
|
|
* @var array
|
|
*/
|
|
protected $tags = [];
|
|
|
|
/**
|
|
* The stack of concretions being current built.
|
|
*
|
|
* @var array
|
|
*/
|
|
protected $buildStack = [];
|
|
|
|
/**
|
|
* The contextual binding map.
|
|
*
|
|
* @var array
|
|
*/
|
|
public $contextual = [];
|
|
|
|
/**
|
|
* All of the registered rebound callbacks.
|
|
*
|
|
* @var array
|
|
*/
|
|
protected $reboundCallbacks = [];
|
|
|
|
/**
|
|
* All of the global resolving callbacks.
|
|
*
|
|
* @var array
|
|
*/
|
|
protected $globalResolvingCallbacks = [];
|
|
|
|
/**
|
|
* All of the global after resolving callbacks.
|
|
*
|
|
* @var array
|
|
*/
|
|
protected $globalAfterResolvingCallbacks = [];
|
|
|
|
/**
|
|
* All of the after resolving callbacks by class type.
|
|
*
|
|
* @var array
|
|
*/
|
|
protected $resolvingCallbacks = [];
|
|
|
|
/**
|
|
* All of the after resolving callbacks by class type.
|
|
*
|
|
* @var array
|
|
*/
|
|
protected $afterResolvingCallbacks = [];
|
|
|
|
/**
|
|
* Define a contextual binding.
|
|
*
|
|
* @param string $concrete
|
|
* @return \Illuminate\Contracts\Container\ContextualBindingBuilder
|
|
*/
|
|
public function when($concrete)
|
|
{
|
|
return new ContextualBindingBuilder($this, $concrete);
|
|
}
|
|
|
|
/**
|
|
* Determine if the given abstract type has been bound.
|
|
*
|
|
* @param string $abstract
|
|
* @return bool
|
|
*/
|
|
public function bound($abstract)
|
|
{
|
|
return isset($this->bindings[$abstract]) || isset($this->instances[$abstract]) || $this->isAlias($abstract);
|
|
}
|
|
|
|
/**
|
|
* Determine if the given abstract type has been resolved.
|
|
*
|
|
* @param string $abstract
|
|
* @return bool
|
|
*/
|
|
public function resolved($abstract)
|
|
{
|
|
return isset($this->resolved[$abstract]) || isset($this->instances[$abstract]);
|
|
}
|
|
|
|
/**
|
|
* Determine if a given string is an alias.
|
|
*
|
|
* @param string $name
|
|
* @return bool
|
|
*/
|
|
public function isAlias($name)
|
|
{
|
|
return isset($this->aliases[$name]);
|
|
}
|
|
|
|
/**
|
|
* Register a binding with the container.
|
|
*
|
|
* @param string|array $abstract
|
|
* @param \Closure|string|null $concrete
|
|
* @param bool $shared
|
|
* @return void
|
|
*/
|
|
public function bind($abstract, $concrete = null, $shared = false)
|
|
{
|
|
// If the given types are actually an array, we will assume an alias is being
|
|
// defined and will grab this "real" abstract class name and register this
|
|
// alias with the container so that it can be used as a shortcut for it.
|
|
if (is_array($abstract)) {
|
|
list($abstract, $alias) = $this->extractAlias($abstract);
|
|
|
|
$this->alias($abstract, $alias);
|
|
}
|
|
|
|
// If no concrete type was given, we will simply set the concrete type to the
|
|
// abstract type. This will allow concrete type to be registered as shared
|
|
// without being forced to state their classes in both of the parameter.
|
|
$this->dropStaleInstances($abstract);
|
|
|
|
if (is_null($concrete)) {
|
|
$concrete = $abstract;
|
|
}
|
|
|
|
// If the factory is not a Closure, it means it is just a class name which is
|
|
// is bound into this container to the abstract type and we will just wrap
|
|
// it up inside a Closure to make things more convenient when extending.
|
|
if (! $concrete instanceof Closure) {
|
|
$concrete = $this->getClosure($abstract, $concrete);
|
|
}
|
|
|
|
$this->bindings[$abstract] = compact('concrete', 'shared');
|
|
|
|
// If the abstract type was already resolved in this container we'll fire the
|
|
// rebound listener so that any objects which have already gotten resolved
|
|
// can have their copy of the object updated via the listener callbacks.
|
|
if ($this->resolved($abstract)) {
|
|
$this->rebound($abstract);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the Closure to be used when building a type.
|
|
*
|
|
* @param string $abstract
|
|
* @param string $concrete
|
|
* @return \Closure
|
|
*/
|
|
protected function getClosure($abstract, $concrete)
|
|
{
|
|
return function ($c, $parameters = []) use ($abstract, $concrete) {
|
|
$method = ($abstract == $concrete) ? 'build' : 'make';
|
|
|
|
return $c->$method($concrete, $parameters);
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Add a contextual binding to the container.
|
|
*
|
|
* @param string $concrete
|
|
* @param string $abstract
|
|
* @param \Closure|string $implementation
|
|
*/
|
|
public function addContextualBinding($concrete, $abstract, $implementation)
|
|
{
|
|
$this->contextual[$concrete][$abstract] = $implementation;
|
|
}
|
|
|
|
/**
|
|
* Register a binding if it hasn't already been registered.
|
|
*
|
|
* @param string $abstract
|
|
* @param \Closure|string|null $concrete
|
|
* @param bool $shared
|
|
* @return void
|
|
*/
|
|
public function bindIf($abstract, $concrete = null, $shared = false)
|
|
{
|
|
if (! $this->bound($abstract)) {
|
|
$this->bind($abstract, $concrete, $shared);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Register a shared binding in the container.
|
|
*
|
|
* @param string $abstract
|
|
* @param \Closure|string|null $concrete
|
|
* @return void
|
|
*/
|
|
public function singleton($abstract, $concrete = null)
|
|
{
|
|
$this->bind($abstract, $concrete, true);
|
|
}
|
|
|
|
/**
|
|
* Wrap a Closure such that it is shared.
|
|
*
|
|
* @param \Closure $closure
|
|
* @return \Closure
|
|
*/
|
|
public function share(Closure $closure)
|
|
{
|
|
return function ($container) use ($closure) {
|
|
// We'll simply declare a static variable within the Closures and if it has
|
|
// not been set we will execute the given Closures to resolve this value
|
|
// and return it back to these consumers of the method as an instance.
|
|
static $object;
|
|
|
|
if (is_null($object)) {
|
|
$object = $closure($container);
|
|
}
|
|
|
|
return $object;
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Bind a shared Closure into the container.
|
|
*
|
|
* @param string $abstract
|
|
* @param \Closure $closure
|
|
* @return void
|
|
*
|
|
* @deprecated since version 5.1. Use singleton instead.
|
|
*/
|
|
public function bindShared($abstract, Closure $closure)
|
|
{
|
|
$this->bind($abstract, $this->share($closure), true);
|
|
}
|
|
|
|
/**
|
|
* "Extend" an abstract type in the container.
|
|
*
|
|
* @param string $abstract
|
|
* @param \Closure $closure
|
|
* @return void
|
|
*
|
|
* @throws \InvalidArgumentException
|
|
*/
|
|
public function extend($abstract, Closure $closure)
|
|
{
|
|
if (isset($this->instances[$abstract])) {
|
|
$this->instances[$abstract] = $closure($this->instances[$abstract], $this);
|
|
|
|
$this->rebound($abstract);
|
|
} else {
|
|
$this->extenders[$abstract][] = $closure;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Register an existing instance as shared in the container.
|
|
*
|
|
* @param string $abstract
|
|
* @param mixed $instance
|
|
* @return void
|
|
*/
|
|
public function instance($abstract, $instance)
|
|
{
|
|
// First, we will extract the alias from the abstract if it is an array so we
|
|
// are using the correct name when binding the type. If we get an alias it
|
|
// will be registered with the container so we can resolve it out later.
|
|
if (is_array($abstract)) {
|
|
list($abstract, $alias) = $this->extractAlias($abstract);
|
|
|
|
$this->alias($abstract, $alias);
|
|
}
|
|
|
|
unset($this->aliases[$abstract]);
|
|
|
|
// We'll check to determine if this type has been bound before, and if it has
|
|
// we will fire the rebound callbacks registered with the container and it
|
|
// can be updated with consuming classes that have gotten resolved here.
|
|
$bound = $this->bound($abstract);
|
|
|
|
$this->instances[$abstract] = $instance;
|
|
|
|
if ($bound) {
|
|
$this->rebound($abstract);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Assign a set of tags to a given binding.
|
|
*
|
|
* @param array|string $abstracts
|
|
* @param array|mixed ...$tags
|
|
* @return void
|
|
*/
|
|
public function tag($abstracts, $tags)
|
|
{
|
|
$tags = is_array($tags) ? $tags : array_slice(func_get_args(), 1);
|
|
|
|
foreach ($tags as $tag) {
|
|
if (! isset($this->tags[$tag])) {
|
|
$this->tags[$tag] = [];
|
|
}
|
|
|
|
foreach ((array) $abstracts as $abstract) {
|
|
$this->tags[$tag][] = $abstract;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Resolve all of the bindings for a given tag.
|
|
*
|
|
* @param string $tag
|
|
* @return array
|
|
*/
|
|
public function tagged($tag)
|
|
{
|
|
$results = [];
|
|
|
|
if (isset($this->tags[$tag])) {
|
|
foreach ($this->tags[$tag] as $abstract) {
|
|
$results[] = $this->make($abstract);
|
|
}
|
|
}
|
|
|
|
return $results;
|
|
}
|
|
|
|
/**
|
|
* Alias a type to a different name.
|
|
*
|
|
* @param string $abstract
|
|
* @param string $alias
|
|
* @return void
|
|
*/
|
|
public function alias($abstract, $alias)
|
|
{
|
|
$this->aliases[$alias] = $abstract;
|
|
}
|
|
|
|
/**
|
|
* Extract the type and alias from a given definition.
|
|
*
|
|
* @param array $definition
|
|
* @return array
|
|
*/
|
|
protected function extractAlias(array $definition)
|
|
{
|
|
return [key($definition), current($definition)];
|
|
}
|
|
|
|
/**
|
|
* Bind a new callback to an abstract's rebind event.
|
|
*
|
|
* @param string $abstract
|
|
* @param \Closure $callback
|
|
* @return mixed
|
|
*/
|
|
public function rebinding($abstract, Closure $callback)
|
|
{
|
|
$this->reboundCallbacks[$abstract][] = $callback;
|
|
|
|
if ($this->bound($abstract)) {
|
|
return $this->make($abstract);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Refresh an instance on the given target and method.
|
|
*
|
|
* @param string $abstract
|
|
* @param mixed $target
|
|
* @param string $method
|
|
* @return mixed
|
|
*/
|
|
public function refresh($abstract, $target, $method)
|
|
{
|
|
return $this->rebinding($abstract, function ($app, $instance) use ($target, $method) {
|
|
$target->{$method}($instance);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Fire the "rebound" callbacks for the given abstract type.
|
|
*
|
|
* @param string $abstract
|
|
* @return void
|
|
*/
|
|
protected function rebound($abstract)
|
|
{
|
|
$instance = $this->make($abstract);
|
|
|
|
foreach ($this->getReboundCallbacks($abstract) as $callback) {
|
|
call_user_func($callback, $this, $instance);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the rebound callbacks for a given type.
|
|
*
|
|
* @param string $abstract
|
|
* @return array
|
|
*/
|
|
protected function getReboundCallbacks($abstract)
|
|
{
|
|
if (isset($this->reboundCallbacks[$abstract])) {
|
|
return $this->reboundCallbacks[$abstract];
|
|
}
|
|
|
|
return [];
|
|
}
|
|
|
|
/**
|
|
* Wrap the given closure such that its dependencies will be injected when executed.
|
|
*
|
|
* @param \Closure $callback
|
|
* @param array $parameters
|
|
* @return \Closure
|
|
*/
|
|
public function wrap(Closure $callback, array $parameters = [])
|
|
{
|
|
return function () use ($callback, $parameters) {
|
|
return $this->call($callback, $parameters);
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Call the given Closure / class@method and inject its dependencies.
|
|
*
|
|
* @param callable|string $callback
|
|
* @param array $parameters
|
|
* @param string|null $defaultMethod
|
|
* @return mixed
|
|
*/
|
|
public function call($callback, array $parameters = [], $defaultMethod = null)
|
|
{
|
|
if ($this->isCallableWithAtSign($callback) || $defaultMethod) {
|
|
return $this->callClass($callback, $parameters, $defaultMethod);
|
|
}
|
|
|
|
$dependencies = $this->getMethodDependencies($callback, $parameters);
|
|
|
|
return call_user_func_array($callback, $dependencies);
|
|
}
|
|
|
|
/**
|
|
* Determine if the given string is in Class@method syntax.
|
|
*
|
|
* @param mixed $callback
|
|
* @return bool
|
|
*/
|
|
protected function isCallableWithAtSign($callback)
|
|
{
|
|
if (! is_string($callback)) {
|
|
return false;
|
|
}
|
|
|
|
return strpos($callback, '@') !== false;
|
|
}
|
|
|
|
/**
|
|
* Get all dependencies for a given method.
|
|
*
|
|
* @param callable|string $callback
|
|
* @param array $parameters
|
|
* @return array
|
|
*/
|
|
protected function getMethodDependencies($callback, array $parameters = [])
|
|
{
|
|
$dependencies = [];
|
|
|
|
foreach ($this->getCallReflector($callback)->getParameters() as $key => $parameter) {
|
|
$this->addDependencyForCallParameter($parameter, $parameters, $dependencies);
|
|
}
|
|
|
|
return array_merge($dependencies, $parameters);
|
|
}
|
|
|
|
/**
|
|
* Get the proper reflection instance for the given callback.
|
|
*
|
|
* @param callable|string $callback
|
|
* @return \ReflectionFunctionAbstract
|
|
*/
|
|
protected function getCallReflector($callback)
|
|
{
|
|
if (is_string($callback) && strpos($callback, '::') !== false) {
|
|
$callback = explode('::', $callback);
|
|
}
|
|
|
|
if (is_array($callback)) {
|
|
return new ReflectionMethod($callback[0], $callback[1]);
|
|
}
|
|
|
|
return new ReflectionFunction($callback);
|
|
}
|
|
|
|
/**
|
|
* Get the dependency for the given call parameter.
|
|
*
|
|
* @param \ReflectionParameter $parameter
|
|
* @param array $parameters
|
|
* @param array $dependencies
|
|
* @return mixed
|
|
*/
|
|
protected function addDependencyForCallParameter(ReflectionParameter $parameter, array &$parameters, &$dependencies)
|
|
{
|
|
if (array_key_exists($parameter->name, $parameters)) {
|
|
$dependencies[] = $parameters[$parameter->name];
|
|
|
|
unset($parameters[$parameter->name]);
|
|
} elseif ($parameter->getClass()) {
|
|
$dependencies[] = $this->make($parameter->getClass()->name);
|
|
} elseif ($parameter->isDefaultValueAvailable()) {
|
|
$dependencies[] = $parameter->getDefaultValue();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call a string reference to a class using Class@method syntax.
|
|
*
|
|
* @param string $target
|
|
* @param array $parameters
|
|
* @param string|null $defaultMethod
|
|
* @return mixed
|
|
*/
|
|
protected function callClass($target, array $parameters = [], $defaultMethod = null)
|
|
{
|
|
$segments = explode('@', $target);
|
|
|
|
// If the listener has an @ sign, we will assume it is being used to delimit
|
|
// the class name from the handle method name. This allows for handlers
|
|
// to run multiple handler methods in a single class for convenience.
|
|
$method = count($segments) == 2 ? $segments[1] : $defaultMethod;
|
|
|
|
if (is_null($method)) {
|
|
throw new InvalidArgumentException('Method not provided.');
|
|
}
|
|
|
|
return $this->call([$this->make($segments[0]), $method], $parameters);
|
|
}
|
|
|
|
/**
|
|
* Resolve the given type from the container.
|
|
*
|
|
* @param string $abstract
|
|
* @param array $parameters
|
|
* @return mixed
|
|
*/
|
|
public function make($abstract, array $parameters = [])
|
|
{
|
|
$abstract = $this->getAlias($abstract);
|
|
|
|
// If an instance of the type is currently being managed as a singleton we'll
|
|
// just return an existing instance instead of instantiating new instances
|
|
// so the developer can keep using the same objects instance every time.
|
|
if (isset($this->instances[$abstract])) {
|
|
return $this->instances[$abstract];
|
|
}
|
|
|
|
$concrete = $this->getConcrete($abstract);
|
|
|
|
// We're ready to instantiate an instance of the concrete type registered for
|
|
// the binding. This will instantiate the types, as well as resolve any of
|
|
// its "nested" dependencies recursively until all have gotten resolved.
|
|
if ($this->isBuildable($concrete, $abstract)) {
|
|
$object = $this->build($concrete, $parameters);
|
|
} else {
|
|
$object = $this->make($concrete, $parameters);
|
|
}
|
|
|
|
// If we defined any extenders for this type, we'll need to spin through them
|
|
// and apply them to the object being built. This allows for the extension
|
|
// of services, such as changing configuration or decorating the object.
|
|
foreach ($this->getExtenders($abstract) as $extender) {
|
|
$object = $extender($object, $this);
|
|
}
|
|
|
|
// If the requested type is registered as a singleton we'll want to cache off
|
|
// the instances in "memory" so we can return it later without creating an
|
|
// entirely new instance of an object on each subsequent request for it.
|
|
if ($this->isShared($abstract)) {
|
|
$this->instances[$abstract] = $object;
|
|
}
|
|
|
|
$this->fireResolvingCallbacks($abstract, $object);
|
|
|
|
$this->resolved[$abstract] = true;
|
|
|
|
return $object;
|
|
}
|
|
|
|
/**
|
|
* Get the concrete type for a given abstract.
|
|
*
|
|
* @param string $abstract
|
|
* @return mixed $concrete
|
|
*/
|
|
protected function getConcrete($abstract)
|
|
{
|
|
if (! is_null($concrete = $this->getContextualConcrete($abstract))) {
|
|
return $concrete;
|
|
}
|
|
|
|
// If we don't have a registered resolver or concrete for the type, we'll just
|
|
// assume each type is a concrete name and will attempt to resolve it as is
|
|
// since the container should be able to resolve concretes automatically.
|
|
if (! isset($this->bindings[$abstract])) {
|
|
if ($this->missingLeadingSlash($abstract) &&
|
|
isset($this->bindings['\\'.$abstract])) {
|
|
$abstract = '\\'.$abstract;
|
|
}
|
|
|
|
return $abstract;
|
|
}
|
|
|
|
return $this->bindings[$abstract]['concrete'];
|
|
}
|
|
|
|
/**
|
|
* Get the contextual concrete binding for the given abstract.
|
|
*
|
|
* @param string $abstract
|
|
* @return string
|
|
*/
|
|
protected function getContextualConcrete($abstract)
|
|
{
|
|
if (isset($this->contextual[end($this->buildStack)][$abstract])) {
|
|
return $this->contextual[end($this->buildStack)][$abstract];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Determine if the given abstract has a leading slash.
|
|
*
|
|
* @param string $abstract
|
|
* @return bool
|
|
*/
|
|
protected function missingLeadingSlash($abstract)
|
|
{
|
|
return is_string($abstract) && strpos($abstract, '\\') !== 0;
|
|
}
|
|
|
|
/**
|
|
* Get the extender callbacks for a given type.
|
|
*
|
|
* @param string $abstract
|
|
* @return array
|
|
*/
|
|
protected function getExtenders($abstract)
|
|
{
|
|
if (isset($this->extenders[$abstract])) {
|
|
return $this->extenders[$abstract];
|
|
}
|
|
|
|
return [];
|
|
}
|
|
|
|
/**
|
|
* Instantiate a concrete instance of the given type.
|
|
*
|
|
* @param string $concrete
|
|
* @param array $parameters
|
|
* @return mixed
|
|
*
|
|
* @throws \Illuminate\Contracts\Container\BindingResolutionException
|
|
*/
|
|
public function build($concrete, array $parameters = [])
|
|
{
|
|
// If the concrete type is actually a Closure, we will just execute it and
|
|
// hand back the results of the functions, which allows functions to be
|
|
// used as resolvers for more fine-tuned resolution of these objects.
|
|
if ($concrete instanceof Closure) {
|
|
return $concrete($this, $parameters);
|
|
}
|
|
|
|
$reflector = new ReflectionClass($concrete);
|
|
|
|
// If the type is not instantiable, the developer is attempting to resolve
|
|
// an abstract type such as an Interface of Abstract Class and there is
|
|
// no binding registered for the abstractions so we need to bail out.
|
|
if (! $reflector->isInstantiable()) {
|
|
$message = "Target [$concrete] is not instantiable.";
|
|
|
|
throw new BindingResolutionContractException($message);
|
|
}
|
|
|
|
$this->buildStack[] = $concrete;
|
|
|
|
$constructor = $reflector->getConstructor();
|
|
|
|
// If there are no constructors, that means there are no dependencies then
|
|
// we can just resolve the instances of the objects right away, without
|
|
// resolving any other types or dependencies out of these containers.
|
|
if (is_null($constructor)) {
|
|
array_pop($this->buildStack);
|
|
|
|
return new $concrete;
|
|
}
|
|
|
|
$dependencies = $constructor->getParameters();
|
|
|
|
// Once we have all the constructor's parameters we can create each of the
|
|
// dependency instances and then use the reflection instances to make a
|
|
// new instance of this class, injecting the created dependencies in.
|
|
$parameters = $this->keyParametersByArgument(
|
|
$dependencies, $parameters
|
|
);
|
|
|
|
$instances = $this->getDependencies(
|
|
$dependencies, $parameters
|
|
);
|
|
|
|
array_pop($this->buildStack);
|
|
|
|
return $reflector->newInstanceArgs($instances);
|
|
}
|
|
|
|
/**
|
|
* Resolve all of the dependencies from the ReflectionParameters.
|
|
*
|
|
* @param array $parameters
|
|
* @param array $primitives
|
|
* @return array
|
|
*/
|
|
protected function getDependencies(array $parameters, array $primitives = [])
|
|
{
|
|
$dependencies = [];
|
|
|
|
foreach ($parameters as $parameter) {
|
|
$dependency = $parameter->getClass();
|
|
|
|
// If the class is null, it means the dependency is a string or some other
|
|
// primitive type which we can not resolve since it is not a class and
|
|
// we will just bomb out with an error since we have no-where to go.
|
|
if (array_key_exists($parameter->name, $primitives)) {
|
|
$dependencies[] = $primitives[$parameter->name];
|
|
} elseif (is_null($dependency)) {
|
|
$dependencies[] = $this->resolveNonClass($parameter);
|
|
} else {
|
|
$dependencies[] = $this->resolveClass($parameter);
|
|
}
|
|
}
|
|
|
|
return (array) $dependencies;
|
|
}
|
|
|
|
/**
|
|
* Resolve a non-class hinted dependency.
|
|
*
|
|
* @param \ReflectionParameter $parameter
|
|
* @return mixed
|
|
*
|
|
* @throws \Illuminate\Contracts\Container\BindingResolutionException
|
|
*/
|
|
protected function resolveNonClass(ReflectionParameter $parameter)
|
|
{
|
|
if ($parameter->isDefaultValueAvailable()) {
|
|
return $parameter->getDefaultValue();
|
|
}
|
|
|
|
$message = "Unresolvable dependency resolving [$parameter] in class {$parameter->getDeclaringClass()->getName()}";
|
|
|
|
throw new BindingResolutionContractException($message);
|
|
}
|
|
|
|
/**
|
|
* Resolve a class based dependency from the container.
|
|
*
|
|
* @param \ReflectionParameter $parameter
|
|
* @return mixed
|
|
*
|
|
* @throws \Illuminate\Contracts\Container\BindingResolutionException
|
|
*/
|
|
protected function resolveClass(ReflectionParameter $parameter)
|
|
{
|
|
try {
|
|
return $this->make($parameter->getClass()->name);
|
|
}
|
|
|
|
// If we can not resolve the class instance, we will check to see if the value
|
|
// is optional, and if it is we will return the optional parameter value as
|
|
// the value of the dependency, similarly to how we do this with scalars.
|
|
catch (BindingResolutionContractException $e) {
|
|
if ($parameter->isOptional()) {
|
|
return $parameter->getDefaultValue();
|
|
}
|
|
|
|
throw $e;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* If extra parameters are passed by numeric ID, rekey them by argument name.
|
|
*
|
|
* @param array $dependencies
|
|
* @param array $parameters
|
|
* @return array
|
|
*/
|
|
protected function keyParametersByArgument(array $dependencies, array $parameters)
|
|
{
|
|
foreach ($parameters as $key => $value) {
|
|
if (is_numeric($key)) {
|
|
unset($parameters[$key]);
|
|
|
|
$parameters[$dependencies[$key]->name] = $value;
|
|
}
|
|
}
|
|
|
|
return $parameters;
|
|
}
|
|
|
|
/**
|
|
* Register a new resolving callback.
|
|
*
|
|
* @param string $abstract
|
|
* @param \Closure|null $callback
|
|
* @return void
|
|
*/
|
|
public function resolving($abstract, Closure $callback = null)
|
|
{
|
|
if ($callback === null && $abstract instanceof Closure) {
|
|
$this->resolvingCallback($abstract);
|
|
} else {
|
|
$this->resolvingCallbacks[$abstract][] = $callback;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Register a new after resolving callback for all types.
|
|
*
|
|
* @param string $abstract
|
|
* @param \Closure|null $callback
|
|
* @return void
|
|
*/
|
|
public function afterResolving($abstract, Closure $callback = null)
|
|
{
|
|
if ($abstract instanceof Closure && $callback === null) {
|
|
$this->afterResolvingCallback($abstract);
|
|
} else {
|
|
$this->afterResolvingCallbacks[$abstract][] = $callback;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Register a new resolving callback by type of its first argument.
|
|
*
|
|
* @param \Closure $callback
|
|
* @return void
|
|
*/
|
|
protected function resolvingCallback(Closure $callback)
|
|
{
|
|
$abstract = $this->getFunctionHint($callback);
|
|
|
|
if ($abstract) {
|
|
$this->resolvingCallbacks[$abstract][] = $callback;
|
|
} else {
|
|
$this->globalResolvingCallbacks[] = $callback;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Register a new after resolving callback by type of its first argument.
|
|
*
|
|
* @param \Closure $callback
|
|
* @return void
|
|
*/
|
|
protected function afterResolvingCallback(Closure $callback)
|
|
{
|
|
$abstract = $this->getFunctionHint($callback);
|
|
|
|
if ($abstract) {
|
|
$this->afterResolvingCallbacks[$abstract][] = $callback;
|
|
} else {
|
|
$this->globalAfterResolvingCallbacks[] = $callback;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the type hint for this closure's first argument.
|
|
*
|
|
* @param \Closure $callback
|
|
* @return mixed
|
|
*/
|
|
protected function getFunctionHint(Closure $callback)
|
|
{
|
|
$function = new ReflectionFunction($callback);
|
|
|
|
if ($function->getNumberOfParameters() == 0) {
|
|
return;
|
|
}
|
|
|
|
$expected = $function->getParameters()[0];
|
|
|
|
if (! $expected->getClass()) {
|
|
return;
|
|
}
|
|
|
|
return $expected->getClass()->name;
|
|
}
|
|
|
|
/**
|
|
* Fire all of the resolving callbacks.
|
|
*
|
|
* @param string $abstract
|
|
* @param mixed $object
|
|
* @return void
|
|
*/
|
|
protected function fireResolvingCallbacks($abstract, $object)
|
|
{
|
|
$this->fireCallbackArray($object, $this->globalResolvingCallbacks);
|
|
|
|
$this->fireCallbackArray(
|
|
$object, $this->getCallbacksForType(
|
|
$abstract, $object, $this->resolvingCallbacks
|
|
)
|
|
);
|
|
|
|
$this->fireCallbackArray($object, $this->globalAfterResolvingCallbacks);
|
|
|
|
$this->fireCallbackArray(
|
|
$object, $this->getCallbacksForType(
|
|
$abstract, $object, $this->afterResolvingCallbacks
|
|
)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Get all callbacks for a given type.
|
|
*
|
|
* @param string $abstract
|
|
* @param object $object
|
|
* @param array $callbacksPerType
|
|
*
|
|
* @return array
|
|
*/
|
|
protected function getCallbacksForType($abstract, $object, array $callbacksPerType)
|
|
{
|
|
$results = [];
|
|
|
|
foreach ($callbacksPerType as $type => $callbacks) {
|
|
if ($type === $abstract || $object instanceof $type) {
|
|
$results = array_merge($results, $callbacks);
|
|
}
|
|
}
|
|
|
|
return $results;
|
|
}
|
|
|
|
/**
|
|
* Fire an array of callbacks with an object.
|
|
*
|
|
* @param mixed $object
|
|
* @param array $callbacks
|
|
*/
|
|
protected function fireCallbackArray($object, array $callbacks)
|
|
{
|
|
foreach ($callbacks as $callback) {
|
|
$callback($object, $this);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Determine if a given type is shared.
|
|
*
|
|
* @param string $abstract
|
|
* @return bool
|
|
*/
|
|
public function isShared($abstract)
|
|
{
|
|
if (isset($this->bindings[$abstract]['shared'])) {
|
|
$shared = $this->bindings[$abstract]['shared'];
|
|
} else {
|
|
$shared = false;
|
|
}
|
|
|
|
return isset($this->instances[$abstract]) || $shared === true;
|
|
}
|
|
|
|
/**
|
|
* Determine if the given concrete is buildable.
|
|
*
|
|
* @param mixed $concrete
|
|
* @param string $abstract
|
|
* @return bool
|
|
*/
|
|
protected function isBuildable($concrete, $abstract)
|
|
{
|
|
return $concrete === $abstract || $concrete instanceof Closure;
|
|
}
|
|
|
|
/**
|
|
* Get the alias for an abstract if available.
|
|
*
|
|
* @param string $abstract
|
|
* @return string
|
|
*/
|
|
protected function getAlias($abstract)
|
|
{
|
|
return isset($this->aliases[$abstract]) ? $this->aliases[$abstract] : $abstract;
|
|
}
|
|
|
|
/**
|
|
* Get the container's bindings.
|
|
*
|
|
* @return array
|
|
*/
|
|
public function getBindings()
|
|
{
|
|
return $this->bindings;
|
|
}
|
|
|
|
/**
|
|
* Drop all of the stale instances and aliases.
|
|
*
|
|
* @param string $abstract
|
|
* @return void
|
|
*/
|
|
protected function dropStaleInstances($abstract)
|
|
{
|
|
unset($this->instances[$abstract], $this->aliases[$abstract]);
|
|
}
|
|
|
|
/**
|
|
* Remove a resolved instance from the instance cache.
|
|
*
|
|
* @param string $abstract
|
|
* @return void
|
|
*/
|
|
public function forgetInstance($abstract)
|
|
{
|
|
unset($this->instances[$abstract]);
|
|
}
|
|
|
|
/**
|
|
* Clear all of the instances from the container.
|
|
*
|
|
* @return void
|
|
*/
|
|
public function forgetInstances()
|
|
{
|
|
$this->instances = [];
|
|
}
|
|
|
|
/**
|
|
* Flush the container of all bindings and resolved instances.
|
|
*
|
|
* @return void
|
|
*/
|
|
public function flush()
|
|
{
|
|
$this->aliases = [];
|
|
$this->resolved = [];
|
|
$this->bindings = [];
|
|
$this->instances = [];
|
|
}
|
|
|
|
/**
|
|
* Set the globally available instance of the container.
|
|
*
|
|
* @return static
|
|
*/
|
|
public static function getInstance()
|
|
{
|
|
return static::$instance;
|
|
}
|
|
|
|
/**
|
|
* Set the shared instance of the container.
|
|
*
|
|
* @param \Illuminate\Contracts\Container\Container $container
|
|
* @return void
|
|
*/
|
|
public static function setInstance(ContainerContract $container)
|
|
{
|
|
static::$instance = $container;
|
|
}
|
|
|
|
/**
|
|
* Determine if a given offset exists.
|
|
*
|
|
* @param string $key
|
|
* @return bool
|
|
*/
|
|
public function offsetExists($key)
|
|
{
|
|
return isset($this->bindings[$key]);
|
|
}
|
|
|
|
/**
|
|
* Get the value at a given offset.
|
|
*
|
|
* @param string $key
|
|
* @return mixed
|
|
*/
|
|
public function offsetGet($key)
|
|
{
|
|
return $this->make($key);
|
|
}
|
|
|
|
/**
|
|
* Set the value at a given offset.
|
|
*
|
|
* @param string $key
|
|
* @param mixed $value
|
|
* @return void
|
|
*/
|
|
public function offsetSet($key, $value)
|
|
{
|
|
// If the value is not a Closure, we will make it one. This simply gives
|
|
// more "drop-in" replacement functionality for the Pimple which this
|
|
// container's simplest functions are base modeled and built after.
|
|
if (! $value instanceof Closure) {
|
|
$value = function () use ($value) {
|
|
return $value;
|
|
};
|
|
}
|
|
|
|
$this->bind($key, $value);
|
|
}
|
|
|
|
/**
|
|
* Unset the value at a given offset.
|
|
*
|
|
* @param string $key
|
|
* @return void
|
|
*/
|
|
public function offsetUnset($key)
|
|
{
|
|
unset($this->bindings[$key], $this->instances[$key], $this->resolved[$key]);
|
|
}
|
|
|
|
/**
|
|
* Dynamically access container services.
|
|
*
|
|
* @param string $key
|
|
* @return mixed
|
|
*/
|
|
public function __get($key)
|
|
{
|
|
return $this[$key];
|
|
}
|
|
|
|
/**
|
|
* Dynamically set container services.
|
|
*
|
|
* @param string $key
|
|
* @param mixed $value
|
|
* @return void
|
|
*/
|
|
public function __set($key, $value)
|
|
{
|
|
$this[$key] = $value;
|
|
}
|
|
}
|