Borobudur\Kernel\Middleware\MiddlewareContainer

Complexity

Total Complexity

11

Size/Duplication

Total Lines	112
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	add()	0	6	2
A	set()	0	4	1
A	has()	0	4	1
A	dispatches()	0	6	2
A	dispatch()	0	19	3
A	invoke()	0	11	2

<?php
/*
 * This file is part of the Borobudur-Kernel package.
 *
 * (c) Hexacodelabs <http://hexacodelabs.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Borobudur\Kernel\Middleware;

use Borobudur\DependencyInjection\ContainerAwareInterface;
use Borobudur\DependencyInjection\ContainerAwareTrait;
use Borobudur\Http\ParameterBag;
use Borobudur\Http\Request;
use Borobudur\Http\Response;
use Borobudur\Kernel\Exception\InvalidArgumentException;
use Borobudur\Routing\RequestContext;
use Closure;

/**
 * @author      Iqbal Maulana <iq.bluejack@gmail.com>
 * @created     8/15/15
 */
class MiddlewareContainer implements ContainerAwareInterface
{
    use ContainerAwareTrait;

    /**
     * @var MiddlewareInterface[]
     */
    private $middlewares = array();

    /**
     * @var MiddlewareInvoker[]
     */
    private $executes = array();

    /**
     * Add sets of middleware.
     *
     * @param array $middlewares
     */
    public function add(array $middlewares)
    {
        foreach ($middlewares as $middleware) {
            $this->set($middleware);
        }
    }

    /**
     * Register middleware.
     *
     * @param MiddlewareInterface $middleware
     */
    public function set(MiddlewareInterface $middleware)
    {
        $this->middlewares[$middleware->getName()] = $middleware;
    }

    /**
     * Check if middleware was registered.
     *
     * @param string $name
     *
     * @return bool
     */
    public function has($name)
    {
        return array_key_exists($name, $this->middlewares);
    }

    /**
     * Register sets of middleware to be invoke.
     *
     * @param array $middlewares
     * @param array $excepts
     * @param array $only
     */
    public function dispatches(array $middlewares, array $excepts = array(), array $only = array())
    {
        foreach ($middlewares as $middleware) {
            $this->dispatch($middleware)->except($excepts)->only($only);
        }
    }

    /**
     * Register middleware to be invoke.
     *
     * @param string $name
     * @param array  $params
     *
     * @return MiddlewareInvoker
     */
    public function dispatch($name, array $params = array())
    {
        if (isset($this->middlewares[$name])) {
            $middleware = $this->middlewares[$name];
            $middleware->setParameter(new ParameterBag((array) $params));

            if (method_exists($middleware, 'configure')) {
                $instance = $this->container->getDi()->create($middleware);
                $instance->callMethod('configure');
                $middleware = $instance->getOriginalInstance();
            }

            $this->executes[] = $invoker = new MiddlewareInvoker($middleware);

            return $invoker;
        }

        throw new InvalidArgumentException(sprintf('Middleware "%s" is not registered.', $name));
    }

    /**
     * Invoke middleware.
     *
     * @param Request        $request
     * @param RequestContext $context
     * @param Closure        $next
     * @param string|null    $action
     *
     * @return Response|mixed|null
     */
    public function invoke(Request $request, RequestContext $context, Closure $next, $action = null)
    {
        $executes = array_reverse($this->executes);
        foreach ($executes as $caller) {
            $next = function () use (&$request, &$context, $caller, $next, $action) {
                return $caller($request, $context, $next, $action);
            };
        }

        return call_user_func($next);
    }
}