UrlGenerator::previous() - Code Metrics - Inspection of "Merge branch 'develop'" - ByTIC/framework - Measure and Improve Code Quality continuously with Scrutinizer

Test Setup Failed

Push — master ( c5ade0...e039e4 )

by Gabriel

created 2017-07-29 13:11 UTC

UrlGenerator::previous() A

↳ Parent: UrlGenerator

Complexity

Conditions	4
Paths	6

Size

Total Lines	12
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	4
eloc	9
nc	6
nop	1
dl	0
loc	12
rs	9.2
c	0
b	0
f	0

<?php

namespace Nip\Router\Generator;

use Nip\Request;
use Nip\Router\RouteCollection;
use Nip\Utility\Arr;
use Nip\Utility\Str;

/**
 * Class UrlGenerator
 * @package Nip\Router\Generator
 */
class UrlGenerator
{

    /**
     * The route collection.
     *
     * @var RouteCollection
     */
    protected $routes;

    /**
     * The request instance.
     *
     * @var Request
     */
    protected $request;

    /**
     * A cached copy of the URL root for the current request.
     *
     * @var string|null
     */
    protected $cachedRoot;

    /**
     * A cached copy of the URL schema for the current request.
     *
     * @var string|null
     */
    protected $cachedSchema;

    /**
     * The forced URL root.
     *
     * @var string
     */
    protected $forcedRoot;

    /**
     * The forced schema for URLs.
     *
     * @var string
     */
    protected $forceScheme;

    /**
     * The callback to use to format hosts.
     *
     * @var \Closure
     */
    protected $formatHostUsing;

    /**
     * The callback to use to format paths.
     *
     * @var \Closure
     */
    protected $formatPathUsing;

    /**
     * Create a new URL Generator instance.
     *
     * @param  RouteCollection $routes
     * @param  Request $request
     */
    public function __construct(RouteCollection $routes, Request $request)
    {
        $this->routes = $routes;
        $this->setRequest($request);
    }

    /**
     * Set the current request instance.
     *
     * @param  Request $request
     * @return void
     */
    public function setRequest(Request $request)

    {
        $this->request = $request;

        $this->cachedRoot = null;
        $this->cachedSchema = null;
//        $this->routeGenerator = null;

    }

    /**
     * Get the full URL for the current request.
     *
     * @return string
     */
    public function full()
    {
        return $this->request->fullUrl();
    }

    /**
     * Get the current URL for the request.
     *
     * @return string
     */
    public function current()
    {
        return $this->to($this->request->getPathInfo());
    }

    /**
     * Generate an absolute URL to the given path.
     *
     * @param  string  $path
     * @param  mixed  $extra
     * @param  bool|null  $secure
     * @return string
     */
    public function to($path, $extra = [], $secure = null)
    {
        // First we will check if the URL is already a valid URL. If it is we will not
        // try to generate a new one but will simply return the URL as is, which is
        // convenient since developers do not always have to check if it's valid.
        if ($this->isValidUrl($path)) {
            return $path;
        }
        $tail = implode('/', array_map(
                'rawurlencode', (array) $this->formatParameters($extra))
        );
        // Once we have the scheme we will compile the "tail" by collapsing the values
        // into a single string delimited by slashes. This just makes it convenient
        // for passing the array of parameters to this URL as a list of segments.
        $root = $this->formatRoot($this->formatScheme($secure));
        list($path, $query) = $this->extractQueryString($path);
        return $this->format(
                $root, '/'.trim($path.'/'.$tail, '/')
            ).$query;
    }

    /**
     * Determine if the given path is a valid URL.
     *
     * @param  string $path
     * @return bool
     */
    public function isValidUrl($path)
    {
        if (!Str::startsWith($path, ['#', '//', 'mailto:', 'tel:', 'http://', 'https://'])) {
            return filter_var($path, FILTER_VALIDATE_URL) !== false;
        }
        return true;
    }

    /**
     * Format the array of URL parameters.
     *
     * @param  mixed|array  $parameters
     * @return array
     */
    public function formatParameters($parameters)
    {
        $parameters = Arr::wrap($parameters);
        foreach ($parameters as $key => $parameter) {

//            if ($parameter instanceof UrlRoutable) {

//                $parameters[$key] = $parameter->getRouteKey();
//            }
        }
        return $parameters;
    }

    /**
     * Get the base URL for the request.
     *
     * @param  string $scheme
     * @param  string $root
     * @return string
     */
    public function formatRoot($scheme, $root = null)
    {
        if (is_null($root)) {
            if (is_null($this->cachedRoot)) {
                $this->cachedRoot = $this->forcedRoot ?: $this->request->root();
            }
            $root = $this->cachedRoot;
        }
        $start = Str::startsWith($root, 'http://') ? 'http://' : 'https://';
        return preg_replace('~' . $start . '~', $scheme, $root, 1);
    }

    /**
     * Get the default scheme for a raw URL.
     *
     * @param  bool|null $secure
     * @return string
     */
    public function formatScheme($secure)
    {
        if (!is_null($secure)) {
            return $secure ? 'https://' : 'http://';
        }
        if (is_null($this->cachedSchema)) {
            $this->cachedSchema = $this->forceScheme ?: $this->request->getScheme() . '://';
        }
        return $this->cachedSchema;
    }

    /**
     * Extract the query string from the given path.
     *
     * @param  string  $path
     * @return array
     */
    protected function extractQueryString($path)
    {
        if (($queryPosition = strpos($path, '?')) !== false) {
            return [
                substr($path, 0, $queryPosition),
                substr($path, $queryPosition),
            ];
        }
        return [$path, ''];
    }

    /**
     * Format the given URL segments into a single URL.
     *
     * @param  string $root
     * @param  string $path
     * @return string
     */
    public function format($root, $path)
    {
        $path = '/' . trim($path, '/');
        if ($this->formatHostUsing) {
            $root = call_user_func($this->formatHostUsing, $root);
        }
        if ($this->formatPathUsing) {
            $path = call_user_func($this->formatPathUsing, $path);
        }
        return trim($root . $path, '/');
    }

    /**
     * Get the URL for the previous request.
     *
     * @param  mixed $fallback
     * @return string
     */
    public function previous($fallback = false)
    {
        $referrer = $this->request->headers->get('referer');
        $url = $referrer ? $this->to($referrer) : $this->getPreviousUrlFromSession();
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        if ($url) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            return $url;
        } elseif ($fallback) {
            return $this->to($fallback);
        } else {
            return $this->to('/');
        }
    }

    /**
     * Get the previous URL from the session if possible.
     *
     * @return string|null
     */
    protected function getPreviousUrlFromSession()
    {
        return null;
//        $session = $this->getSession();

//        return $session ? $session->previousUrl() : null;
    }

    /**
     * Generate the URL to an application asset.
     *
     * @param  string $path
     * @param  bool|null $secure
     * @return string
     */
    public function asset($path, $secure = null)
    {
        if ($this->isValidUrl($path)) {
            return $path;
        }
        // Once we get the root URL, we will check to see if it contains an index.php
        // file in the paths. If it does, we will remove it since it is not needed
        // for asset paths, but only for routes to endpoints in the application.
        $root = $this->formatRoot($this->formatScheme($secure));
        return $this->removeIndex($root) . '/assets/' . trim($path, '/');
    }

    /**
     * Remove the index.php file from a path.
     *
     * @param  string $root
     * @return string
     */
    protected function removeIndex($root)
    {
        $i = 'index.php';
        return Str::contains($root, $i) ? str_replace('/' . $i, '', $root) : $root;
    }
}


1			<?php
2
3			namespace Nip\Router\Generator;
4
5			use Nip\Request;
6			use Nip\Router\RouteCollection;
7			use Nip\Utility\Arr;
8			use Nip\Utility\Str;
9
10			/**
11			* Class UrlGenerator
12			* @package Nip\Router\Generator
13			*/
14			class UrlGenerator
15			{
16
17			/**
18			* The route collection.
19			*
20			* @var RouteCollection
21			*/
22			protected $routes;
23
24			/**
25			* The request instance.
26			*
27			* @var Request
28			*/
29			protected $request;
30
31			/**
32			* A cached copy of the URL root for the current request.
33			*
34			* @var string\|null
35			*/
36			protected $cachedRoot;
37
38			/**
39			* A cached copy of the URL schema for the current request.
40			*
41			* @var string\|null
42			*/
43			protected $cachedSchema;
44
45			/**
46			* The forced URL root.
47			*
48			* @var string
49			*/
50			protected $forcedRoot;
51
52			/**
53			* The forced schema for URLs.
54			*
55			* @var string
56			*/
57			protected $forceScheme;
58
59			/**
60			* The callback to use to format hosts.
61			*
62			* @var \Closure
63			*/
64			protected $formatHostUsing;
65
66			/**
67			* The callback to use to format paths.
68			*
69			* @var \Closure
70			*/
71			protected $formatPathUsing;
72
73			/**
74			* Create a new URL Generator instance.
75			*
76			* @param RouteCollection $routes
77			* @param Request $request
78			*/
79			public function __construct(RouteCollection $routes, Request $request)
80			{
81			$this->routes = $routes;
82			$this->setRequest($request);
83			}
84
85			/**
86			* Set the current request instance.
87			*
88			* @param Request $request
89			* @return void
90			*/
91			public function setRequest(Request $request)
			0 ignored issues – show Bug introduced 2017-07-29 13:16 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...
92			{
93			$this->request = $request;
94
95			$this->cachedRoot = null;
96			$this->cachedSchema = null;
97			// $this->routeGenerator = null;
			0 ignored issues – show Unused Code Comprehensibility introduced 2017-07-29 13:16 UTC by Report Bug Copy Issue Report `45%` of this comment could be valid code. Did you maybe forget this after debugging? Sometimes obsolete code just ends up commented out instead of removed. In this case it is better to remove the code once you have checked you do not need it. The code might also have been commented out for debugging purposes. In this case it is vital that someone uncomments it again or your project may behave in very unexpected ways in production. This check looks for comments that seem to be mostly valid code and reports them. Loading history...
98			}
99
100			/**
101			* Get the full URL for the current request.
102			*
103			* @return string
104			*/
105			public function full()
106			{
107			return $this->request->fullUrl();
108			}
109
110			/**
111			* Get the current URL for the request.
112			*
113			* @return string
114			*/
115			public function current()
116			{
117			return $this->to($this->request->getPathInfo());
118			}
119
120			/**
121			* Generate an absolute URL to the given path.
122			*
123			* @param string $path
124			* @param mixed $extra
125			* @param bool\|null $secure
126			* @return string
127			*/
128			public function to($path, $extra = [], $secure = null)
129			{
130			// First we will check if the URL is already a valid URL. If it is we will not
131			// try to generate a new one but will simply return the URL as is, which is
132			// convenient since developers do not always have to check if it's valid.
133			if ($this->isValidUrl($path)) {
134			return $path;
135			}
136			$tail = implode('/', array_map(
137			'rawurlencode', (array) $this->formatParameters($extra))
138			);
139			// Once we have the scheme we will compile the "tail" by collapsing the values
140			// into a single string delimited by slashes. This just makes it convenient
141			// for passing the array of parameters to this URL as a list of segments.
142			$root = $this->formatRoot($this->formatScheme($secure));
143			list($path, $query) = $this->extractQueryString($path);
144			return $this->format(
145			$root, '/'.trim($path.'/'.$tail, '/')
146			).$query;
147			}
148
149			/**
150			* Determine if the given path is a valid URL.
151			*
152			* @param string $path
153			* @return bool
154			*/
155			public function isValidUrl($path)
156			{
157			if (!Str::startsWith($path, ['#', '//', 'mailto:', 'tel:', 'http://', 'https://'])) {
158			return filter_var($path, FILTER_VALIDATE_URL) !== false;
159			}
160			return true;
161			}
162
163			/**
164			* Format the array of URL parameters.
165			*
166			* @param mixed\|array $parameters
167			* @return array
168			*/
169			public function formatParameters($parameters)
170			{
171			$parameters = Arr::wrap($parameters);
172			foreach ($parameters as $key => $parameter) {
			0 ignored issues – show Unused Code introduced 2017-07-29 13:16 UTC by Report Bug Copy Issue Report This `foreach` statement is empty and can be removed. This check looks for `foreach` loops that have no statements or where all statements have been commented out. This may be the result of changes for debugging or the code may simply be obsolete. Consider removing the loop. Loading history...
173			// if ($parameter instanceof UrlRoutable) {
			0 ignored issues – show Unused Code Comprehensibility introduced 2017-07-29 13:16 UTC by Report Bug Copy Issue Report `54%` of this comment could be valid code. Did you maybe forget this after debugging? Sometimes obsolete code just ends up commented out instead of removed. In this case it is better to remove the code once you have checked you do not need it. The code might also have been commented out for debugging purposes. In this case it is vital that someone uncomments it again or your project may behave in very unexpected ways in production. This check looks for comments that seem to be mostly valid code and reports them. Loading history...
174			// $parameters[$key] = $parameter->getRouteKey();
175			// }
176			}
177			return $parameters;
178			}
179
180			/**
181			* Get the base URL for the request.
182			*
183			* @param string $scheme
184			* @param string $root
185			* @return string
186			*/
187			public function formatRoot($scheme, $root = null)
188			{
189			if (is_null($root)) {
190			if (is_null($this->cachedRoot)) {
191			$this->cachedRoot = $this->forcedRoot ?: $this->request->root();
192			}
193			$root = $this->cachedRoot;
194			}
195			$start = Str::startsWith($root, 'http://') ? 'http://' : 'https://';
196			return preg_replace('~' . $start . '~', $scheme, $root, 1);
197			}
198
199			/**
200			* Get the default scheme for a raw URL.
201			*
202			* @param bool\|null $secure
203			* @return string
204			*/
205			public function formatScheme($secure)
206			{
207			if (!is_null($secure)) {
208			return $secure ? 'https://' : 'http://';
209			}
210			if (is_null($this->cachedSchema)) {
211			$this->cachedSchema = $this->forceScheme ?: $this->request->getScheme() . '://';
212			}
213			return $this->cachedSchema;
214			}
215
216			/**
217			* Extract the query string from the given path.
218			*
219			* @param string $path
220			* @return array
221			*/
222			protected function extractQueryString($path)
223			{
224			if (($queryPosition = strpos($path, '?')) !== false) {
225			return [
226			substr($path, 0, $queryPosition),
227			substr($path, $queryPosition),
228			];
229			}
230			return [$path, ''];
231			}
232
233			/**
234			* Format the given URL segments into a single URL.
235			*
236			* @param string $root
237			* @param string $path
238			* @return string
239			*/
240			public function format($root, $path)
241			{
242			$path = '/' . trim($path, '/');
243			if ($this->formatHostUsing) {
244			$root = call_user_func($this->formatHostUsing, $root);
245			}
246			if ($this->formatPathUsing) {
247			$path = call_user_func($this->formatPathUsing, $path);
248			}
249			return trim($root . $path, '/');
250			}
251
252			/**
253			* Get the URL for the previous request.
254			*
255			* @param mixed $fallback
256			* @return string
257			*/
258			public function previous($fallback = false)
259			{
260			$referrer = $this->request->headers->get('referer');
261			$url = $referrer ? $this->to($referrer) : $this->getPreviousUrlFromSession();
			0 ignored issues – show Bug introduced 2017-07-29 13:16 UTC by Report Bug Copy Issue Report It seems like `$referrer` defined by `$this->request->headers->get('referer')` on line `260` can also be of type `array`; however, `Nip\Router\Generator\UrlGenerator::to()` does only seem to accept `string`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
262			if ($url) {
			0 ignored issues – show Bug Best Practice introduced 2017-07-29 13:16 UTC by Report Bug Copy Issue Report The expression `$url` of type `string\|null` 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...
263			return $url;
264			} elseif ($fallback) {
265			return $this->to($fallback);
266			} else {
267			return $this->to('/');
268			}
269			}
270
271			/**
272			* Get the previous URL from the session if possible.
273			*
274			* @return string\|null
275			*/
276			protected function getPreviousUrlFromSession()
277			{
278			return null;
279			// $session = $this->getSession();
			0 ignored issues – show Unused Code Comprehensibility introduced 2017-07-29 13:16 UTC by Report Bug Copy Issue Report `56%` of this comment could be valid code. Did you maybe forget this after debugging? Sometimes obsolete code just ends up commented out instead of removed. In this case it is better to remove the code once you have checked you do not need it. The code might also have been commented out for debugging purposes. In this case it is vital that someone uncomments it again or your project may behave in very unexpected ways in production. This check looks for comments that seem to be mostly valid code and reports them. Loading history...
280			// return $session ? $session->previousUrl() : null;
281			}
282
283			/**
284			* Generate the URL to an application asset.
285			*
286			* @param string $path
287			* @param bool\|null $secure
288			* @return string
289			*/
290			public function asset($path, $secure = null)
291			{
292			if ($this->isValidUrl($path)) {
293			return $path;
294			}
295			// Once we get the root URL, we will check to see if it contains an index.php
296			// file in the paths. If it does, we will remove it since it is not needed
297			// for asset paths, but only for routes to endpoints in the application.
298			$root = $this->formatRoot($this->formatScheme($secure));
299			return $this->removeIndex($root) . '/assets/' . trim($path, '/');
300			}
301
302			/**
303			* Remove the index.php file from a path.
304			*
305			* @param string $root
306			* @return string
307			*/
308			protected function removeIndex($root)
309			{
310			$i = 'index.php';
311			return Str::contains($root, $i) ? str_replace('/' . $i, '', $root) : $root;
312			}
313			}
314

ByTIC / framework

GitHub Access Token became invalid

Push — master ( c5ade0...e039e4 )

UrlGenerator::previous() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like