/**
* 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, $parameters = [])
{
$dependencies = [];
foreach ($this->getCallReflector($callback)->getParameters() as $key => $parameter) {
$this->addDependencyForCallParameter($parameter, $parameters, $dependencies);
}
return array_values(
array_filter(
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 ($this->getParameterType($parameter)) {
$dependencies[] = $this->make($this->getParameterName($parameter));
} elseif ($parameter->isDefaultValueAvailable()) {
$dependencies[] = $parameter->getDefaultValue();
}
}
/**
* Get the parameter type for the given parameter.
*
* @return object ReflectionClass|ReflectionNamedType
*/
protected function getParameterType($parameter)
{
if (method_exists($parameter, 'getType')) {
return $parameter->getType();
}
return $parameter->getClass();
}
/**
* Get the parameter name for the given parameter.
*
* @return string
*/
protected function getParameterName($parameter)
{
$parameterType = $this->getParameterType($parameter);
if (property_exists($parameterType, 'name')) {
return $parameterType->name;
}
return $parameterType->getName();
}
/**
* 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, $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 BindingResolutionException
*/
public function build($concrete, $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 BindingResolutionException($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($parameters, array $primitives = [])
{
$dependencies = [];
$types = ['bool', 'int', 'float', 'string', 'array', 'resource'];
foreach ($parameters as $parameter) {
if ($dependency = $this->getParameterType($parameter)) {
$dependency = $dependency->getName();
if ($dependency && in_array($dependency, $types)) {
$dependency = null;
}
}
// 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 BindingResolutionException
*/
protected function resolveNonClass(ReflectionParameter $parameter)
{
if ($parameter->isDefaultValueAvailable()) {
return $parameter->getDefaultValue();
}
$message = "Unresolvable dependency resolving [{$parameter}] in class {$parameter->getDeclaringClass()->getName()}";
throw new BindingResolutionException($message);
}
/**
* Resolve a class based dependency from the container.
*
* @param ReflectionParameter $parameter
* @return mixed
*
* @throws BindingResolutionException
*/
protected function resolveClass(ReflectionParameter $parameter)
{
try {
return $this->make($this->getParameterName($parameter));
} catch (BindingResolutionException $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 $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 $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 NinjaTables\Framework\Foundation\Container $container
* @return void
*/
public static function setInstance(ContainerContract $container)
{
static::$instance = $container;
}
/**
* Determine if a given offset exists.
*
* @param string $key
* @return bool
*/
#[\ReturnTypeWillChange]
public function offsetExists($key)
{
return isset($this->bindings[$key]);
}
/**
* Get the value at a given offset.
*
* @param string $key
* @return mixed
*/
#[\ReturnTypeWillChange]
public function offsetGet($key)
{
return $this->make($key);
}
/**
* Set the value at a given offset.
*
* @param string $key
* @param mixed $value
* @return void
*/
#[\ReturnTypeWillChange]
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
*/
#[\ReturnTypeWillChange]
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;
}
}
Fatal error: Uncaught Error: Class 'NinjaTables\Framework\Foundation\Container' not found in /home/nimaghor/public_html/wp-content/plugins/ninja-tables/vendor/wpfluent/framework/src/WPFluent/Foundation/Application.php:13
Stack trace:
#0 /home/nimaghor/public_html/wp-content/plugins/RTL-CareUnit/vendor/composer/ClassLoader.php(0): unknown()
#1 /home/nimaghor/public_html/wp-content/plugins/RTL-CareUnit/vendor/composer/ClassLoader.php(0): Composer\Autoload\includeFile('/home/nimaghor/...')
#2 [internal function]: Composer\Autoload\ClassLoader->loadClass('NinjaTables\\Fra...')
#3 /home/nimaghor/public_html/wp-content/plugins/ninja-tables/boot/app.php(9): spl_autoload_call('NinjaTables\\Fra...')
#4 /home/nimaghor/public_html/wp-content/plugins/ninja-tables/ninja-tables.php(25): {closure}('/home/nimaghor/...')
#5 /home/nimaghor/public_html/wp-content/plugins/ninja-tables/ninja-tables.php(26): {closure}(Object(Closure))
#6 /home/nimaghor/public_html/wp-settings.php(517): include_once('/home/nimaghor/...')
#7 /home/nimaghor/publi in /home/nimaghor/public_html/wp-content/plugins/ninja-tables/vendor/wpfluent/framework/src/WPFluent/Foundation/Application.php on line 13