RouteAction::cancel() - Code Metrics - Inspection of "Cancel action" - jasny/controller - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#8)

by Arnold

created 2016-12-02 20:31 UTC

RouteAction::cancel() A

↳ Parent: RouteAction

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	4
ccs	3
cts	3
cp	1
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	0
crap	1

<?php

namespace Jasny\Controller;

use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Message\ResponseInterface;

/**
 * Execute controller on given route
 */
trait RouteAction
{
    /**
     * @var boolean
     */
    protected $actionCancelled = false;
    
    
    /**
     * Get request, set for controller
     *
     * @return ServerRequestInterface
     */
    abstract public function getRequest();

    /**
     * Get response. set for controller
     *
     * @return ResponseInterface
     */
    abstract public function getResponse();

    /**
     * Respond with a server error
     *
     * @param string $message
     * @param int    $code     HTTP status code
     */
    abstract public function notFound($message = '', $code = 404);

    

    /**
     * Get the route
     * 
     * @return \stdClass
     */
    protected function getRoute()
    {
        $route = $this->getRequest()->getAttribute('route');
        
        if (!isset($route)) {
            throw new \LogicException("Route has not been set");
        }
        
        if (is_array($route)) {
            $route = (object)$route;
        }
        
        if (!$route instanceof \stdClass) {
            $type = (is_object($route) ? get_class($route) . ' ' : '') . gettype($route);
            throw new \UnexpectedValueException("Expected route to be a stdClass object, not a $type");
        }
        
        return $route;
    }

    /**
     * Get the method name of the action
     * 
     * @param string $action
     * @return string
     */
    protected function getActionMethod($action)
    {
        return \Jasny\camelcase($action) . 'Action';
    }
    
    /**
     * Called before executing the action.
     * @codeCoverageIgnore
     * 
     * <code>
     * protected function beforeAction()
     * {
     *    $this->respondWith('json'); // Respond with JSON by default
     * 
     *    if ($this->auth->getUser()->getCredits() <= 0) {
     *        $this->paymentRequired();
     *    }
     * }
     * </code>
     */
    protected function before()
    {
    }
    
    /**
     * Called before executing the action.
     * @codeCoverageIgnore
     */
    protected function after()
    {
    }
    
    /**
     * Cancel the action
     */
    public function cancel()
    {
        $this->actionCancelled = true;
    }

    /**
     * Check if the action is cancelled
     * 
     * @return boolean
     */
    public function isCancelled()
    {
        return $this->actionCancelled;
    }
    
    /**
     * Run the controller
     *
     * @return ResponseInterface
     */
    public function run()
    {
        $route = $this->getRoute();
        $method = $this->getActionMethod(isset($route->action) ? $route->action : 'default');

        if (!method_exists($this, $method)) {
            return $this->notFound();
        }

        $this->before();
        
        if (!$this->isCancelled()) {
            $args = isset($route->args) ? $route->args
                : $this->getFunctionArgs($route, new \ReflectionMethod($this, $method)); 

            call_user_func_array([$this, $method], $args);
        }
        
        $this->after();
    }

    /**
     * Get the arguments for a function from a route using reflection
     * 
     * @param \stdClass                   $route
     * @param \ReflectionFunctionAbstract $refl
     * @return array
     */
    protected function getFunctionArgs($route, \ReflectionFunctionAbstract $refl)
    {
        $args = [];
        $params = $refl->getParameters();

        foreach ($params as $param) {
            $key = $param->name;

            if (property_exists($route, $key)) {
                $value = $route->$key;
            } else {
                if (!$param->isOptional()) {
                    $fn = $refl instanceof \ReflectionMethod ? $refl->class . '::' . $refl->name : $refl->name;
                    throw new \RuntimeException("Missing argument '$key' for {$fn}()");
                }
                
                $value = $param->isDefaultValueAvailable() ? $param->getDefaultValue() : null;
            }

            $args[$key] = $value;
        }
        
        return $args;
    }
}



1		<?php
2
3		namespace Jasny\Controller;
4
5		use Psr\Http\Message\ServerRequestInterface;
6		use Psr\Http\Message\ResponseInterface;
7
8		/**
9		* Execute controller on given route
10		*/
11		trait RouteAction
12		{
13		/**
14		* @var boolean
15		*/
16		protected $actionCancelled = false;
17
18
19		/**
20		* Get request, set for controller
21		*
22		* @return ServerRequestInterface
23		*/
24		abstract public function getRequest();
25
26		/**
27		* Get response. set for controller
28		*
29		* @return ResponseInterface
30		*/
31		abstract public function getResponse();
32
33		/**
34		* Respond with a server error
35		*
36		* @param string $message
37		* @param int $code HTTP status code
38		*/
39		abstract public function notFound($message = '', $code = 404);
		0 ignored issues – show Documentation introduced 2016-11-21 11:59 UTC by Report Bug Copy Issue Report For interfaces and abstract methods it is generally a good practice to add a `@return` annotation even if it is just `@return void` or `@return null`, so that implementors know what to do in the overridden method. For interface and abstract methods, it is impossible to infer the return type from the immediate code. In these cases, it is generally advisible to explicitly annotate these methods with a `@return` doc comment to communicate to implementors of these methods what they are expected to return. Loading history...
40
41
42		/**
43		* Get the route
44		*
45		* @return \stdClass
46		*/
47	13	protected function getRoute()
48		{
49	13	$route = $this->getRequest()->getAttribute('route');
50
51	13	if (!isset($route)) {
52	1	throw new \LogicException("Route has not been set");
53		}
54
55	12	if (is_array($route)) {
56	1	$route = (object)$route;
57		}
58
59	12	if (!$route instanceof \stdClass) {
60	1	$type = (is_object($route) ? get_class($route) . ' ' : '') . gettype($route);
61	1	throw new \UnexpectedValueException("Expected route to be a stdClass object, not a $type");
62		}
63
64	11	return $route;
65		}
66
67		/**
68		* Get the method name of the action
69		*
70		* @param string $action
71		* @return string
72		*/
73	11	protected function getActionMethod($action)
74		{
75	11	return \Jasny\camelcase($action) . 'Action';
76		}
77
78		/**
79		* Called before executing the action.
80		* @codeCoverageIgnore
81		*
82		* <code>
83		* protected function beforeAction()
84		* {
85		* $this->respondWith('json'); // Respond with JSON by default
86		*
87		* if ($this->auth->getUser()->getCredits() <= 0) {
88		* $this->paymentRequired();
89		* }
90		* }
91		* </code>
92		*/
93		protected function before()
94		{
95		}
96
97		/**
98		* Called before executing the action.
99		* @codeCoverageIgnore
100		*/
101		protected function after()
102		{
103		}
104
105		/**
106		* Cancel the action
107		*/
108	1	public function cancel()
109		{
110	1	$this->actionCancelled = true;
111	1	}
112
113		/**
114		* Check if the action is cancelled
115		*
116		* @return boolean
117		*/
118	10	public function isCancelled()
119		{
120	10	return $this->actionCancelled;
121		}
122
123		/**
124		* Run the controller
125		*
126		* @return ResponseInterface
127		*/
128	13	public function run()
129		{
130	13	$route = $this->getRoute();
131	11	$method = $this->getActionMethod(isset($route->action) ? $route->action : 'default');
132
133	11	if (!method_exists($this, $method)) {
134	1	return $this->notFound();
135		}
136
137	10	$this->before();
138
139	10	if (!$this->isCancelled()) {
140	9	$args = isset($route->args) ? $route->args
141	9	: $this->getFunctionArgs($route, new \ReflectionMethod($this, $method));
142
143	8	call_user_func_array([$this, $method], $args);
144		}
145
146	9	$this->after();
147	9	}
148
149		/**
150		* Get the arguments for a function from a route using reflection
151		*
152		* @param \stdClass $route
153		* @param \ReflectionFunctionAbstract $refl
154		* @return array
155		*/
156	6	protected function getFunctionArgs($route, \ReflectionFunctionAbstract $refl)
157		{
158	6	$args = [];
159	6	$params = $refl->getParameters();
160
161	6	foreach ($params as $param) {
162	6	$key = $param->name;
163
164	6	if (property_exists($route, $key)) {
165	5	$value = $route->$key;
166		} else {
167	4	if (!$param->isOptional()) {
168	1	$fn = $refl instanceof \ReflectionMethod ? $refl->class . '::' . $refl->name : $refl->name;
169	1	throw new \RuntimeException("Missing argument '$key' for {$fn}()");
170		}
171
172	3	$value = $param->isDefaultValueAvailable() ? $param->getDefaultValue() : null;
173		}
174
175	5	$args[$key] = $value;
176		}
177
178	5	return $args;
179		}
180		}
181
182

jasny / controller

Pull Request — master (#8)

RouteAction::cancel() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like