Lead\Router\Scope

Complexity

Total Complexity

16

Size/Duplication

Total Lines	152
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__call()	0	7	1
A	apply()	0	7	2
A	__construct()	0	21	1
B	scopify()	0	22	7
A	middleware()	0	8	4
A	seed()	0	7	1

<?php
declare(strict_types=1);

namespace Lead\Router;

/**
 * Scope
 */
class Scope implements ScopeInterface
{
    /**
     * The router instance.
     *
     * @var object
     */
    protected $_router = null;

    /**
     * The parent instance.
     *
     * @var object
     */
    protected $_parent = null;

    /**
     * The middleware array.
     *
     * @var array
     */
    protected $_middleware = [];

    /**
     * The scope data.
     *
     * @var array
     */
    protected $_scope = [];

    /**
     * The constructor.
     *
     * @param array $config The config array.
     */
    public function __construct($config = [])
    {
        $defaults = [
            'router' => null,
            'parent' => null,
            'middleware' => [],
            'scope'  => []
        ];
        $config += $defaults;

        $this->_router = $config['router'];
        $this->_parent = $config['parent'];
        $this->_middleware = $config['middleware'];
        $this->_scope = $config['scope'] + [
            'name'           => '',
            'scheme'         => '*',
            'host'           => '*',
            'methods'        => '*',
            'prefix'         => '',
            'namespace'      => '',
            'persist'        => []
        ];
    }

    /**
     * Creates a new sub scope based on the instance scope.
     *
     * @param  array $options The route options to scopify.
     * @return $this          The new sub scope.
     */
    public function seed(array $options): ScopeInterface
    {
        return new static(
            [
            'router' => $this->_router,
            'parent' => $this,
            'scope'  => $this->scopify($options)
            ]
        );
    }

    /**
     * Scopes an options array according to the instance scope data.
     *
     * @param  array $options The options to scope.
     * @return array          The scoped options.
     */
    public function scopify(array $options): array
    {
        $scope = $this->_scope;

        if (!empty($options['name'])) {
            $options['name'] = $scope['name'] ? $scope['name'] . '.' . $options['name'] : $options['name'];
        }

        if (!empty($options['prefix'])) {
            $options['prefix'] = $scope['prefix'] . trim($options['prefix'], '/');
            $options['prefix'] = $options['prefix'] ? $options['prefix'] . '/' : '';
        }

        if (isset($options['persist'])) {
            $options['persist'] = ((array) $options['persist']) + $scope['persist'];
        }

        if (isset($options['namespace'])) {
            $options['namespace'] = $scope['namespace'] . trim($options['namespace'], '\\') . '\\';
        }

        return $options + $scope;
    }

    /**
     * Middleware generator.
     *
     * @return callable
     */
    public function middleware()
    {
        foreach ($this->_middleware as $middleware) {
            yield $middleware;

The expression yield $middleware returns the type Generator which is incompatible with the documented return type callable.

        }
        if ($this->_parent) {
            foreach ($this->_parent->middleware() as $middleware) {
                yield $middleware;
            }
        }
    }

    /**
     * Adds a middleware to the list of middleware
     *
     * @param object|\Closure A callable middleware

The type Lead\Router\A was not found. Did you mean A? If so, make sure to prefix the type with \.

     * @return \Lead\Router\ScopeInterface
     */
    public function apply($middleware): ScopeInterface
    {
        foreach (func_get_args() as $mw) {
            array_unshift($this->_middleware, $mw);
        }

        return $this;
    }

    /**
     * Delegates calls to the router instance
     *
     * @param string $name The method name
     * @param array $params The parameters
     * @return mixed
     */
    public function __call(string $name, array $params)
    {
        $this->_router->pushScope($this);
        $result = call_user_func_array([$this->_router, $name], $params);
        $this->_router->popScope();

        return $result;
    }
}