Router - Code Metrics - Inspection of "View work" - zewadesign/framework - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#70)

unknown

created 2016-08-17 02:21 UTC

Router C

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	445
Duplicated Lines	2.02 %

Coupling/Cohesion

Components	2
Dependencies	2

Test Coverage

Coverage

64.19%

Importance

Changes	21
Bugs	4	Features	1

Metric	Value
wmc	61
c	21
b	4
f	1
lcom	2
cbo	2
dl	9
loc	445
ccs	138
cts	215
cp	0.6419
rs	6.018

13 Methods

Rating	Name	Duplication	Size	Complexity
B	__construct()	0	38	1
A	isURIClean()	0	17	4
B	normalize()	0	12	5
B	parseURI()	0	28	4
B	normalizeURI()	0	22	5
B	discoverRoute()	0	29	4
A	uri()	0	13	2
C	sortURISegments()	9	36	8
A	addQueryString()	0	10	2
A	removeQueryString()	0	6	1
B	currentURL()	0	19	6
C	baseURL()	0	27	7
C	redirect()	0	51	12

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like Router often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use Router, and based on these observations, apply Extract Interface, too.

<?php
namespace Zewa;

use Zewa\Exception\RouteException;

/**
 * Handles everything relating to URL/URI.
 *
 * @author Zechariah Walden<zech @ zewadesign.com>
 */
class Router
{
    /**
     * Reference to instantiated controller object.
     *
     * @var object
     */
    protected static $instance = false;

    /**
     * System configuration
     *
     * @var object
     */
    private $configuration;

    /**
     * The active module
     *
     * @var    string
     * @access public
     */
    public $module;

    /**
     * The active controller
     *
     * @var    string
     * @access public
     */
    public $controller;

    /**
     * The active method
     *
     * @var    string
     * @access public
     */
    public $method;

    /**
     * The base URL
     *
     * @var    string
     * @access public
     */
    public $baseURL;

    /**
     * Default module
     *
     * @var    string
     * @access public
     */
    public $defaultModule;

    /**
     * Default controller
     *
     * @var    string
     * @access public
     */
    public $defaultController;

    /**
     * Default method
     *
     * @var    string
     * @access public
     */
    public $defaultMethod;

    /**
     * Default uri
     *
     * @var    string
     * @access public
     */
    public $uri;
    /**
     * Load up some basic configuration settings.
     */
    public function __construct()
    {
        self::$instance = $this;

        $app = App::getInstance();
        $moduleConfig = $app->getConfiguration('modules');

        $this->defaultModule = $moduleConfig->defaultModule;
        $defaultModule = $this->defaultModule;
        $this->defaultController = $moduleConfig->$defaultModule->defaultController;
        $this->defaultMethod = $moduleConfig->$defaultModule->defaultMethod;

        $normalizedURI = $this->normalizeURI();

        //check routes


        $this->uri = $this->uri($normalizedURI);
        $this->baseURL = $this->baseURL();
        $this->currentURL = $this->currentURL();
class MyClass { }

$x = new MyClass();
$x->foo = true;

        //@TODO: routing
        $uriChunks = $this->parseURI($this->uri);

        $app = App::getInstance();

        $app->setConfiguration(
            'router',
            (object)[
            'module' => $uriChunks[0],
            'controller' => $uriChunks[1],
            'method' => $uriChunks[2],
            'params' => array_slice($uriChunks, 3),
            'baseURL' => $this->baseURL,
            'currentURL' => $this->currentURL
            ]
        );
    }


    private function isURIClean($uri, $uriChunks)
    {
        if (!preg_match("/^[a-z0-9:_\/\.\[\]-]+$/i", $uri)
            || array_filter(
                $uriChunks,
                function ($uriChunk) {
                    if (strpos($uriChunk, '__') !== false) {
                        return true;
                    }
                }
            )
        ) {
            return false;
        } else {
            return true;
        }
    }

    //@TODO add Security class.
    private function normalize($data)
    {
        if (is_numeric($data)) {
            if (is_int($data) || ctype_digit(trim($data, '-'))) {
                $data = (int)$data;
            } elseif ($data === (string)(float)$data) {
                //@TODO: this needs work.. 9E26 converts to float
                $data = (float)$data;
            }
        }
        return $data;
    }

    /**
     * Parse and explode URI segments into chunks
     *
     * @access private
     *
     * @param string $uri
     *
     * @return array chunks of uri
     * @throws RouteException on disallowed characters
     */
    private function parseURI($uri)
    {
        $uriFragments = explode('/', $uri);
        $uriChunks = [];
        $params = [];
        $iteration = 0;
        foreach ($uriFragments as $location => $fragment) {
            if ($iteration > 2) {
                $params[] = $this->normalize(trim($fragment));
            } else {
                $uriChunks[] = trim($fragment);
            }
            $iteration++;
        }

        $result = array_merge($uriChunks, $params);

        if ($this->isURIClean($uri, $result) === false) {
//            echo "<PRE>\r\n";

//            print_r($_SERVER);
//            print_r($uri);echo "\r\n";
//            print_r($result);echo "\r\n";
//            die("test");
            throw new RouteException('Invalid key characters.');
        }

        return $result;
    }

    /**
     * Normalize the $_SERVER vars for formatting the URI.
     *
     * @access private
     * @return string formatted/u/r/l
     */
    private function normalizeURI()
// Bad
class Router
{
    public function generate($path)
    {
        return $_SERVER['HOST'].$path;
    }
}

// Better
class Router
{
    private $host;

    public function __construct($host)
    {
        $this->host = $host;
    }

    public function generate($path)
    {
        return $this->host.$path;
    }
}

class Controller
{
    public function myAction(Request $request)
    {
        // Instead of
        $page = isset($_GET['page']) ? intval($_GET['page']) : 1;

        // Better (assuming you use the Symfony2 request)
        $page = $request->query->get('page', 1);
    }
}
    {
        if (!empty($_SERVER['PATH_INFO'])) {
            $normalizedURI = $_SERVER['PATH_INFO'];
        } elseif (!empty($_SERVER['REQUEST_URI'])) {
            $normalizedURI = $_SERVER['REQUEST_URI'];
        } else {
            $normalizedURI = false;
        }

        if ($normalizedURI === '/') {
            $normalizedURI = false;
        }

        $normalizedURI = ltrim(preg_replace('/\?.*/', '', $normalizedURI), '/');

        if (! empty($this->configuration->routes)) {
            $normalizedURI = $this->discoverRoute($normalizedURI);
        }

        return $normalizedURI;
    }

    private function discoverRoute($uri)
    {
        $routes = $this->configuration->routes;

        foreach ($routes as $route => $reroute) {
            $pattern = '/^(?i)' . str_replace('/', '\/', $route) . '$/';

            if (preg_match($pattern, $uri, $params)) {
                array_shift($params);

                $uri = $reroute;

                if (! empty($params)) {
                    $pat = '/(\$\d+)/';
                    $uri = preg_replace_callback(
                        $pat,
                        function () use (&$params) {
                            $first = $params[0];
                            array_shift($params);
                            return $first;
                        },
                        $reroute
                    );
                }
            }
        }

        return $uri;
    }

    /**
     * Normalize the $_SERVER vars for formatting the URI.
     *
     * @access public
     * @return string formatted/u/r/l
     */
    private function uri($uri)
    {
        if ($uri !== '') {
            $uriChunks = explode('/', filter_var(trim($uri), FILTER_SANITIZE_URL));
            $chunks = $this->sortURISegments($uriChunks);
        } else {
            $chunks = $this->sortURISegments();
        }

        $uri = ltrim(implode('/', $chunks), '/');

        return $uri;
    }

    private function sortURISegments($uriChunks = [])
    {
        $module = ucfirst(strtolower($this->defaultModule));
        $controller = ucfirst(strtolower($this->defaultController));
        $method = ucfirst(strtolower($this->defaultMethod));

        if (!empty($uriChunks)) {
            $module = ucfirst(strtolower($uriChunks[0]));

            if (!empty($uriChunks[1])) {
                $controller = ucfirst(strtolower($uriChunks[1]));
            } elseif (!empty($this->configuration->modules->$module->defaultController)) {
                $controller = $this->configuration->modules->$module->defaultController;
            }

            if (!empty($uriChunks[2])) {
                $method = ucfirst(strtolower($uriChunks[2]));
                $class = '\\App\\Modules\\' . $module . '\\Controllers\\' . $controller;
                $methodExist = method_exists($class, $method);
                
                if ($methodExist === false) {

                    if (!empty($this->configuration->modules->$module->defaultMethod)) {
                        $method = $this->configuration->modules->$module->defaultMethod;
                        array_unshift($uriChunks, null);
                    }
                }
            } elseif (!empty($this->configuration->modules->$module->defaultMethod)) {

                $method = $this->configuration->modules->$module->defaultMethod;
            }

            unset($uriChunks[0], $uriChunks[1], $uriChunks[2]);
        }

        $return = [$module, $controller, $method];
        return array_merge($return, array_values($uriChunks));
    }

    private function addQueryString($url, $key, $value)
    {
        $url = preg_replace('/(.*)(\?|&)' . $key . '=[^&]+?(&)(.*)/i', '$1$2$4', $url . '&');
        $url = substr($url, 0, -1);
        if (strpos($url, '?') === false) {
            return ($url . '?' . $key . '=' . $value);
        } else {
            return ($url . '&' . $key . '=' . $value);
        }
    }

    private function removeQueryString($url, $key)
    {
        $url = preg_replace('/(.*)(\?|&)' . $key . '=[^&]+?(&)(.*)/i', '$1$2$4', $url . '&');
        $url = substr($url, 0, -1);
        return ($url);
    }

    /**
     * Return the currentURL w/ query strings
     *
     * @access public
     * @return string http://tld.com/formatted/u/r/l?q=bingo
     */
    public function currentURL($params = false)
// Bad
class Router
{
    public function generate($path)
    {
        return $_SERVER['HOST'].$path;
    }
}

// Better
class Router
{
    private $host;

    public function __construct($host)
    {
        $this->host = $host;
    }

    public function generate($path)
    {
        return $this->host.$path;
    }
}

class Controller
{
    public function myAction(Request $request)
    {
        // Instead of
        $page = isset($_GET['page']) ? intval($_GET['page']) : 1;

        // Better (assuming you use the Symfony2 request)
        $page = $request->query->get('page', 1);
    }
}
    {
        if (trim($_SERVER['REQUEST_URI']) === '/') {
            $url = $this->baseURL()
                   . (!empty($_SERVER['QUERY_STRING']) ? '?' . $_SERVER['QUERY_STRING'] : '');
        } else {
            $url = $this->baseURL($this->uri)
                   . (!empty($_SERVER['QUERY_STRING']) ? '?' . $_SERVER['QUERY_STRING'] : '');
        }

        if (!empty($params)) {
            foreach ($params as $key => $param) {

                $url = $this->removeQueryString($url, $key);
                $url = $this->addQueryString($url, $key, $param);
            }
        }

        return $url;
    }

    /**
     * Return the baseURL
     *
     * @access public
     * @return string http://tld.com
     */
    public function baseURL($path = '')
// Bad
class Router
{
    public function generate($path)
    {
        return $_SERVER['HOST'].$path;
    }
}

// Better
class Router
{
    private $host;

    public function __construct($host)
    {
        $this->host = $host;
    }

    public function generate($path)
    {
        return $this->host.$path;
    }
}

class Controller
{
    public function myAction(Request $request)
    {
        // Instead of
        $page = isset($_GET['page']) ? intval($_GET['page']) : 1;

        // Better (assuming you use the Symfony2 request)
        $page = $request->query->get('page', 1);
    }
}
    {
        if (is_null($this->baseURL)) {
            $self = $_SERVER['PHP_SELF'];
            $server = $_SERVER['HTTP_HOST']
                      . rtrim(str_replace(strstr($self, 'index.php'), '', $self), '/');

            if ((!empty($_SERVER['HTTPS']) && $_SERVER['HTTPS'] != 'off')
                || !empty($_SERVER['HTTP_X_FORWARDED_PROTO'])
                && $_SERVER['HTTP_X_FORWARDED_PROTO'] === 'https'
            ) {
                $protocol = 'https://';
            } else {
                $protocol = 'http://';
            }

            $this->baseURL = $protocol . $server;
        }

        $url = $this->baseURL;

        if ($path !== '') {
            $url .= '/' . $path;
        }

        return $url;
    }

    /**
     * Set optional status header, and redirect to provided URL
     *
     * @access public
     * @return bool
     */
    public function redirect($url = '/', $status = null)
    {
        $url = str_replace(array('\r', '\n', '%0d', '%0a'), '', $url);

        if (headers_sent()) {
            return false;
        }

        // trap session vars before redirect
        session_write_close();

        if (is_null($status)) {
            $status = '302';
        }

        // push a status to the browser if necessary
        if ((int)$status > 0) {
            switch ($status) {
                case '301':
                    $msg = '301 Moved Permanently';
                    break;
                case '307':
                    $msg = '307 Temporary Redirect';
                    break;
                // Using these below (except 302) would be an intentional misuse of the 'system'
                // Need to dig into the above comment @zech
                case '401':
                    $msg = '401 Access Denied';
                    break;
                case '403':
                    $msg = '403 Request Forbidden';
                    break;
                case '404':
                    $msg = '404 Not Found';
                    break;
                case '405':
                    $msg = '405 Method Not Allowed';
                    break;
                case '302':
                default:
                    $msg = '302 Found';
                    break; // temp redirect
            }
            if (isset($msg)) {
                header('HTTP/1.1 ' . $msg);
            }
        }

        $url = preg_replace('!^/*!', '', $url);
        header("Location: " . $url);
    }
}


1			<?php
2			namespace Zewa;
3
4			use Zewa\Exception\RouteException;
5
6			/**
7			* Handles everything relating to URL/URI.
8			*
9			* @author Zechariah Walden<zech @ zewadesign.com>
10			*/
11			class Router
12			{
13			/**
14			* Reference to instantiated controller object.
15			*
16			* @var object
17			*/
18			protected static $instance = false;
19
20			/**
21			* System configuration
22			*
23			* @var object
24			*/
25			private $configuration;
26
27			/**
28			* The active module
29			*
30			* @var string
31			* @access public
32			*/
33			public $module;
34
35			/**
36			* The active controller
37			*
38			* @var string
39			* @access public
40			*/
41			public $controller;
42
43			/**
44			* The active method
45			*
46			* @var string
47			* @access public
48			*/
49			public $method;
50
51			/**
52			* The base URL
53			*
54			* @var string
55			* @access public
56			*/
57			public $baseURL;
58
59			/**
60			* Default module
61			*
62			* @var string
63			* @access public
64			*/
65			public $defaultModule;
66
67			/**
68			* Default controller
69			*
70			* @var string
71			* @access public
72			*/
73			public $defaultController;
74
75			/**
76			* Default method
77			*
78			* @var string
79			* @access public
80			*/
81			public $defaultMethod;
82
83			/**
84			* Default uri
85			*
86			* @var string
87			* @access public
88			*/
89			public $uri;
90			/**
91			* Load up some basic configuration settings.
92			*/
93	28		public function __construct()
94			{
95	28		self::$instance = $this;
96
97	28		$app = App::getInstance();
98	28		$moduleConfig = $app->getConfiguration('modules');
99
100	28		$this->defaultModule = $moduleConfig->defaultModule;
101	28		$defaultModule = $this->defaultModule;
102	28		$this->defaultController = $moduleConfig->$defaultModule->defaultController;
103	28		$this->defaultMethod = $moduleConfig->$defaultModule->defaultMethod;
104
105	28		$normalizedURI = $this->normalizeURI();
106
107			//check routes
108
109
110	28		$this->uri = $this->uri($normalizedURI);
111	28		$this->baseURL = $this->baseURL();
112	28		$this->currentURL = $this->currentURL();
			0 ignored issues – show Bug introduced 2016-08-13 01:11 UTC by Report Bug Copy Issue Report The property `currentURL` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
113
114			//@TODO: routing
115	28		$uriChunks = $this->parseURI($this->uri);
116
117	14		$app = App::getInstance();
118
119	14		$app->setConfiguration(
120	14		'router',
121			(object)[
122	14		'module' => $uriChunks[0],
123	14		'controller' => $uriChunks[1],
124	14		'method' => $uriChunks[2],
125	14		'params' => array_slice($uriChunks, 3),
126	14		'baseURL' => $this->baseURL,
127	14		'currentURL' => $this->currentURL
128	14		]
129	14		);
130	14		}
131
132
133	28		private function isURIClean($uri, $uriChunks)
134			{
135	28		if (!preg_match("/^[a-z0-9:_\/\.\[\]-]+$/i", $uri)
136	28		\|\| array_filter(
137	19		$uriChunks,
138			function ($uriChunk) {
139	19		if (strpos($uriChunk, '__') !== false) {
140	5		return true;
141			}
142	19		}
143	19		)
144	28		) {
145	14		return false;
146			} else {
147	14		return true;
148			}
149			}
150
151			//@TODO add Security class.
152	26		private function normalize($data)
153			{
154	26		if (is_numeric($data)) {
155	12		if (is_int($data) \|\| ctype_digit(trim($data, '-'))) {
156	3		$data = (int)$data;
157	12		} elseif ($data === (string)(float)$data) {
158			//@TODO: this needs work.. 9E26 converts to float
159	4		$data = (float)$data;
160	4		}
161	12		}
162	26		return $data;
163			}
164
165			/**
166			* Parse and explode URI segments into chunks
167			*
168			* @access private
169			*
170			* @param string $uri
171			*
172			* @return array chunks of uri
173			* @throws RouteException on disallowed characters
174			*/
175	28		private function parseURI($uri)
176			{
177	28		$uriFragments = explode('/', $uri);
178	28		$uriChunks = [];
179	28		$params = [];
180	28		$iteration = 0;
181	28		foreach ($uriFragments as $location => $fragment) {
182	28		if ($iteration > 2) {
183	26		$params[] = $this->normalize(trim($fragment));
184	26		} else {
185	28		$uriChunks[] = trim($fragment);
186			}
187	28		$iteration++;
188	28		}
189
190	28		$result = array_merge($uriChunks, $params);
191
192	28		if ($this->isURIClean($uri, $result) === false) {
193			// echo "<PRE>\r\n";
			0 ignored issues – show Unused Code Comprehensibility introduced 2016-08-17 02:23 UTC by Report Bug Copy Issue Report `64%` 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...
194			// print_r($_SERVER);
195			// print_r($uri);echo "\r\n";
196			// print_r($result);echo "\r\n";
197			// die("test");
198	14		throw new RouteException('Invalid key characters.');
199			}
200
201	14		return $result;
202			}
203
204			/**
205			* Normalize the $_SERVER vars for formatting the URI.
206			*
207			* @access private
208			* @return string formatted/u/r/l
209			*/
210	28		private function normalizeURI()
			0 ignored issues – show Coding Style introduced 2016-08-13 01:11 UTC by Report Bug Copy Issue Report `normalizeURI` uses the super-global variable `$_SERVER` which is generally not recommended. Instead of super-globals, we recommend to explicitly inject the dependencies of your class. This makes your code less dependent on global state and it becomes generally more testable: // Bad class Router { public function generate($path) { return $_SERVER['HOST'].$path; } } // Better class Router { private $host; public function __construct($host) { $this->host = $host; } public function generate($path) { return $this->host.$path; } } class Controller { public function myAction(Request $request) { // Instead of $page = isset($_GET['page']) ? intval($_GET['page']) : 1; // Better (assuming you use the Symfony2 request) $page = $request->query->get('page', 1); } } Loading history...
211			{
212	28		if (!empty($_SERVER['PATH_INFO'])) {
213			$normalizedURI = $_SERVER['PATH_INFO'];
214	28		} elseif (!empty($_SERVER['REQUEST_URI'])) {
215	28		$normalizedURI = $_SERVER['REQUEST_URI'];
216	28		} else {
217			$normalizedURI = false;
218			}
219
220	28		if ($normalizedURI === '/') {
221			$normalizedURI = false;
222			}
223
224	28		$normalizedURI = ltrim(preg_replace('/\?.*/', '', $normalizedURI), '/');
225
226	28		if (! empty($this->configuration->routes)) {
227			$normalizedURI = $this->discoverRoute($normalizedURI);
228			}
229
230	28		return $normalizedURI;
231			}
232
233			private function discoverRoute($uri)
234			{
235			$routes = $this->configuration->routes;
236
237			foreach ($routes as $route => $reroute) {
238			$pattern = '/^(?i)' . str_replace('/', '\/', $route) . '$/';
239
240			if (preg_match($pattern, $uri, $params)) {
241			array_shift($params);
242
243			$uri = $reroute;
244
245			if (! empty($params)) {
246			$pat = '/(\$\d+)/';
247			$uri = preg_replace_callback(
248			$pat,
249			function () use (&$params) {
250			$first = $params[0];
251			array_shift($params);
252			return $first;
253			},
254			$reroute
255			);
256			}
257			}
258			}
259
260			return $uri;
261			}
262
263			/**
264			* Normalize the $_SERVER vars for formatting the URI.
265			*
266			* @access public
267			* @return string formatted/u/r/l
268			*/
269	28		private function uri($uri)
270			{
271	28		if ($uri !== '') {
272	28		$uriChunks = explode('/', filter_var(trim($uri), FILTER_SANITIZE_URL));
273	28		$chunks = $this->sortURISegments($uriChunks);
274	28		} else {
275			$chunks = $this->sortURISegments();
276			}
277
278	28		$uri = ltrim(implode('/', $chunks), '/');
279
280	28		return $uri;
281			}
282
283	28		private function sortURISegments($uriChunks = [])
284			{
285	28		$module = ucfirst(strtolower($this->defaultModule));
286	28		$controller = ucfirst(strtolower($this->defaultController));
287	28		$method = ucfirst(strtolower($this->defaultMethod));
288
289	28		if (!empty($uriChunks)) {
290	28		$module = ucfirst(strtolower($uriChunks[0]));
291
292	28		if (!empty($uriChunks[1])) {
293	26		$controller = ucfirst(strtolower($uriChunks[1]));
294	28		} elseif (!empty($this->configuration->modules->$module->defaultController)) {
295			$controller = $this->configuration->modules->$module->defaultController;
296			}
297
298	28		if (!empty($uriChunks[2])) {
299	26		$method = ucfirst(strtolower($uriChunks[2]));
300	26		$class = '\\App\\Modules\\' . $module . '\\Controllers\\' . $controller;
301	26		$methodExist = method_exists($class, $method);
302
303	26	View Code Duplication	if ($methodExist === false) {
			0 ignored issues – show Duplication introduced 2016-08-13 01:11 UTC by Report Bug Copy Issue Report This code seems to be duplicated across 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...
304	26		if (!empty($this->configuration->modules->$module->defaultMethod)) {
305			$method = $this->configuration->modules->$module->defaultMethod;
306			array_unshift($uriChunks, null);
307			}
308	26		}
309	28	View Code Duplication	} elseif (!empty($this->configuration->modules->$module->defaultMethod)) {
			0 ignored issues – show Duplication introduced 2016-08-13 01:11 UTC by Report Bug Copy Issue Report This code seems to be duplicated across 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...
310			$method = $this->configuration->modules->$module->defaultMethod;
311			}
312
313	28		unset($uriChunks[0], $uriChunks[1], $uriChunks[2]);
314	28		}
315
316	28		$return = [$module, $controller, $method];
317	28		return array_merge($return, array_values($uriChunks));
318			}
319
320	2		private function addQueryString($url, $key, $value)
321			{
322	2		$url = preg_replace('/(.)(\?\|&)' . $key . '=[^&]+?(&)(.)/i', '$1$2$4', $url . '&');
323	2		$url = substr($url, 0, -1);
324	2		if (strpos($url, '?') === false) {
325	2		return ($url . '?' . $key . '=' . $value);
326			} else {
327	1		return ($url . '&' . $key . '=' . $value);
328			}
329			}
330
331	2		private function removeQueryString($url, $key)
332			{
333	2		$url = preg_replace('/(.)(\?\|&)' . $key . '=[^&]+?(&)(.)/i', '$1$2$4', $url . '&');
334	2		$url = substr($url, 0, -1);
335	2		return ($url);
336			}
337
338			/**
339			* Return the currentURL w/ query strings
340			*
341			* @access public
342			* @return string http://tld.com/formatted/u/r/l?q=bingo
343			*/
344	28		public function currentURL($params = false)
			0 ignored issues – show Coding Style introduced 2016-08-13 01:11 UTC by Report Bug Copy Issue Report `currentURL` uses the super-global variable `$_SERVER` which is generally not recommended. Instead of super-globals, we recommend to explicitly inject the dependencies of your class. This makes your code less dependent on global state and it becomes generally more testable: // Bad class Router { public function generate($path) { return $_SERVER['HOST'].$path; } } // Better class Router { private $host; public function __construct($host) { $this->host = $host; } public function generate($path) { return $this->host.$path; } } class Controller { public function myAction(Request $request) { // Instead of $page = isset($_GET['page']) ? intval($_GET['page']) : 1; // Better (assuming you use the Symfony2 request) $page = $request->query->get('page', 1); } } Loading history...
345			{
346	28		if (trim($_SERVER['REQUEST_URI']) === '/') {
347			$url = $this->baseURL()
348			. (!empty($_SERVER['QUERY_STRING']) ? '?' . $_SERVER['QUERY_STRING'] : '');
349			} else {
350	28		$url = $this->baseURL($this->uri)
351	28		. (!empty($_SERVER['QUERY_STRING']) ? '?' . $_SERVER['QUERY_STRING'] : '');
352			}
353
354	28		if (!empty($params)) {
355	2		foreach ($params as $key => $param) {
			0 ignored issues – show Bug introduced 2016-08-13 01:11 UTC by Report Bug Copy Issue Report The expression `$params` of type `boolean` is not traversable. Loading history...
356	2		$url = $this->removeQueryString($url, $key);
357	2		$url = $this->addQueryString($url, $key, $param);
358	2		}
359	2		}
360
361	28		return $url;
362			}
363
364			/**
365			* Return the baseURL
366			*
367			* @access public
368			* @return string http://tld.com
369			*/
370	28		public function baseURL($path = '')
			0 ignored issues – show Coding Style introduced 2016-08-13 01:11 UTC by Report Bug Copy Issue Report `baseURL` uses the super-global variable `$_SERVER` which is generally not recommended. Instead of super-globals, we recommend to explicitly inject the dependencies of your class. This makes your code less dependent on global state and it becomes generally more testable: // Bad class Router { public function generate($path) { return $_SERVER['HOST'].$path; } } // Better class Router { private $host; public function __construct($host) { $this->host = $host; } public function generate($path) { return $this->host.$path; } } class Controller { public function myAction(Request $request) { // Instead of $page = isset($_GET['page']) ? intval($_GET['page']) : 1; // Better (assuming you use the Symfony2 request) $page = $request->query->get('page', 1); } } Loading history...
371			{
372	28		if (is_null($this->baseURL)) {
373	28		$self = $_SERVER['PHP_SELF'];
374	28		$server = $_SERVER['HTTP_HOST']
375	28		. rtrim(str_replace(strstr($self, 'index.php'), '', $self), '/');
376
377	28		if ((!empty($_SERVER['HTTPS']) && $_SERVER['HTTPS'] != 'off')
378	27		\|\| !empty($_SERVER['HTTP_X_FORWARDED_PROTO'])
379	27		&& $_SERVER['HTTP_X_FORWARDED_PROTO'] === 'https'
380	28		) {
381	1		$protocol = 'https://';
382	1		} else {
383	27		$protocol = 'http://';
384			}
385
386	28		$this->baseURL = $protocol . $server;
387	28		}
388
389	28		$url = $this->baseURL;
390
391	28		if ($path !== '') {
392	28		$url .= '/' . $path;
393	28		}
394
395	28		return $url;
396			}
397
398			/**
399			* Set optional status header, and redirect to provided URL
400			*
401			* @access public
402			* @return bool
403			*/
404			public function redirect($url = '/', $status = null)
405			{
406			$url = str_replace(array('\r', '\n', '%0d', '%0a'), '', $url);
407
408			if (headers_sent()) {
409			return false;
410			}
411
412			// trap session vars before redirect
413			session_write_close();
414
415			if (is_null($status)) {
416			$status = '302';
417			}
418
419			// push a status to the browser if necessary
420			if ((int)$status > 0) {
421			switch ($status) {
422			case '301':
423			$msg = '301 Moved Permanently';
424			break;
425			case '307':
426			$msg = '307 Temporary Redirect';
427			break;
428			// Using these below (except 302) would be an intentional misuse of the 'system'
429			// Need to dig into the above comment @zech
430			case '401':
431			$msg = '401 Access Denied';
432			break;
433			case '403':
434			$msg = '403 Request Forbidden';
435			break;
436			case '404':
437			$msg = '404 Not Found';
438			break;
439			case '405':
440			$msg = '405 Method Not Allowed';
441			break;
442			case '302':
443			default:
444			$msg = '302 Found';
445			break; // temp redirect
446			}
447			if (isset($msg)) {
448			header('HTTP/1.1 ' . $msg);
449			}
450			}
451
452			$url = preg_replace('!^/*!', '', $url);
453			header("Location: " . $url);
454			}
455			}
456

zewadesign / framework