Queue::fillTheQueue() - Code Metrics - Inspection of "fixed bugs" - phossa2/middleware - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( e3dde5...8d49f8 )

by Hong

created 2016-09-24 03:10 UTC

Queue::fillTheQueue() A

↳ Parent: Queue

Complexity

Conditions	3
Paths	3

Size

Total Lines	13
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?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.0
 * @since   2.0.0 added
 */
class Queue extends ObjectAbstract implements QueueInterface
{
    /**
     * @var    \SplQueue
     * @access protected
     */
    protected $queue;

    /**
     * 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 ? $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.0
35		* @since 2.0.0 added
36		*/
37		class Queue extends ObjectAbstract implements QueueInterface
38		{
39		/**
40		* @var \SplQueue
41		* @access protected
42		*/
43		protected $queue;
44
45		/**
46		* Constructor
47		*
48		* @param array $middlewares
49		* @access public
50		*/
51		public function __construct(array $middlewares = [])
52		{
53		// create the queue
54		$this->queue = new \SplQueue();
55
56		// fill the queue with middlewares
57		$this->fillTheQueue($middlewares);
58		}
59
60		/**
61		* Compatible with middlewares of the signature
62		*
63		* ```php
64		* fn($request, $response, callable $next)
65		* ```
66		*
67		* @param RequestInterface $request
68		* @param ResponseInterface $response
69		* @param DelegateInterface $next
70		* @return ResponseInterface
71		* @access public
72		*/
73		public function __invoke(
74		RequestInterface $request,
75		ResponseInterface $response,
76		DelegateInterface $next = null
77		)/# : ResponseInterface / {
78		return $this->process($request, $response, $next);
79		}
80
81		/**
82		* {@inheritDoc}
83		*/
84		public function push($middleware, $condition = null)
85		{
86		$this->queue->push([$middleware, $condition]);
87		$this->queue->rewind();
88		return $this;
89		}
90
91		/**
92		* {@inheritDoc}
93		*/
94		public function process(
95		RequestInterface $request,
96		ResponseInterface $response,
97		DelegateInterface $next = null
98		)/# : ResponseInterface / {
99		// process the queue
100		$response = $this->next($request, $response);
101
102		// $next is parent queue
103		return $next ? $next->next($request, $response) : $response;
104		}
105
106		/**
107		* {@inheritDoc}
108		*/
109		public function next(
110		RequestInterface $request,
111		ResponseInterface $response
112		)/# : ResponseInterface / {
113		if ($this->queue->valid()) {
114		list($middleware, $condition) = $this->queue->current();
115		$this->queue->next();
116
117		if (null === $condition \|\|
118		$this->evalCondition($condition, $request, $response)
119		) { // run this mw
120		return $this->runMiddleware($middleware, $request, $response);
121		} else { // skip this mw
122		return $this->next($request, $response);
123		}
124		}
125		$this->queue->rewind();
126		return $response;
127		}
128
129		/**
130		* Fill the queue with middlewares
131		*
132		* @param array $middlewares
133		* @access protected
134		*/
135		protected function fillTheQueue(array $middlewares)
136		{
137		foreach ($middlewares as $mw) {
138		// with conditions specified
139		if (is_array($mw)) {
140		$this->push($mw[0], $mw[1]);
141
142		// no condition
143		} else {
144		$this->push($mw);
145		}
146		}
147		}
148
149		/**
150		* Process/run this middleware
151		*
152		* @param MiddlewareInterface\|callable $middleware
153		* @param RequestInterface $request
154		* @param ResponseInterface $response
155		* @return ResponseInterface
156		* @throws LogicException if invalid middleware type
157		* @access protected
158		*/
159	View Code Duplication	protected function runMiddleware(
160		$middleware,
161		RequestInterface $request,
162		ResponseInterface $response
163		)/# : ResponseInterface / {
164		// instance of MiddlewareInterface
165		if (is_object($middleware) && $middleware instanceof MiddlewareInterface) {
166		return $middleware->process($request, $response, $this);
167
168		// old style callable
169		} elseif (is_callable($middleware)) {
170		return $middleware($request, $response, $this);
171
172		// unknown middleware type
173		} else {
174		throw new LogicException(
175		Message::get(Message::MIDDLEWARE_INVALID, $middleware),
176		Message::MIDDLEWARE_INVALID
177		);
178		}
179		}
180
181		/**
182		* Evaluate the condition
183		*
184		* support both a callable returns bool value or an object instance of
185		* ConditionInterface.
186		*
187		* @param ConditionInterface\|callable $condition
188		* @param RequestInterface $request
189		* @param ResponseInterface $response
190		* @return bool
191		* @throws LogicException if condition is invalid
192		* @access protected
193		*/
194	View Code Duplication	protected function evalCondition(
		1 ignored issue – show Duplication introduced 2016-09-22 13:42 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
195		$condition,
196		RequestInterface $request,
197		ResponseInterface $response
198		)/# : bool / {
199		// instanceof ConditionInterface
200		if (is_object($condition) && $condition instanceof ConditionInterface) {
201		return $condition->evaluate($request, $response);
202
203		// old style callable
204		} elseif (is_callable($condition)) {
205		return $condition($request, $response);
206
207		// unknown type
208		} else {
209		throw new LogicException(
210		Message::get(Message::CONDITION_INVALID, $condition),
211		Message::CONDITION_INVALID
212		);
213		}
214		}
215		}
216

phossa2 / middleware

GitHub Access Token became invalid

Push — master ( e3dde5...8d49f8 )

Queue::fillTheQueue() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like