Resolver::unserialize() - Code Metrics - Inspection of "serializable application" - mvc5/mvc5 - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( 7b5e8d...349330 )

by devosc
created 2016-12-14 05:04 UTC
Resolver::unserialize() A

↳ Parent: Resolver
Complexity

Conditions	1
Paths	1
Size

Total Lines	6
Code Lines	4
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	1
CRAP Score	1
Importance

Changes
Metric	Value
dl	0
loc	6
ccs	1
cts	1
cp	1
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	4
nc	1
nop	1
crap	1
<?php
/**
 *
 */

namespace Mvc5\Resolver;

use Closure;
use Mvc5\Arg;
use Mvc5\Event\Event;
use Mvc5\Plugin\Gem\Args;
use Mvc5\Plugin\Gem\Call;
use Mvc5\Plugin\Gem\Calls;
use Mvc5\Plugin\Gem\Child;
use Mvc5\Plugin\Gem\Config;
use Mvc5\Plugin\Gem\Copy;
use Mvc5\Plugin\Gem\Factory;
use Mvc5\Plugin\Gem\FileInclude;
use Mvc5\Plugin\Gem\Filter;
use Mvc5\Plugin\Gem\Gem;
use Mvc5\Plugin\Gem\Invokable;
use Mvc5\Plugin\Gem\Invoke;
use Mvc5\Plugin\Gem\Link;
use Mvc5\Plugin\Gem\Param;
use Mvc5\Plugin\Gem\Plug;
use Mvc5\Plugin\Gem\Plugin;
use Mvc5\Plugin\Gem\Provide;
use Mvc5\Plugin\Gem\Scoped;
use Mvc5\Plugin\Gem\Shared;
use Mvc5\Plugin\Gem\SignalArgs;
use Mvc5\Plugin\Gem\Value;
use Mvc5\Resolvable;
use Mvc5\Service\Config\Container;

trait Resolver
{
    /**
     *
     */
    use Build;
    use Container;
    use Generator;
    use Initializer;

    /**
     * @var callable
     */
    protected $provider;

    /**
     * @var object
     */
    protected $scope;

    /**
     * @var bool
     */
    protected $strict = false;

    /**
     * @param array|\ArrayAccess $config
     * @param callable $provider
     * @param object $scope
     * @param bool $strict
     */
    function __construct($config = null, callable $provider = null, $scope = null, $strict = false)

    {
        $config && $this->config = $config;
class Id
{
    public $id;

    public function __construct($id)
    {
        $this->id = $id;
    }

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}

        isset($config[Arg::CONTAINER])
            && $this->container = $config[Arg::CONTAINER];

        isset($config[Arg::EVENTS])
            && $this->events = $config[Arg::EVENTS];

        isset($config[Arg::SERVICES])
            && $this->services = $config[Arg::SERVICES];

        $provider && $this->provider = $this->resolve($provider);
class Id
{
    public $id;

    public function __construct($id)
    {
        $this->id = $id;
    }

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}

        $scope && $this->scope = $this->resolve($scope);
class Id
{
    public $id;

    public function __construct($id)
    {
        $this->id = $id;
    }

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}

        $strict && $this->strict = $strict;
    }

    /**
     * @param $args
     * @return array|callable|null|object|string
     */
    protected function args($args)
    {
        if (!$args) {
            return $args;
        }

        if (!is_array($args)) {
            return $this->resolve($args);
        }

        foreach($args as $index => $value) {
            $value instanceof Resolvable && $args[$index] = $this->resolve($value);
        }

        return $args;
    }

    /**
     * @param array $child
     * @param array $parent
     * @return array
     */
    protected function arguments(array $child, array $parent)
    {
        return !$parent ? $child : (
            !$child ? $parent : (is_string(key($child)) ? $child + $parent : array_merge($child, $parent))
        );
    }

    /**
     * @param Closure $callback
     * @param $scope
     * @return Closure
     */
    protected function bind(Closure $callback, $scope)
    {
        return Closure::bind($callback, $scope, $scope);
    }

    /**
     * @param array|callable|object|string $config
     * @param array $args
     * @param callable $callback
     * @return callable|mixed|null|object
     */
    function call($config, array $args = [], callable $callback = null)

    {
        if (is_string($config)) {
            return $this->transmit(explode(Arg::CALL_SEPARATOR, $config), $args, $callback);
        }

        if ($config instanceof Event) {
            return $this->event($config, $args, $callback);
        }

        return $this->invoke($config instanceof Resolvable ? $this->resolve($config) : $config, $args, $callback);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
    }

    /**
     * @param array|callable|object|string $config
     * @return callable|null
     */
    protected function callable($config) : callable
    {
        if (is_string($config)) {
            return function(...$args) use($config) {
                return $this->call($config, $this->variadic($args));
            };
        }

        if (is_array($config)) {
            return is_string($config[0]) ? $config : [$this->resolve($config[0]), $config[1]];
        }

        return $config instanceof Closure ? $config : $this->listener($this->resolve($config));
    }

    /**
     * @param Child $config
     * @param array $args
     * @return array|callable|object|string
     */
    protected function child(Child $config, array $args = [])
    {
        return $this->provide($this->merge(clone $this->parent($config->parent()), $config), $args);
    }

    /**
     * @param $name
     * @return callable|mixed|object
     */
    protected function fallback($name)
    {
        return $this(Arg::EVENT_MODEL, [Arg::EVENT => $name]) ?: Unresolvable::plugin($name);
    }

    /**
     * @param array|callable|null|object|string $value
     * @param array|\Traversable $filters
     * @param array $args
     * @param $param
     * @return mixed
     */
    protected function filter($value, $filters = [], array $args = [], $param = null)
    {
        $result = $value;

        foreach($filters as $filter) {
            $value = $this->invoke(
                $this->callable($filter), $param ? [$param => $result] + $args : array_merge([$result], $args)

            );

            if (false === $value) {
                return $result;
            }

            if (null === $value) {
                return null;
            }

            $result = $value;
        }

        return $result;
    }

    /**
     * @param Filter $config
     * @param array $args
     * @return mixed
     */
    protected function filterable(Filter $config, array $args = [])
    {
        return $this->filter(
            $this->resolve($config->config()), $this->resolve($config->filter()), $args, $config->param()
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        );
    }

    /**
     * @param $config
     * @param array $args
     * @return mixed|callable
     */
    protected function gem($config, array $args = [])
    {
        if ($config instanceof Factory) {
            return $this->invoke($this->child($config, $args));

        }

        if ($config instanceof Calls) {
            return $this->hydrate($config, $this->resolve($config->name(), $args));

        }

        if ($config instanceof Child) {
            return $this->child($config, $args);
        }

        if ($config instanceof Plugin) {
            return $this->provide($config, $args);
        }

        if ($config instanceof Shared) {
            return $this->shared($config->name(), $config->config());
        }

        if ($config instanceof Param) {
            return $this->resolve($this->param($config->name()), $args);
        }

        if ($config instanceof Call) {
            return $this->call($this->resolve($config->config()), $this->vars($args, $config->args()));

        }

        if ($config instanceof Args) {
            return $this->args($config->config());
        }

        if ($config instanceof Config) {
            return $this->config();
        }

        if ($config instanceof Link) {
            return $this;
        }

        if ($config instanceof Filter) {
            return $this->filterable($config, $this->vars($args, $config->args()));
        }

        if ($config instanceof Plug) {
            return $this->configured($config->name());
        }

        if ($config instanceof Invoke) {
            return function(...$args) use ($config) {
                return $this->call(
                    $this->resolve($config->config()), $this->vars($this->variadic($args), $config->args())

                );
            };
        }

        if ($config instanceof Invokable) {
            return function(...$args) use ($config) {
                return $this->resolve($config->config(), $this->vars($this->variadic($args), $config->args()));
            };
        }

        if ($config instanceof FileInclude) {
            $include = new class() {
                function __invoke($file) {

                    return include $file;
                }
            };

            return $include($this->resolve($config->config()));
        }

        if ($config instanceof Copy) {
            return clone $this->resolve($config->config(), $args);
        }

        if ($config instanceof Value) {
            return $config->config();
        }

        if ($config instanceof Scoped) {
            return $this->scoped($config->closure());
        }

        if ($config instanceof Provide) {
            return ($this->provider() ?: new Unresolvable)($config->config(), $this->vars($args, $config->args()));
        }

        return Unresolvable::plugin($config);
    }

    /**
     * @param string $name
     * @return mixed
     */
    function get($name)
    {
        return $this->stored($name) ?? $this($name);
    }

    /**
     * @param Plugin $config
     * @param object $service
     * @return object
     */
    protected function hydrate(Plugin $config, $service)
    {
        foreach($config->calls() as $method => $args) {
            if (is_string($method)) {
                if (Arg::INDEX == $method[0]) {
                    $service[substr($method, 1)] = $this->resolve($args);
                    continue;
                }

                if (Arg::PROPERTY == $method[0]) {
                    $service->{substr($method, 1)} = $this->resolve($args);
                    continue;
                }

                $service->$method($this->resolve($args));
                continue;
            }

            if (is_array($args)) {
                $method = array_shift($args);
                $param  = $config->param();

                if (is_string($method) && Arg::PROPERTY == $method[0]) {
                    $param  = substr($method, 1);
                    $method = array_shift($args);
                }

                $this->invoke(
                    is_string($method) ? [$service, $method] : $this->callable($method),
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
                    ($param && (!$args || is_string(key($args))) ? [$param => $service] : []) + $this->args($args)

                );

                continue;
            }

            $this->resolve($args);
        }

        return $service;
    }

    /**
     * @param array|callable|object|string $name
     * @return callable|null
     */
    protected function invokable($name)
    {
        return Arg::CALL === $name[0] ? substr($name, 1) :
            $this->listener($this->plugin($name, [], $this) ?: $this->fallback($name));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * @param array|callable|object|string $config
     * @param array $args
     * @param callable $callback
     * @return array|callable|object|string
     */
    protected function invoke($config, array $args = [], callable $callback = null)
    {
        return $this->signal($config, $args, $callback ?? $this);
    }

    /**
     * @param $plugin
     * @return callable|null
     */
    protected function listener($plugin)
    {
        return !$plugin instanceof Event ? $plugin : function(...$args) use ($plugin) {
            return $this->event($plugin, $this->variadic($args));
        };
    }

    /**
     * @param Plugin $parent
     * @param Plugin $config
     * @param null|string $name
     * @return Plugin
     */
    protected function merge(Plugin $parent, Plugin $config, $name = null)
    {
        !$parent->name() &&
            $parent[Arg::NAME] = $name ?? $this->resolve($config->name());

        $config->args() &&
            $parent[Arg::ARGS] = is_string(key($config->args())) ? $config->args() + $parent->args() : $config->args();

        $config->calls() &&
            $parent[Arg::CALLS] = $config->merge() ? array_merge($parent->calls(), $config->calls()) : $config->calls();

        $config->param() &&
            $parent[Arg::PARAM] = $config->param();

        return $parent;
    }

    /**
     * @param string $name
     * @return mixed
     */
    function param($name)
    {
        $name  = explode(Arg::CALL_SEPARATOR, $name);
        $value = $this->config()[array_shift($name)];

        foreach($name as $n) {
            $value = $value[$n];
        }

        return $value;
    }

    /**
     * @param $config
     * @return array|callable|Plugin|null|object|string
     */
    protected function parent($config)
    {
        return $this->configured($this->resolve($config));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * @param string $config
     * @param array $args
     * @param callable|null $callback
     * @param null|string $previous
     * @return array|callable|null|object|string
     */
    function plugin($config, array $args = [], callable $callback = null, $previous = null)
    {
        if (!$config) {
            return $config;
        }

        if (is_string($config)) {
            return $this->build(explode(Arg::SERVICE_SEPARATOR, $config), $args, $callback);
        }

        if (is_array($config)) {
            return $this->pluginArray(array_shift($config), $args + $this->args($config), $callback, $previous);

        }

        if ($config instanceof Closure) {
            return $this->invoke($this->scoped($config), $args);
        }

        return $this->resolve($config, $args);
    }

    /**
     * @param $config
     * @param array $args
     * @param callable|null $callback
     * @param null $previous
     * @return array|callable|null|object|string
     */
    protected function pluginArray($config, array $args = [], callable $callback = null, $previous = null)
    {
        return $previous && $previous === $config ?
            $this->callback($config, true, $args, $callback) : $this->plugin($config, $args, $callback);
    }

    /**
     * @param Plugin $config
     * @param array $args
     * @return callable|null|object
     */
    protected function provide(Plugin $config, array $args = [])
    {
        $name   = $this->resolve($config->name());
        $parent = $this->configured($name);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        $args && is_string(key($args)) && $config->args() && $args += $this->args($config->args());


        !$args && $args = $this->args($config->args());

        if (!$parent) {
            return $this->hydrate($config, $this->combine(explode(Arg::SERVICE_SEPARATOR, $name), $args));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        }

        if (!$parent instanceof Plugin) {
            return $this->hydrate(
                $config, $name === $parent ? $this->make($name, $args) : $this->plugin($this->resolve($parent), $args)
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            );
        }

        if ($name == $parent->name()) {
            return $this->hydrate($config, $this->make($name, $args));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        }

        return $this->provide($this->merge(clone $parent, $config, $name), $args);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
    }

    /**
     * @return callable
     */
    protected function provider()
    {
        return $this->provider;
    }

    /**
     * @param $plugin
     * @param array $config
     * @param array $args
     * @param callable|null $callback
     * @return array|callable|object|string
     */
    protected function relay($plugin, array $config = [], array $args = [], callable $callback = null)
    {
        return !$config ? $this->invoke($plugin, $args, $callback) :
            $this->repeat($plugin, array_shift($config), $config, $args, $callback);
    }

    /**
     * @param $plugin
     * @param $name
     * @param array $config
     * @param array $args
     * @param callable|null $callback
     * @return array|callable|object|string
     */
    protected function repeat($plugin, $name, array $config = [], array $args = [], callable $callback = null)
    {
        return !$config ? $this->invoke([$plugin, $name], $args, $callback) : $this->repeat(
            $this->invoke([$plugin, $name], $args, $callback), array_shift($config), $config, $args, $callback
        );
    }

    /**
     * @param $config
     * @param array $args
     * @param callable $callback
     * @param int $c
     * @return array|callable|Plugin|null|object|Resolvable|string
     */
    protected function resolvable($config, array $args = [], callable $callback = null, $c = 0)
    {
        return !$config instanceof Resolvable ? $config : (
            $c > Arg::MAX_RECURSION ? Unresolvable::plugin($config) :
                $this->resolvable($this->solve($config, $args, $callback), $args, $callback, ++$c)
        );
    }

    /**
     * @param $config
     * @param array $args
     * @return array|callable|Plugin|null|object|Resolvable|string
     */
    protected function resolve($config, array $args = [])
    {
        return $this->resolvable($config, $args);
    }

    /**
     * @param $config
     * @param array $args
     * @return callable|mixed|null|object
     */
    protected function resolver($config, array $args = [])
    {
        return $this->call($this->provider() ?: Arg::SERVICE_RESOLVER, [$config, $args]);
    }

    /**
     * @param $config
     * @param array $args
     * @param callable $callback
     * @return mixed|callable
     */
    protected function solve($config, array $args = [], callable $callback = null)
    {
        return $config instanceof Gem ? $this->gem($config, $args) : (
            $callback ? $callback($config, $args) : $this->resolver($config, $args)
        );
    }

    /**
     * @param object $scope
     * @return object
     */
    function scope($scope = null)
    {
        return null !== $scope ? $this->scope = $scope : $this->scope;
    }

    /**
     * @param Closure $callback
     * @return Closure
     */
    protected function scoped(Closure $callback)
    {
        return $this->scope ? $this->bind($callback, $this->scope === true ? $this : $this->scope) : $callback;
    }

    /**
     * @return string
     */
    function serialize()
    {
        return serialize([$this->config, $this->events, $this->provider, $this->scope, $this->services, $this->strict]);
    }

    /**
     * @param $name
     * @param null $config
     * @return callable|mixed|null|object
     */
    function shared($name, $config = null)
    {
        return $this->stored($name) ?? $this->initialize($name, $config);
    }

    /**
     * @return bool
     */
    protected function strict()
    {
        return $this->strict;
    }

    /**
     * @param array $config
     * @param array $args
     * @param callable|null $callback
     * @return array|callable|object|string
     */
    protected function transmit(array $config = [], array $args = [], callable $callback = null)
    {
        return $this->relay($this->invokable(array_shift($config)), $config, $args, $callback);
    }

    /**
     * @param array|object|string|\Traversable $event
     * @param array $args
     * @param callable $callback
     * @return mixed|null
     */
    function trigger($event, array $args = [], callable $callback = null)
    {
        return $this->event($event instanceof Event ? $event : $this($event) ?? $event, $args, $callback);
    }

    /**
     * @param string $serialized
     */
    function unserialize($serialized)
    {
        list(
            $this->config, $this->events, $this->provider, $this->scope, $this->services, $this->strict
            ) = unserialize($serialized);
    }

    /**
     * @param array $args
     * @return array
     */
    protected function variadic(array $args)
    {
        return $args && $args[0] instanceof SignalArgs ? $args[0]->args() : $args;

    }

    /**
     * @param array $child
     * @param array $parent
     * @return array
     */
    protected function vars(array $child = [], array $parent = [])
    {
        return $this->arguments($child, $this->args($parent));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     *
     */
    function __clone()
    {
        is_object($this->config) &&
            $this->config = clone $this->config;

        if (is_object($this->container)) {
            $this->container = clone $this->container;

            if (isset($this->config[Arg::CONTAINER])) {
                $this->config[Arg::CONTAINER] = $this->container;
            }
        }

        if (is_object($this->events)) {
            $this->events = clone $this->events;

            if (isset($this->config[Arg::EVENTS])) {
                $this->config[Arg::EVENTS] = $this->events;
            }
        }

        if (is_object($this->services)) {
            $this->services = clone $this->services;

            if (isset($this->config[Arg::SERVICES])) {
                $this->config[Arg::SERVICES] = $this->services;
            }
        }

        is_object($this->scope) &&
            $this->scope = clone $this->scope;
    }

    /**
     * @param string $name
     * @param array $args
     * @return array|callable|null|object|string
     */
    function __invoke($name, array $args = [])
    {
        return $this->plugin($name, $args, $this->provider() ?? function(){});
    }
}

1			<?php
2			/**
3			*
4			*/
5
6			namespace Mvc5\Resolver;
7
8			use Closure;
9			use Mvc5\Arg;
10			use Mvc5\Event\Event;
11			use Mvc5\Plugin\Gem\Args;
12			use Mvc5\Plugin\Gem\Call;
13			use Mvc5\Plugin\Gem\Calls;
14			use Mvc5\Plugin\Gem\Child;
15			use Mvc5\Plugin\Gem\Config;
16			use Mvc5\Plugin\Gem\Copy;
17			use Mvc5\Plugin\Gem\Factory;
18			use Mvc5\Plugin\Gem\FileInclude;
19			use Mvc5\Plugin\Gem\Filter;
20			use Mvc5\Plugin\Gem\Gem;
21			use Mvc5\Plugin\Gem\Invokable;
22			use Mvc5\Plugin\Gem\Invoke;
23			use Mvc5\Plugin\Gem\Link;
24			use Mvc5\Plugin\Gem\Param;
25			use Mvc5\Plugin\Gem\Plug;
26			use Mvc5\Plugin\Gem\Plugin;
27			use Mvc5\Plugin\Gem\Provide;
28			use Mvc5\Plugin\Gem\Scoped;
29			use Mvc5\Plugin\Gem\Shared;
30			use Mvc5\Plugin\Gem\SignalArgs;
31			use Mvc5\Plugin\Gem\Value;
32			use Mvc5\Resolvable;
33			use Mvc5\Service\Config\Container;
34
35			trait Resolver
36			{
37			/**
38			*
39			*/
40			use Build;
mvc5 / mvc5

Push — master ( 7b5e8d...349330 )

Resolver::unserialize() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
