Active::state() - Code Metrics - Inspection of "Fix #6 - Added Active::state() method" - Arcesilas/active-state - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — develop (#7)

by Olivier

created 2018-05-10 20:47 UTC

Active::state() A

↳ Parent: Active

Complexity

Conditions	2
Paths	2

Size

Total Lines	8
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	2
eloc	5
nc	2
nop	2
dl	0
loc	8
rs	9.4285
c	0
b	0
f	0

<?php

namespace Arcesilas\ActiveState;

use Request;
use Illuminate\Support\Str;
use Illuminate\Http\Request as HttpRequest;
use Illuminate\Routing\Exceptions\UrlGenerationException;

class Active
{
    /**
     * Value returned when state is "active"
     * @var string
     */
    protected $activeValue;

    /**
     * Whether $activeValue should be reset after a check or not
     * @var boolean
     */
    protected $activeValuePersistent = false;

    /**
     * Value returned when state is "inactive"
     * @var string
     */
    protected $inactiveValue;

    /**
     * Whether $inactiveValue should be reset after a check or not
     * @var [type]
     */
    protected $inactiveValuePersistent = false;

    /**
     * The Request instance
     * @var \Illuminate\Http\Request
     */
    protected $request;

    /**
     * Obviously: the constructor
     * @method __construct
     * @param  \Illuminate\Http\Request  $request The HTTP Request handled by Laravel
     */
    public function __construct(HttpRequest $request)

    {
        $this->request = $request;
    }

    /**
     * Check whether url matches the given patterns
     * @param  string $patterns Patterns to match
     * @return boolean
     */
    public function checkUrlIs(...$patterns)
    {
        return $this->request->is(...$patterns);
    }

    /**
     * Check whether url contains given strings
     * @param  string  $patterns
     * @return boolean
     */
    public function checkUrlHas(...$patterns)
    {
        return $this->request->is(array_map(
            function ($item) {
                return "*{$item}*";
            },
            $patterns
        ));
    }

    /**
     * Check if the current route name is the one given and the parameters match the current url
     * @param  string  $route       The route name to check
     * @param  array  $routeparameters The route parameters, used to build the url
/**
 * @param array $germany
 * @param array $ireland
 */
function finale($germany, $island) {
    return "2:1";
}
     * @return boolean
     */
    public function checkRouteIs($route, array $routeParameters = [])
    {
        if (!is_array($route)) {
            $route = [$route => $routeParameters];
        }
        foreach ($route as $r => $parameters) {
            try {
                $routeUri = route($r, $parameters, true);
                if ($this->request->fullUrlIs($routeUri)) {
                    return true;
                }
            } catch (\Exception $e) {
                // Just ignore the exception: route does not exist
            }
        }
        return false;
    }

    /**
     * Check whether the current route is one of the given routes
     * @method checkRouteIn
     * @param  string  $routes
     * @return boolean
     */
    public function checkRouteIn(...$routes)
    {
        return $this->request->routeIs(...$routes);
    }

    /**
     * Check that the parameters of the query string are exactly the ones given
     * The test returns true if at least one given array matches the query string parameters (keys and values)
     * @param  array  $parameters
     * @return boolean
     */
    public function checkQueryIs(array ...$parameters)
    {
        foreach ($parameters as $params) {
            if ($this->request->query->all() == $params) {
                return true;
            }
        }
        return false;
    }

    /**
     * Check if query has all of the given parameters, not taking their values into account
     * @param  array  $parameters
     * @return boolean
     */
    public function checkQueryHas(...$parameters)
    {
        $queryKeys = array_keys($this->request->query->all());
        return empty(
            array_diff($parameters, $queryKeys)
        );
    }

    /**
     * Check if query parameters names are exactly the ones given in argument
     * The order of the parameters does not matter
     * @param  string  $parameters string
     * @return boolean
     */
    public function checkQueryHasOnly(...$parameters)
    {
        $queryKeys = array_keys($this->request->query->all());
        sort($queryKeys);
        sort($parameters);

        return $parameters === $queryKeys;
    }

    /**
     * Check if query has the given parameters, with their given values
     * @param  array  $parameters  The parameters to check for
     * @return boolean
     */
    public function checkQueryContains($parameters)
    {
        return empty(
            array_diff($parameters, $this->request->query->all())
        );
    }

    /**
     * Common check function
     * @param  string  $check  The check method to use
     * @param  array  $arguments  Arguments to check with
     * @return string
     */
    protected function check($check, array $arguments)
    {
        return $this->getState(call_user_func_array([$this, $check], $arguments));
    }

    /**
     * Returns activeValue or inactiveValue for checkUrlIs test
     * @param  string  $patterns
     * @return string  Active state string
     * @see Active::checkUrl
     */
    public function ifUrlIs(...$patterns)
    {
        return $this->check('checkUrlIs', $patterns);
    }

    /**
     * Returns activeValue or inactiveValue for checkUrlHas test
     * @param  string  $patterns
     * @return string  Active state string
     * @see Active::checkUrlHas()
     */
    public function ifUrlHas(...$patterns)
    {
        return $this->check('checkUrlHas', $patterns);
    }

    /**
     * Returns activeValue or inactiveValue for checkRouteIs test
     * @param  string  $route
     * @param  array  $parameters
     * @return string  Active state string
     * @see Active::checkRouteIs()
     */
    public function ifRouteIs($route, array $parameters = [])
    {
        return $this->check('checkRouteIs', [$route, $parameters]);
    }

    /**
     * Return activeValue or inactiveValue for checkRouteIn test
     * @param  string  $routes
     * @return boolean
     * @see Active::checkRouteIn()
     */
    public function ifRouteIn(...$routes)
    {
        return $this->check('checkRouteIn', $routes);
    }

    /**
     * Returns activeValue or inactiveValue for checkQuery test
     * @param  string  $patterns
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     * @return string               Active state string
     * @see Active::checkQueryIs()
     */
    public function ifQueryIs(array ...$parameters)
    {
        return $this->check('checkQueryIs', $parameters);
    }

    /**
     * Returns activeValue or inactiveValue for checkQueryHas test
     * @param  string  $patterns
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     * @return string  Active state string
     * @see Active::checkQueryHas()
     */
    public function ifQueryHas(...$parameters)
    {
        return $this->check('checkQueryHas', $parameters);
    }

    /**
     * Returns activeValue or inactiveValue for checkQueryHasOnly test
     * @param  string  $patterns
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     * @return string  Active state string
     * @see Active::checkQueryHasOnly()
     */
    public function ifQueryHasOnly(...$parameters)
    {
        return $this->check('checkQueryHasOnly', $parameters);
    }

    /**
     * Returns activeValue or inactiveValue for checkQueryContains test
     * @param  string  $parameters
     * @return string  Active state string
     * @see Active::checkQueryContains()
     */
    public function ifQueryContains($parameters)
    {
        return $this->check('checkQueryContains', $parameters);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * Returns the active state string depending on the actual state
     * @param  boolean  $active
     * @return string
     */
    public function getState($active)
    {
        return $active ? $this->getActiveValue() : $this->getInactiveValue();
    }

    /**
     * Returns the active state string
     * @return string
     */
    public function getActiveValue()
    {
        $return = $this->activeValue ?? config('active.active_state', 'active');
        if (! $this->activeValuePersistent) {
            $this->setActiveValue();
        }
        return $return;
    }

    /**
     * Return the inactive state string
     * @return string
     */
    public function getInactiveValue()
    {
        $return = $this->inactiveValue ?? config('active.inactive_state', '');
        if (! $this->inactiveValuePersistent) {
            $this->setInactiveValue();
        }
        return $return;
    }

    /**
     * Set the active state string
     * @param  string  $value  The string value
     * @param  boolean|null  $persistent Whether to reset the value after the next check
     */
    public function setActiveValue($value = null, $persistent = null)
    {
        $this->activeValue = $value;
        if (null !== $persistent) {
            $this->activeValuePersistent = (bool) $persistent;
        }
    }

    /**
     * Set the inactive state string
     * @param  string  $value      The string value
     * @param  boolean|null  $persistent Whether to reset the value after the next check
     */
    public function setInactiveValue($value = null, $persistent = null)
    {
        $this->inactiveValue = $value;
        if (null !== $persistent) {
            $this->inactiveValuePersistent = (bool) $persistent;
        }
    }

    /**
     * Change active and inactive state at runtime and allow method chaining
     * @param  string $active_state
     * @param  string $inactive_state
     * @return Active
     */
    public function state(string $active_state, string $inactive_state = null)
    {
        $this->setActiveValue($active_state, false);
        if ($inactive_state) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            $this->setInactiveValue($inactive_state, false);
        }
        return $this;
    }

    /**
     * Reset both active and inactive state strings
     */
    public function resetValues()
    {
        $this->activeValue = null;
        $this->inactiveValue = null;
    }
}


1			<?php
2
3			namespace Arcesilas\ActiveState;
4
5			use Request;
6			use Illuminate\Support\Str;
7			use Illuminate\Http\Request as HttpRequest;
8			use Illuminate\Routing\Exceptions\UrlGenerationException;
9
10			class Active
11			{
12			/**
13			* Value returned when state is "active"
14			* @var string
15			*/
16			protected $activeValue;
17
18			/**
19			* Whether $activeValue should be reset after a check or not
20			* @var boolean
21			*/
22			protected $activeValuePersistent = false;
23
24			/**
25			* Value returned when state is "inactive"
26			* @var string
27			*/
28			protected $inactiveValue;
29
30			/**
31			* Whether $inactiveValue should be reset after a check or not
32			* @var [type]
33			*/
34			protected $inactiveValuePersistent = false;
35
36			/**
37			* The Request instance
38			* @var \Illuminate\Http\Request
39			*/
40			protected $request;
41
42			/**
43			* Obviously: the constructor
44			* @method __construct
45			* @param \Illuminate\Http\Request $request The HTTP Request handled by Laravel
46			*/
47			public function __construct(HttpRequest $request)
			0 ignored issues – show Bug introduced 2018-01-27 10:05 UTC by Report Bug Copy Issue Report You have injected the Request via parameter `$request`. This is generally not recommended as there might be multiple instances during a request cycle (f.e. when using sub-requests). Instead, it is recommended to inject the RequestStack and retrieve the current request each time you need it via `getCurrentRequest()`. Loading history...
48			{
49			$this->request = $request;
50			}
51
52			/**
53			* Check whether url matches the given patterns
54			* @param string $patterns Patterns to match
55			* @return boolean
56			*/
57			public function checkUrlIs(...$patterns)
58			{
59			return $this->request->is(...$patterns);
60			}
61
62			/**
63			* Check whether url contains given strings
64			* @param string $patterns
65			* @return boolean
66			*/
67			public function checkUrlHas(...$patterns)
68			{
69			return $this->request->is(array_map(
70			function ($item) {
71			return "{$item}";
72			},
73			$patterns
74			));
75			}
76
77			/**
78			* Check if the current route name is the one given and the parameters match the current url
79			* @param string $route The route name to check
80			* @param array $routeparameters The route parameters, used to build the url
			0 ignored issues – show Documentation introduced 2018-01-27 10:05 UTC by Report Bug Copy Issue Report There is no parameter named `$routeparameters`. Did you maybe mean `$routeParameters`? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. It has, however, found a similar but not annotated parameter which might be a good fit. Consider the following example. The parameter `$ireland` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $ireland */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was changed, but the annotation was not. Loading history...
81			* @return boolean
82			*/
83			public function checkRouteIs($route, array $routeParameters = [])
84			{
85			if (!is_array($route)) {
86			$route = [$route => $routeParameters];
87			}
88			foreach ($route as $r => $parameters) {
89			try {
90			$routeUri = route($r, $parameters, true);
91			if ($this->request->fullUrlIs($routeUri)) {
92			return true;
93			}
94			} catch (\Exception $e) {
95			// Just ignore the exception: route does not exist
96			}
97			}
98			return false;
99			}
100
101			/**
102			* Check whether the current route is one of the given routes
103			* @method checkRouteIn
104			* @param string $routes
105			* @return boolean
106			*/
107			public function checkRouteIn(...$routes)
108			{
109			return $this->request->routeIs(...$routes);
110			}
111
112			/**
113			* Check that the parameters of the query string are exactly the ones given
114			* The test returns true if at least one given array matches the query string parameters (keys and values)
115			* @param array $parameters
116			* @return boolean
117			*/
118			public function checkQueryIs(array ...$parameters)
119			{
120			foreach ($parameters as $params) {
121			if ($this->request->query->all() == $params) {
122			return true;
123			}
124			}
125			return false;
126			}
127
128			/**
129			* Check if query has all of the given parameters, not taking their values into account
130			* @param array $parameters
131			* @return boolean
132			*/
133			public function checkQueryHas(...$parameters)
134			{
135			$queryKeys = array_keys($this->request->query->all());
136			return empty(
137			array_diff($parameters, $queryKeys)
138			);
139			}
140
141			/**
142			* Check if query parameters names are exactly the ones given in argument
143			* The order of the parameters does not matter
144			* @param string $parameters string
145			* @return boolean
146			*/
147			public function checkQueryHasOnly(...$parameters)
148			{
149			$queryKeys = array_keys($this->request->query->all());
150			sort($queryKeys);
151			sort($parameters);
152
153			return $parameters === $queryKeys;
154			}
155
156			/**
157			* Check if query has the given parameters, with their given values
158			* @param array $parameters The parameters to check for
159			* @return boolean
160			*/
161			public function checkQueryContains($parameters)
162			{
163			return empty(
164			array_diff($parameters, $this->request->query->all())
165			);
166			}
167
168			/**
169			* Common check function
170			* @param string $check The check method to use
171			* @param array $arguments Arguments to check with
172			* @return string
173			*/
174			protected function check($check, array $arguments)
175			{
176			return $this->getState(call_user_func_array([$this, $check], $arguments));
177			}
178
179			/**
180			* Returns activeValue or inactiveValue for checkUrlIs test
181			* @param string $patterns
182			* @return string Active state string
183			* @see Active::checkUrl
184			*/
185			public function ifUrlIs(...$patterns)
186			{
187			return $this->check('checkUrlIs', $patterns);
188			}
189
190			/**
191			* Returns activeValue or inactiveValue for checkUrlHas test
192			* @param string $patterns
193			* @return string Active state string
194			* @see Active::checkUrlHas()
195			*/
196			public function ifUrlHas(...$patterns)
197			{
198			return $this->check('checkUrlHas', $patterns);
199			}
200
201			/**
202			* Returns activeValue or inactiveValue for checkRouteIs test
203			* @param string $route
204			* @param array $parameters
205			* @return string Active state string
206			* @see Active::checkRouteIs()
207			*/
208			public function ifRouteIs($route, array $parameters = [])
209			{
210			return $this->check('checkRouteIs', [$route, $parameters]);
211			}
212
213			/**
214			* Return activeValue or inactiveValue for checkRouteIn test
215			* @param string $routes
216			* @return boolean
217			* @see Active::checkRouteIn()
218			*/
219			public function ifRouteIn(...$routes)
220			{
221			return $this->check('checkRouteIn', $routes);
222			}
223
224			/**
225			* Returns activeValue or inactiveValue for checkQuery test
226			* @param string $patterns
			0 ignored issues – show Bug introduced 2018-01-27 10:05 UTC by Report Bug Copy Issue Report There is no parameter named `$patterns`. Was it maybe removed? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. Consider the following example. The parameter `$italy` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $island * @param array $italy */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was removed, but the annotation was not. Loading history...
227			* @return string Active state string
228			* @see Active::checkQueryIs()
229			*/
230			public function ifQueryIs(array ...$parameters)
231			{
232			return $this->check('checkQueryIs', $parameters);
233			}
234
235			/**
236			* Returns activeValue or inactiveValue for checkQueryHas test
237			* @param string $patterns
			0 ignored issues – show Bug introduced 2018-01-27 10:05 UTC by Report Bug Copy Issue Report There is no parameter named `$patterns`. Was it maybe removed? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. Consider the following example. The parameter `$italy` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $island * @param array $italy */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was removed, but the annotation was not. Loading history...
238			* @return string Active state string
239			* @see Active::checkQueryHas()
240			*/
241			public function ifQueryHas(...$parameters)
242			{
243			return $this->check('checkQueryHas', $parameters);
244			}
245
246			/**
247			* Returns activeValue or inactiveValue for checkQueryHasOnly test
248			* @param string $patterns
			0 ignored issues – show Bug introduced 2018-01-27 10:05 UTC by Report Bug Copy Issue Report There is no parameter named `$patterns`. Was it maybe removed? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. Consider the following example. The parameter `$italy` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $island * @param array $italy */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was removed, but the annotation was not. Loading history...
249			* @return string Active state string
250			* @see Active::checkQueryHasOnly()
251			*/
252			public function ifQueryHasOnly(...$parameters)
253			{
254			return $this->check('checkQueryHasOnly', $parameters);
255			}
256
257			/**
258			* Returns activeValue or inactiveValue for checkQueryContains test
259			* @param string $parameters
260			* @return string Active state string
261			* @see Active::checkQueryContains()
262			*/
263			public function ifQueryContains($parameters)
264			{
265			return $this->check('checkQueryContains', $parameters);
			0 ignored issues – show Documentation introduced 2018-01-27 10:05 UTC by Report Bug Copy Issue Report `$parameters` is of type `string`, but the function expects a `array`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
266			}
267
268			/**
269			* Returns the active state string depending on the actual state
270			* @param boolean $active
271			* @return string
272			*/
273			public function getState($active)
274			{
275			return $active ? $this->getActiveValue() : $this->getInactiveValue();
276			}
277
278			/**
279			* Returns the active state string
280			* @return string
281			*/
282			public function getActiveValue()
283			{
284			$return = $this->activeValue ?? config('active.active_state', 'active');
285			if (! $this->activeValuePersistent) {
286			$this->setActiveValue();
287			}
288			return $return;
289			}
290
291			/**
292			* Return the inactive state string
293			* @return string
294			*/
295			public function getInactiveValue()
296			{
297			$return = $this->inactiveValue ?? config('active.inactive_state', '');
298			if (! $this->inactiveValuePersistent) {
299			$this->setInactiveValue();
300			}
301			return $return;
302			}
303
304			/**
305			* Set the active state string
306			* @param string $value The string value
307			* @param boolean\|null $persistent Whether to reset the value after the next check
308			*/
309			public function setActiveValue($value = null, $persistent = null)
310			{
311			$this->activeValue = $value;
312			if (null !== $persistent) {
313			$this->activeValuePersistent = (bool) $persistent;
314			}
315			}
316
317			/**
318			* Set the inactive state string
319			* @param string $value The string value
320			* @param boolean\|null $persistent Whether to reset the value after the next check
321			*/
322			public function setInactiveValue($value = null, $persistent = null)
323			{
324			$this->inactiveValue = $value;
325			if (null !== $persistent) {
326			$this->inactiveValuePersistent = (bool) $persistent;
327			}
328			}
329
330			/**
331			* Change active and inactive state at runtime and allow method chaining
332			* @param string $active_state
333			* @param string $inactive_state
334			* @return Active
335			*/
336			public function state(string $active_state, string $inactive_state = null)
337			{
338			$this->setActiveValue($active_state, false);
339			if ($inactive_state) {
			0 ignored issues – show Bug Best Practice introduced 2018-05-10 20:59 UTC by Report Bug Copy Issue Report The expression `$inactive_state` of type `null\|string` is loosely compared to `true`; this is ambiguous if the string can be empty. You might want to explicitly use `!== null` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `string` values, the empty string `''` is a special case, in particular the following results might be unexpected: '' == false // true '' == null // true 'ab' == false // false 'ab' == null // false // It is often better to use strict comparison '' === false // false '' === null // false Loading history...
340			$this->setInactiveValue($inactive_state, false);
341			}
342			return $this;
343			}
344
345			/**
346			* Reset both active and inactive state strings
347			*/
348			public function resetValues()
349			{
350			$this->activeValue = null;
351			$this->inactiveValue = null;
352			}
353			}
354

Arcesilas / active-state

Pull Request — develop (#7)

Active::state() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like