Dispatch::namespace() - Code Metrics - kadokweb/router - Measure and Improve Code Quality continuously with Scrutinizer

Dispatch::namespace() A
last analyzed 2019-03-28 14:22 UTC

↳ Parent: Dispatch

Complexity

Conditions	2
Paths	2

Size

Total Lines	4
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

namespace KadokWeb\Router;


/**
 * Class KadokWeb Dispatch
 * @author Doka B. Silva <https://github.com/kadokweb>
 * @package KadokWeb\Router
 */
abstract class Dispatch
{
    /** @var bool|string */
    protected $projectUrl;

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

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

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

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

    /** @var null|string */
    protected $group;

    /** @var null|array */
    protected $route;

    /** @var null|string */
    protected $namespace;

    /** @var null|array */
    protected $data;

    /** @var int */
    protected $error;

    /** @const int Bad Request */
    public const BAD_REQUEST = 400;

    /** @const int Not Found */
    public const NOT_FOUND = 404;

    /** @const int Method Not Allowed */
    public const METHOD_NOT_ALLOWED = 405;

    /** @const int Not Implemented */
    public const NOT_IMPLEMENTED = 501;

    /**
     * Dispatch constructor.
     * @param string $projectUrl
     * @param string|null $separator
     */
    public function __construct(string $projectUrl, ?string $separator = ":")
    {
        $this->projectUrl = (substr($projectUrl, "-1") == "/" ? substr($projectUrl, 0, -1) : $projectUrl);
        $this->patch = (filter_input(INPUT_GET, "route", FILTER_DEFAULT) ?? "/");
        $this->separator = ($separator ?? ":");
        $this->httpMethod = $_SERVER['REQUEST_METHOD'];
    }

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

    /**
     * @param null|string $group
     * @return Dispatch
     */
    public function group(?string $group): Dispatch
    {
        $this->group = ($group ? str_replace("/", "", $group) : null);
        return $this;
    }

    /**
     * @param null|string $namespace
     * @return Dispatch
     */
    public function namespace(?string $namespace): Dispatch
    {
        $this->namespace = ($namespace ? ucwords($namespace) : null);
        return $this;
    }

    /**
     * @return null|array
     */
    public function data(): ?array
    {
        return $this->data;
    }

    /**
     * @return null|int
     */
    public function error(): ?int
    {
        return $this->error;
    }

    /**
     * @param string $route
     */
    public function redirect(string $route): void
    {
        header("Location: {$this->projectUrl}{$route}");
    }

    /**
     * @return bool
     */
    public function dispatch(): bool
    {
        if (empty($this->routes) || empty($this->routes[$this->httpMethod])) {
            $this->error = self::NOT_IMPLEMENTED;
            return false;
        }

        $this->route = null;
        foreach ($this->routes[$this->httpMethod] as $key => $route) {
            if (preg_match("~^" . $key . "$~", $this->patch, $found)) {
                $this->route = $route;
            }
        }

        return $this->route();
    }

    /**
     * @return bool
     */
    private function route()
    {
        if ($this->route) {
            if (is_callable($this->route['handler'])) {
                call_user_func($this->route['handler'], ($this->route['data'] ?? []));
                return true;
            }

            $controller = $this->route['handler'];
            $method = $this->route['action'];

            if (class_exists($controller)) {
                $newController = new $controller;
                if (method_exists($controller, $method)) {
                    $newController->$method(($this->route['data'] ?? []));
                    return true;
                }

                $this->error = self::METHOD_NOT_ALLOWED;
                return false;
            }

            $this->error = self::BAD_REQUEST;
            return false;
        }

        $this->error = self::NOT_FOUND;
        return false;
    }

    /**
     * @param string $method
     * @param string $route
     * @param string|callable $handler
     * @return Dispatch
     */
    protected function addRoute(string $method, string $route, $handler): Dispatch
    {
        if ($route == "/") {
            $this->addRoute($method, "", $handler);
        }

        preg_match_all("~\{\s* ([a-zA-Z_][a-zA-Z0-9_-]*) \}~x", $route, $keys, PREG_SET_ORDER);
        $routeDiff = array_values(array_diff(explode("/", $this->patch), explode("/", $route)));

        $this->formSpoofing();
        $offset = ($this->group ? 1 : 0);
        foreach ($keys as $key) {
            $this->data[$key[1]] = ($routeDiff[$offset++] ?? null);
        }

        $route = (!$this->group ? $route : "/{$this->group}{$route}");
        $data = $this->data;
        $namespace = $this->namespace;
        $router = function () use ($method, $handler, $data, $route, $namespace) {
            return [
                "route" => $route,
                "method" => $method,
                "handler" => $this->handler($handler, $namespace),
                "action" => $this->action($handler),
                "data" => $data
            ];
        };

        $route = preg_replace('~{([^}]*)}~', "([^/]+)", $route);
        $this->routes[$method][$route] = $router();
        return $this;
    }

    /**
     * httpMethod form spoofing
     */
    protected function formSpoofing(): void
    {
        $post = filter_input_array(INPUT_POST, FILTER_DEFAULT);

        if (!empty($post['_method']) && in_array($post['_method'], ["PUT", "PATCH", "DELETE"])) {
            $this->httpMethod = $post['_method'];
            $this->data = $post;

            unset($this->data["_method"]);
            return;
        }

        if ($this->httpMethod == "POST") {
            $this->data = filter_input_array(INPUT_POST, FILTER_DEFAULT);

            unset($this->data["_method"]);
            return;
        }

        if (in_array($this->httpMethod, ["PUT", "PATCH", "DELETE"]) && !empty($_SERVER['CONTENT_LENGTH'])) {
            parse_str(file_get_contents('php://input', false, null, 0, $_SERVER['CONTENT_LENGTH']), $putPatch);
            $this->data = $putPatch;

            unset($this->data["_method"]);
            return;
        }

        $this->data = [];
        return;
    }

    /**
     * @param $handler
     * @param $namespace
     * @return string|callable
     */
    private function handler($handler, $namespace)
    {
        return (!is_string($handler) ? $handler : "{$namespace}\\" . explode($this->separator, $handler)[0]);
    }

    /**
     * @param $handler
     * @return null|string
     */
    private function action($handler): ?string
    {
        return (!is_string($handler) ?: (explode($this->separator, $handler)[1] ?? null));
    }
}

1			<?php
2
3			namespace KadokWeb\Router;
4
5
6			/**
7			* Class KadokWeb Dispatch
8			* @author Doka B. Silva <https://github.com/kadokweb>
9			* @package KadokWeb\Router
10			*/
11			abstract class Dispatch
12			{
13			/** @var bool\|string */
14			protected $projectUrl;
15
16			/** @var string */
17			protected $patch;
18
19			/** @var string */
20			protected $separator;
21
22			/** @var string */
23			protected $httpMethod;
24
25			/** @var array */
26			protected $routes;
27
28			/** @var null\|string */
29			protected $group;
30
31			/** @var null\|array */
32			protected $route;
33
34			/** @var null\|string */
35			protected $namespace;
36
37			/** @var null\|array */
38			protected $data;
39
40			/** @var int */
41			protected $error;
42
43			/** @const int Bad Request */
44			public const BAD_REQUEST = 400;
45
46			/** @const int Not Found */
47			public const NOT_FOUND = 404;
48
49			/** @const int Method Not Allowed */
50			public const METHOD_NOT_ALLOWED = 405;
51
52			/** @const int Not Implemented */
53			public const NOT_IMPLEMENTED = 501;
54
55			/**
56			* Dispatch constructor.
57			* @param string $projectUrl
58			* @param string\|null $separator
59			*/
60			public function __construct(string $projectUrl, ?string $separator = ":")
61			{
62			$this->projectUrl = (substr($projectUrl, "-1") == "/" ? substr($projectUrl, 0, -1) : $projectUrl);
63			$this->patch = (filter_input(INPUT_GET, "route", FILTER_DEFAULT) ?? "/");
64			$this->separator = ($separator ?? ":");
65			$this->httpMethod = $_SERVER['REQUEST_METHOD'];
66			}
67
68			/**
69			* @return array
70			*/
71			public function __debugInfo()
72			{
73			return $this->routes;
74			}
75
76			/**
77			* @param null\|string $group
78			* @return Dispatch
79			*/
80			public function group(?string $group): Dispatch
81			{
82			$this->group = ($group ? str_replace("/", "", $group) : null);
83			return $this;
84			}
85
86			/**
87			* @param null\|string $namespace
88			* @return Dispatch
89			*/
90			public function namespace(?string $namespace): Dispatch
91			{
92			$this->namespace = ($namespace ? ucwords($namespace) : null);
93			return $this;
94			}
95
96			/**
97			* @return null\|array
98			*/
99			public function data(): ?array
100			{
101			return $this->data;
102			}
103
104			/**
105			* @return null\|int
106			*/
107			public function error(): ?int
108			{
109			return $this->error;
110			}
111
112			/**
113			* @param string $route
114			*/
115			public function redirect(string $route): void
116			{
117			header("Location: {$this->projectUrl}{$route}");
118			}
119
120			/**
121			* @return bool
122			*/
123			public function dispatch(): bool
124			{
125			if (empty($this->routes) \|\| empty($this->routes[$this->httpMethod])) {
126			$this->error = self::NOT_IMPLEMENTED;
127			return false;
128			}
129
130			$this->route = null;
131			foreach ($this->routes[$this->httpMethod] as $key => $route) {
132			if (preg_match("~^" . $key . "$~", $this->patch, $found)) {
133			$this->route = $route;
134			}
135			}
136
137			return $this->route();
138			}
139
140			/**
141			* @return bool
142			*/
143			private function route()
144			{
145			if ($this->route) {
146			if (is_callable($this->route['handler'])) {
147			call_user_func($this->route['handler'], ($this->route['data'] ?? []));
148			return true;
149			}
150
151			$controller = $this->route['handler'];
152			$method = $this->route['action'];
153
154			if (class_exists($controller)) {
155			$newController = new $controller;
156			if (method_exists($controller, $method)) {
157			$newController->$method(($this->route['data'] ?? []));
158			return true;
159			}
160
161			$this->error = self::METHOD_NOT_ALLOWED;
162			return false;
163			}
164
165			$this->error = self::BAD_REQUEST;
166			return false;
167			}
168
169			$this->error = self::NOT_FOUND;
170			return false;
171			}
172
173			/**
174			* @param string $method
175			* @param string $route
176			* @param string\|callable $handler
177			* @return Dispatch
178			*/
179			protected function addRoute(string $method, string $route, $handler): Dispatch
180			{
181			if ($route == "/") {
182			$this->addRoute($method, "", $handler);
183			}
184
185			preg_match_all("~\{\s* ([a-zA-Z_][a-zA-Z0-9_-]*) \}~x", $route, $keys, PREG_SET_ORDER);
186			$routeDiff = array_values(array_diff(explode("/", $this->patch), explode("/", $route)));
187
188			$this->formSpoofing();
189			$offset = ($this->group ? 1 : 0);
190			foreach ($keys as $key) {
191			$this->data[$key[1]] = ($routeDiff[$offset++] ?? null);
192			}
193
194			$route = (!$this->group ? $route : "/{$this->group}{$route}");
195			$data = $this->data;
196			$namespace = $this->namespace;
197			$router = function () use ($method, $handler, $data, $route, $namespace) {
198			return [
199			"route" => $route,
200			"method" => $method,
201			"handler" => $this->handler($handler, $namespace),
202			"action" => $this->action($handler),
203			"data" => $data
204			];
205			};
206
207			$route = preg_replace('~{([^}]*)}~', "([^/]+)", $route);
208			$this->routes[$method][$route] = $router();
209			return $this;
210			}
211
212			/**
213			* httpMethod form spoofing
214			*/
215			protected function formSpoofing(): void
216			{
217			$post = filter_input_array(INPUT_POST, FILTER_DEFAULT);
218
219			if (!empty($post['_method']) && in_array($post['_method'], ["PUT", "PATCH", "DELETE"])) {
220			$this->httpMethod = $post['_method'];
221			$this->data = $post;
222
223			unset($this->data["_method"]);
224			return;
225			}
226
227			if ($this->httpMethod == "POST") {
228			$this->data = filter_input_array(INPUT_POST, FILTER_DEFAULT);
229
230			unset($this->data["_method"]);
231			return;
232			}
233
234			if (in_array($this->httpMethod, ["PUT", "PATCH", "DELETE"]) && !empty($_SERVER['CONTENT_LENGTH'])) {
235			parse_str(file_get_contents('php://input', false, null, 0, $_SERVER['CONTENT_LENGTH']), $putPatch);
236			$this->data = $putPatch;
237
238			unset($this->data["_method"]);
239			return;
240			}
241
242			$this->data = [];
243			return;
244			}
245
246			/**
247			* @param $handler
248			* @param $namespace
249			* @return string\|callable
250			*/
251			private function handler($handler, $namespace)
252			{
253			return (!is_string($handler) ? $handler : "{$namespace}\\" . explode($this->separator, $handler)[0]);
254			}
255
256			/**
257			* @param $handler
258			* @return null\|string
259			*/
260			private function action($handler): ?string
261			{
262			return (!is_string($handler) ?: (explode($this->separator, $handler)[1] ?? null));
263			}
264			}

kadokweb / router

Dispatch::namespace() A last analyzed 2019-03-28 14:22 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Dispatch::namespace() A
last analyzed 2019-03-28 14:22 UTC