AbstractParser::getMap() - Code Metrics - bytic/router - Measure and Improve Code Quality continuously with Scrutinizer

AbstractParser::getMap() A
last analyzed 2022-10-01 19:54 UTC

↳ Parent: AbstractParser

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes	1
Bugs	0	Features	0

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

<?php

namespace Nip\Router\Parsers;

/**
 * Class AbstractParser
 * @package Nip\Router\Parsers
 */
abstract class AbstractParser
{
    /**
     * @var \Nip\Request
     */
    protected $request;

    /**
     * @var string
     */
    protected $uri;

    /**
     * @var string
     */
    protected $map;

    /**
     * @var array
     */
    protected $parts;

    /**
     * @var array
     */
    protected $params = [];

    /**
     * @var array
     */
    protected $variables = [];

    /**
     * @var array
     */
    protected $matches = [];

    /**
     * AbstractParser constructor.
     * @param bool $map
     * @param array $params
     */
    public function __construct($map = false, $params = [])
    {
        if ($map) {
            $this->setMap($map);
        } elseif ($this->map) {
            $this->parseMap();
        }


        if ($params) {

            $this->setParams($params);
        }
        $this->init();
    }

    protected function parseMap()
    {
        $this->setParts(explode("/", trim($this->map, '/')));
    }

    public function init()
    {
    }

    /**
     * @param $uri
     * @return bool
     */
    public function match($uri)
    {
        $this->setUri($uri);

        return true;
    }

    /**
     * @param mixed $uri
     */
    public function setUri($uri)
    {
        $this->uri = $uri;
    }

    /**
     * @param array $params
     * @return string
     */
    public function assemble($params = [])
    {
        $return = $this->getMap();

        if ($params) {

            foreach ($params as $key => $value) {
                if (stristr($return, ":" . $key) !== false) {
                    $return = str_replace(":" . $key, $value, $return);
                    unset($params[$key]);
                }
                if (array_key_exists($key, $this->params)) {
                    unset($params[$key]);
                }
            }
            if ($params) {

                $return .= "?" . http_build_query($params);
            }
        }

        // set defaults
        if ($this->params) {

            foreach ($this->params as $key => $value) {
                if (is_string($value)) {
                    $return = str_replace(":" . $key, $value, $return);
                }
            }
        }

        return $return;
    }

    /**
     * @return string
     */
    public function getMap()
    {
        return $this->map;
    }

    /**
     * @param boolean $map
     */
    public function setMap($map)
    {
        $this->map = $map;
$answer = 42;

$correct = false;

$correct = (bool) $answer;
        $this->parseMap();
    }

    /**
     * @param $params
     * @return array
     */
    public function stripEmptyParams($params)
    {
        if (is_array($params)) {
            foreach ($params as $key => $param) {
                if (empty($param)) {
                    unset($params[$key]);
                } elseif (is_array($param)) {
                    $newParams = $this->stripEmptyParams($param);
                    if (!is_array($newParams) or count($newParams) < 1) {
                        unset($params[$key]);
                    } else {
                        $params[$key] = $newParams;
                    }
                }
            }
        }

        return $params;
    }

    /**
     * @return array
     */
    public function getParts()
    {
        return $this->parts;
    }

    /**
     * @param array $parts
     */
    public function setParts($parts)
    {
        $this->parts = $parts;
    }

    /**
     * @return array
     */
    public function getParams()
    {
        return $this->params;
    }

    /**
     * @param array $params
     */
    public function setParams($params = [])
    {
        if (count($params)) {
            foreach ($params as $key => $value) {
                $this->setParam($key, $value);
            }
        }
    }

    /**
     * @param $name
     * @param $value
     * @return $this
     */
    public function setParam($name, $value)
    {
        $this->params[$name] = $value;

        return $this;
    }

    /**
     * @param string $key
     * @return mixed|null
     */
    public function getParam($key)
    {
        return $this->hasParam($key) ? $this->params[$key] : null;
    }

    /**
     * @param $key
     * @return bool
     */
    public function hasParam($key)
    {
        return isset($this->params[$key]);
    }

    /**
     * @return array
     */
    public function getMatches()
    {
        return $this->matches;
    }

    /**
     * @return array
     */
    public function getVariables()
    {
        return $this->variables;
    }

    /**
     * @param array $variables
     */
    public function setVariables($variables)
    {
        $this->variables = $variables;
    }

//    public function setModule($module)
//    {
//        $this->_module = $module;
//    }
//
//    public function setController($controller)
//    {
//        $this->_controller = $controller;
//    }
//
//    public function setAction($action)
//    {
//        $this->_action = $action;
//    }
}


1		<?php
2
3		namespace Nip\Router\Parsers;
4
5		/**
6		* Class AbstractParser
7		* @package Nip\Router\Parsers
8		*/
9		abstract class AbstractParser
10		{
11		/**
12		* @var \Nip\Request
13		*/
14		protected $request;
15
16		/**
17		* @var string
18		*/
19		protected $uri;
20
21		/**
22		* @var string
23		*/
24		protected $map;
25
26		/**
27		* @var array
28		*/
29		protected $parts;
30
31		/**
32		* @var array
33		*/
34		protected $params = [];
35
36		/**
37		* @var array
38		*/
39		protected $variables = [];
40
41		/**
42		* @var array
43		*/
44		protected $matches = [];
45
46		/**
47		* AbstractParser constructor.
48		* @param bool $map
49		* @param array $params
50		*/
51	12	public function __construct($map = false, $params = [])
52		{
53	12	if ($map) {
54		$this->setMap($map);
55	12	} elseif ($this->map) {
56	3	$this->parseMap();
57		}
58
59
60	12	if ($params) {
		0 ignored issues – show Bug Best Practice introduced 2020-05-15 10:55 UTC by Report Bug Copy Issue Report The expression `$params` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `! empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
61		$this->setParams($params);
62		}
63	12	$this->init();
64	12	}
65
66	11	protected function parseMap()
67		{
68	11	$this->setParts(explode("/", trim($this->map, '/')));
69	11	}
70
71	12	public function init()
72		{
73	12	}
74
75		/**
76		* @param $uri
77		* @return bool
78		*/
79	5	public function match($uri)
80		{
81	5	$this->setUri($uri);
82
83	5	return true;
84		}
85
86		/**
87		* @param mixed $uri
88		*/
89	5	public function setUri($uri)
90		{
91	5	$this->uri = $uri;
92	5	}
93
94		/**
95		* @param array $params
96		* @return string
97		*/
98	3	public function assemble($params = [])
99		{
100	3	$return = $this->getMap();
101
102	3	if ($params) {
		0 ignored issues – show Bug Best Practice introduced 2020-05-15 10:55 UTC by Report Bug Copy Issue Report The expression `$params` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `! empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
103	3	foreach ($params as $key => $value) {
104	3	if (stristr($return, ":" . $key) !== false) {
105	3	$return = str_replace(":" . $key, $value, $return);
106	3	unset($params[$key]);
107		}
108	3	if (array_key_exists($key, $this->params)) {
109		unset($params[$key]);
110		}
111		}
112	3	if ($params) {
		0 ignored issues – show Bug Best Practice introduced 2020-05-15 10:55 UTC by Report Bug Copy Issue Report The expression `$params` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `! empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
113	3	$return .= "?" . http_build_query($params);
114		}
115		}
116
117		// set defaults
118	3	if ($this->params) {
		0 ignored issues – show Bug Best Practice introduced 2020-05-15 10:55 UTC by Report Bug Copy Issue Report The expression `$this->params` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `! empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
119		foreach ($this->params as $key => $value) {
120		if (is_string($value)) {
121		$return = str_replace(":" . $key, $value, $return);
122		}
123		}
124		}
125
126	3	return $return;
127		}
128
129		/**
130		* @return string
131		*/
132	6	public function getMap()
133		{
134	6	return $this->map;
135		}
136
137		/**
138		* @param boolean $map
139		*/
140	10	public function setMap($map)
141		{
142	10	$this->map = $map;
		0 ignored issues – show Documentation Bug introduced 2020-05-15 10:55 UTC by Report Bug Copy Issue Report The property `$map` was declared of type `string`, but `$map` is of type `boolean`. Maybe add a type cast? This check looks for assignments to scalar types that may be of the wrong type. To ensure the code behaves as expected, it may be a good idea to add an explicit type cast. $answer = 42; $correct = false; $correct = (bool) $answer; Loading history...
143	10	$this->parseMap();
144	10	}
145
146		/**
147		* @param $params
148		* @return array
149		*/
150	1	public function stripEmptyParams($params)
151		{
152	1	if (is_array($params)) {
153	1	foreach ($params as $key => $param) {
154	1	if (empty($param)) {
155		unset($params[$key]);
156	1	} elseif (is_array($param)) {
157		$newParams = $this->stripEmptyParams($param);
158		if (!is_array($newParams) or count($newParams) < 1) {
159		unset($params[$key]);
160		} else {
161		$params[$key] = $newParams;
162		}
163		}
164		}
165		}
166
167	1	return $params;
168		}
169
170		/**
171		* @return array
172		*/
173	6	public function getParts()
174		{
175	6	return $this->parts;
176		}
177
178		/**
179		* @param array $parts
180		*/
181	11	public function setParts($parts)
182		{
183	11	$this->parts = $parts;
184	11	}
185
186		/**
187		* @return array
188		*/
189	2	public function getParams()
190		{
191	2	return $this->params;
192		}
193
194		/**
195		* @param array $params
196		*/
197	2	public function setParams($params = [])
198		{
199	2	if (count($params)) {
200	2	foreach ($params as $key => $value) {
201	2	$this->setParam($key, $value);
202		}
203		}
204	2	}
205
206		/**
207		* @param $name
208		* @param $value
209		* @return $this
210		*/
211	5	public function setParam($name, $value)
212		{
213	5	$this->params[$name] = $value;
214
215	5	return $this;
216		}
217
218		/**
219		* @param string $key
220		* @return mixed\|null
221		*/
222	2	public function getParam($key)
223		{
224	2	return $this->hasParam($key) ? $this->params[$key] : null;
225		}
226
227		/**
228		* @param $key
229		* @return bool
230		*/
231	2	public function hasParam($key)
232		{
233	2	return isset($this->params[$key]);
234		}
235
236		/**
237		* @return array
238		*/
239		public function getMatches()
240		{
241		return $this->matches;
242		}
243
244		/**
245		* @return array
246		*/
247	2	public function getVariables()
248		{
249	2	return $this->variables;
250		}
251
252		/**
253		* @param array $variables
254		*/
255	3	public function setVariables($variables)
256		{
257	3	$this->variables = $variables;
258	3	}
259
260		// public function setModule($module)
261		// {
262		// $this->_module = $module;
263		// }
264		//
265		// public function setController($controller)
266		// {
267		// $this->_controller = $controller;
268		// }
269		//
270		// public function setAction($action)
271		// {
272		// $this->_action = $action;
273		// }
274		}
275

bytic / router

AbstractParser::getMap() A last analyzed 2022-10-01 19:54 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

AbstractParser::getMap() A
last analyzed 2022-10-01 19:54 UTC