Queue::push() - Code Metrics - phossa2/middleware - Measure and Improve Code Quality continuously with Scrutinizer

Queue::push() A
last analyzed 2016-10-12 00:54 UTC

↳ Parent: Queue

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	6
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	4
nc	1
nop	2

<?php
/**
 * Phossa Project
 *
 * PHP version 5.4
 *
 * @category  Library
 * @package   Phossa2\Middleware
 * @copyright Copyright (c) 2016 phossa.com
 * @license   http://mit-license.org/ MIT License
 * @link      http://www.phossa.com/
 */
/*# declare(strict_types=1); */

namespace Phossa2\Middleware;

use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;
use Phossa2\Shared\Base\ObjectAbstract;
use Phossa2\Middleware\Message\Message;
use Phossa2\Middleware\Exception\LogicException;
use Phossa2\Middleware\Interfaces\QueueInterface;
use Phossa2\Middleware\Interfaces\DelegateInterface;
use Phossa2\Middleware\Interfaces\ConditionInterface;
use Phossa2\Middleware\Interfaces\MiddlewareInterface;

/**
 * Queue
 *
 * Middleware queue
 *
 * @package Phossa2\Middleware
 * @author  Hong Zhang <[email protected]>
 * @version 2.0.1
 * @since   2.0.0 added
 * @since   2.0.1 added $terminate
 */
class Queue extends ObjectAbstract implements QueueInterface
{
    /**
     * @var    \SplQueue
     * @access protected
     */
    protected $queue;

    /**
     * @var    bool
     * @access protected
     */
    protected $terminate = false;

    /**
     * Constructor
     *
     * @param  array $middlewares
     * @access public
     */
    public function __construct(
        array $middlewares = []
    ) {
        // create the queue
        $this->queue = new \SplQueue();

        // fill the queue with middlewares
        $this->fillTheQueue($middlewares);
    }

    /**
     * Compatible with middlewares of the signature
     *
     * ```php
     * fn($request, $response, callable $next)
     * ```
     *
     * @param  RequestInterface $request
     * @param  ResponseInterface $response
     * @param  DelegateInterface $next
     * @return ResponseInterface
     * @access public
     */
    public function __invoke(
        RequestInterface $request,
        ResponseInterface $response,
        DelegateInterface $next = null
    )/*# : ResponseInterface */ {
        return $this->process($request, $response, $next);
    }

    /**
     * {@inheritDoc}
     */
    public function push($middleware, $condition = null)
    {
        $this->queue->push([$middleware, $condition]);
        $this->queue->rewind();
        return $this;
    }

    /**
     * {@inheritDoc}
     */
    public function process(
        RequestInterface $request,
        ResponseInterface $response,
        DelegateInterface $next = null
    )/*# : ResponseInterface */ {
        // process the queue
        $response = $this->next($request, $response);

        // $next is parent queue
        return ($next && !$this->terminate) ?
            $next->next($request, $response) :
            $response;
    }

    /**
     * {@inheritDoc}
     */
    public function next(
        RequestInterface $request,
        ResponseInterface $response
    )/*# : ResponseInterface */ {
        if ($this->queue->valid()) {
            list($middleware, $condition) = $this->queue->current();
            $this->queue->next();

            if (null === $condition ||
                $this->evalCondition($condition, $request, $response)
            ) { // run this mw
                return $this->runMiddleware($middleware, $request, $response);
            } else { // skip this mw
                return $this->next($request, $response);
            }
        }
        $this->queue->rewind();
        return $response;
    }

    /**
     * Fill the queue with middlewares
     *
     * @param  array $middlewares
     * @access protected
     */
    protected function fillTheQueue(array $middlewares)
    {
        foreach ($middlewares as $mw) {
            // with conditions specified
            if (is_array($mw)) {
                $this->push($mw[0], $mw[1]);

            // no condition
            } else {
                $this->push($mw);
            }
        }
    }

    /**
     * Process/run this middleware
     *
     * @param  MiddlewareInterface|callable $middleware
     * @param  RequestInterface $request
     * @param  ResponseInterface $response
     * @return ResponseInterface
     * @throws LogicException if invalid middleware type
     * @access protected
     */
    protected function runMiddleware(
        $middleware,
        RequestInterface $request,
        ResponseInterface $response
    )/*# : ResponseInterface */ {
        // instance of MiddlewareInterface
        if (is_object($middleware) && $middleware instanceof MiddlewareInterface) {
            return $middleware->process($request, $response, $this);

        // old style callable
        } elseif (is_callable($middleware)) {
            return $middleware($request, $response, $this);

        // unknown middleware type
        } else {
            throw new LogicException(
                Message::get(Message::MIDDLEWARE_INVALID, $middleware),
                Message::MIDDLEWARE_INVALID
            );
        }
    }

    /**
     * Evaluate the condition
     *
     * support both a callable returns bool value or an object instance of
     * ConditionInterface.
     *
     * @param  ConditionInterface|callable $condition
     * @param  RequestInterface $request
     * @param  ResponseInterface $response
     * @return bool
     * @throws LogicException if condition is invalid
     * @access protected
     */
    protected function evalCondition(
        $condition,
        RequestInterface $request,
        ResponseInterface $response
    )/*# : bool */ {
        // instanceof ConditionInterface
        if (is_object($condition) && $condition instanceof ConditionInterface) {
            return $condition->evaluate($request, $response);

        // old style callable
        } elseif (is_callable($condition)) {
            return $condition($request, $response);

        // unknown type
        } else {
            throw new LogicException(
                Message::get(Message::CONDITION_INVALID, $condition),
                Message::CONDITION_INVALID
            );
        }
    }
}


1		<?php
2		/**
3		* Phossa Project
4		*
5		* PHP version 5.4
6		*
7		* @category Library
8		* @package Phossa2\Middleware
9		* @copyright Copyright (c) 2016 phossa.com
10		* @license http://mit-license.org/ MIT License
11		* @link http://www.phossa.com/
12		*/
13		/# declare(strict_types=1); /
14
15		namespace Phossa2\Middleware;
16
17		use Psr\Http\Message\RequestInterface;
18		use Psr\Http\Message\ResponseInterface;
19		use Phossa2\Shared\Base\ObjectAbstract;
20		use Phossa2\Middleware\Message\Message;
21		use Phossa2\Middleware\Exception\LogicException;
22		use Phossa2\Middleware\Interfaces\QueueInterface;
23		use Phossa2\Middleware\Interfaces\DelegateInterface;
24		use Phossa2\Middleware\Interfaces\ConditionInterface;
25		use Phossa2\Middleware\Interfaces\MiddlewareInterface;
26
27		/**
28		* Queue
29		*
30		* Middleware queue
31		*
32		* @package Phossa2\Middleware
33		* @author Hong Zhang <[email protected]>
34		* @version 2.0.1
35		* @since 2.0.0 added
36		* @since 2.0.1 added $terminate
37		*/
38		class Queue extends ObjectAbstract implements QueueInterface
39		{
40		/**
41		* @var \SplQueue
42		* @access protected
43		*/
44		protected $queue;
45
46		/**
47		* @var bool
48		* @access protected
49		*/
50		protected $terminate = false;
51
52		/**
53		* Constructor
54		*
55		* @param array $middlewares
56		* @access public
57		*/
58		public function __construct(
59		array $middlewares = []
60		) {
61		// create the queue
62		$this->queue = new \SplQueue();
63
64		// fill the queue with middlewares
65		$this->fillTheQueue($middlewares);
66		}
67
68		/**
69		* Compatible with middlewares of the signature
70		*
71		* ```php
72		* fn($request, $response, callable $next)
73		* ```
74		*
75		* @param RequestInterface $request
76		* @param ResponseInterface $response
77		* @param DelegateInterface $next
78		* @return ResponseInterface
79		* @access public
80		*/
81		public function __invoke(
82		RequestInterface $request,
83		ResponseInterface $response,
84		DelegateInterface $next = null
85		)/# : ResponseInterface / {
86		return $this->process($request, $response, $next);
87		}
88
89		/**
90		* {@inheritDoc}
91		*/
92		public function push($middleware, $condition = null)
93		{
94		$this->queue->push([$middleware, $condition]);
95		$this->queue->rewind();
96		return $this;
97		}
98
99		/**
100		* {@inheritDoc}
101		*/
102		public function process(
103		RequestInterface $request,
104		ResponseInterface $response,
105		DelegateInterface $next = null
106		)/# : ResponseInterface / {
107		// process the queue
108		$response = $this->next($request, $response);
109
110		// $next is parent queue
111		return ($next && !$this->terminate) ?
112		$next->next($request, $response) :
113		$response;
114		}
115
116		/**
117		* {@inheritDoc}
118		*/
119		public function next(
120		RequestInterface $request,
121		ResponseInterface $response
122		)/# : ResponseInterface / {
123		if ($this->queue->valid()) {
124		list($middleware, $condition) = $this->queue->current();
125		$this->queue->next();
126
127		if (null === $condition \|\|
128		$this->evalCondition($condition, $request, $response)
129		) { // run this mw
130		return $this->runMiddleware($middleware, $request, $response);
131		} else { // skip this mw
132		return $this->next($request, $response);
133		}
134		}
135		$this->queue->rewind();
136		return $response;
137		}
138
139		/**
140		* Fill the queue with middlewares
141		*
142		* @param array $middlewares
143		* @access protected
144		*/
145		protected function fillTheQueue(array $middlewares)
146		{
147		foreach ($middlewares as $mw) {
148		// with conditions specified
149		if (is_array($mw)) {
150		$this->push($mw[0], $mw[1]);
151
152		// no condition
153		} else {
154		$this->push($mw);
155		}
156		}
157		}
158
159		/**
160		* Process/run this middleware
161		*
162		* @param MiddlewareInterface\|callable $middleware
163		* @param RequestInterface $request
164		* @param ResponseInterface $response
165		* @return ResponseInterface
166		* @throws LogicException if invalid middleware type
167		* @access protected
168		*/
169	View Code Duplication	protected function runMiddleware(
170		$middleware,
171		RequestInterface $request,
172		ResponseInterface $response
173		)/# : ResponseInterface / {
174		// instance of MiddlewareInterface
175		if (is_object($middleware) && $middleware instanceof MiddlewareInterface) {
176		return $middleware->process($request, $response, $this);
177
178		// old style callable
179		} elseif (is_callable($middleware)) {
180		return $middleware($request, $response, $this);
181
182		// unknown middleware type
183		} else {
184		throw new LogicException(
185		Message::get(Message::MIDDLEWARE_INVALID, $middleware),
186		Message::MIDDLEWARE_INVALID
187		);
188		}
189		}
190
191		/**
192		* Evaluate the condition
193		*
194		* support both a callable returns bool value or an object instance of
195		* ConditionInterface.
196		*
197		* @param ConditionInterface\|callable $condition
198		* @param RequestInterface $request
199		* @param ResponseInterface $response
200		* @return bool
201		* @throws LogicException if condition is invalid
202		* @access protected
203		*/
204	View Code Duplication	protected function evalCondition(
205		$condition,
206		RequestInterface $request,
207		ResponseInterface $response
208		)/# : bool / {
209		// instanceof ConditionInterface
210		if (is_object($condition) && $condition instanceof ConditionInterface) {
211		return $condition->evaluate($request, $response);
212
213		// old style callable
214		} elseif (is_callable($condition)) {
215		return $condition($request, $response);
216
217		// unknown type
218		} else {
219		throw new LogicException(
220		Message::get(Message::CONDITION_INVALID, $condition),
221		Message::CONDITION_INVALID
222		);
223		}
224		}
225		}
226

phossa2 / middleware

GitHub Access Token became invalid

Queue::push() A last analyzed 2016-10-12 00:54 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Queue::push() A
last analyzed 2016-10-12 00:54 UTC