Route::__construct() - Code Metrics - preetender/routing - Measure and Improve Code Quality continuously with Scrutinizer

Route::__construct() A
last analyzed 2017-08-03 12:51 UTC

↳ Parent: Route

Complexity

Conditions	1
Paths	1

Size

Total Lines	8
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	8
c	0
b	0
f	0
rs	9.4285
cc	1
eloc	6
nc	1
nop	3

<?php

namespace Preetender\Routing;

use Illuminate\Http\Response;
use Illuminate\Http\Request;
use Preetender\Routing\Response\ExecuteResponse;

/**
 * Class Route
 * @package Preetender\Routing
 */
class Route
{
    use RouteReflection;

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

    /** @var  */
    protected $callable;

    /** @var   */
    protected $name;

    /** @var array  */
    private static $parameters = [];

    /** @var array  */
    private static $attributes = [];

    /** @var Request  */
    protected $request;

    /** @var  Response */
    protected $response;

    /** @var  */
    protected $running;

    /**
     * Route constructor.
     * @param $url
     * @param $callable
     * @param null $name
     */
    public function __construct($url, $callable, $name = null)
    {
        $this->url = trim($url, '/');
        $this->callable = $callable;
        $this->request = Kernel::getContainer()->get(Request::class);
        $this->response = Kernel::getContainer()->get(Response::class);
        $this->name = $name;
    }

    /**
     * Check the path, if there are parameters to create attributes for the scope of the request
     *
     * @param $url
     * @return bool
     */
    public function extractParameters($url)
    {
        $url = trim($url, '/');
        $path = preg_replace_callback('#:([\w]+)#', [$this, 'attributesMatch'], $this->getUrl());
        if(!preg_match("#^$path$#i", $url, $matches)) {
            return false;
        }
        array_shift($matches);
        self::$parameters = $matches;
        return true;
    }

    /**
     * ...
     *
     * @param $match
     * @return string
     */
    private function attributesMatch($match) {
        if(isset(self::$attributes[$match[1]])) {
            return '(' . self::$attributes[$match[1]] . ')';
        }
        return '([^/]+)';
    }

    /**
     * Get url.
     *
     * @return string
     */
    public function getUrl(): string
    {
        return $this->url;
    }

    /**
     * Get name route
     *
     * @return null|string
     */
    public function getName()
    {
        return $this->name;
    }

    /**
     * Get callback.
     *
     * @return mixed
     */
    public function getCallable()
    {
        return $this->callable;
    }

    /**
     * Get params.
     *
     * @return array
     */
    public static function getParameters(): array
    {
        return self::$parameters;
    }

    /**
     * Get properties on route
     *
     * @return array
     */
    public function getRoute()
    {
        return [
           'name' => $this->getName(),
           'path' => $this->getUrl(),
           'callable' => $this->getCallable(),
           'parameters' => self::resolveParameters()
        ];
    }

    /**
     * Get request
     *
     * @return Request
     */
    public function getRequest(): Request
    {
       return $this->request;
    }

    /**
     * Get reponse
     *
     * @return Response
     */
    public function getResponse(): Response
    {
       return $this->response;
    }

    /**
     * Executing route
     *
     * @param array $parameters
     * @return mixed
     */
    public function requestUrlCall($parameters = [])
    {
        $path = $this->getUrl();
        foreach ($parameters as $key => $value) {
            $path = str_replace(":$key", $value, $path);
        }
        $this->extractParameters($path);
        return $this->run();
    }

    /**
     * Exporta para o controlador uma coleção de dados;
     *
     * @param string $attribute
     * @param string $regex
     * @return $this
     */
    public function with(string $attribute, string $regex)
    {
        self::$attributes[$attribute] = str_replace('(', '(?:', $regex);
        return $this;
    }

    /**
     * Check the type of request and define which treatment it should receive
     *
     * @return mixed
     */
    public function run()
    {
        if(is_string($this->getCallable())) {
            return  $this->handleRequestController();
        }
        return $this->handleRequestCallable();
    }
    /**
     * ...
     *
     * @return mixed
     */
    protected function handleRequestCallable()
    {
        self::createReflection(new \ReflectionFunction($this->getCallable()));
        $call = call_user_func_array($this->getCallable(), self::resolveParameters());
        return ExecuteResponse::factory($call, $this->getRequest(), $this->getResponse());
    }

    /**
     * ...
     *
     * @return mixed
     */
    protected function handleRequestController()
    {
        $attributes = RouteController::prepare($this->getCallable());
        self::createReflection(new \ReflectionClass($attributes['class']), $attributes['method']);
        $call = call_user_func_array([$attributes['class'], $attributes['method']], self::resolveParameters());
        return ExecuteResponse::factory($call, $this->getRequest(), $this->getResponse());
    }
}

1			<?php
2
3			namespace Preetender\Routing;
4
5			use Illuminate\Http\Response;
6			use Illuminate\Http\Request;
7			use Preetender\Routing\Response\ExecuteResponse;
8
9			/**
10			* Class Route
11			* @package Preetender\Routing
12			*/
13			class Route
14			{
15			use RouteReflection;
16
17			/** @var string */
18			protected $url;
19
20			/** @var */
21			protected $callable;
22
23			/** @var */
24			protected $name;
25
26			/** @var array */
27			private static $parameters = [];
28
29			/** @var array */
30			private static $attributes = [];
31
32			/** @var Request */
33			protected $request;
34
35			/** @var Response */
36			protected $response;
37
38			/** @var */
39			protected $running;
40
41			/**
42			* Route constructor.
43			* @param $url
44			* @param $callable
45			* @param null $name
46			*/
47			public function __construct($url, $callable, $name = null)
48			{
49			$this->url = trim($url, '/');
50			$this->callable = $callable;
51			$this->request = Kernel::getContainer()->get(Request::class);
52			$this->response = Kernel::getContainer()->get(Response::class);
53			$this->name = $name;
54			}
55
56			/**
57			* Check the path, if there are parameters to create attributes for the scope of the request
58			*
59			* @param $url
60			* @return bool
61			*/
62			public function extractParameters($url)
63			{
64			$url = trim($url, '/');
65			$path = preg_replace_callback('#:([\w]+)#', [$this, 'attributesMatch'], $this->getUrl());
66			if(!preg_match("#^$path$#i", $url, $matches)) {
67			return false;
68			}
69			array_shift($matches);
70			self::$parameters = $matches;
71			return true;
72			}
73
74			/**
75			* ...
76			*
77			* @param $match
78			* @return string
79			*/
80			private function attributesMatch($match) {
81			if(isset(self::$attributes[$match[1]])) {
82			return '(' . self::$attributes[$match[1]] . ')';
83			}
84			return '([^/]+)';
85			}
86
87			/**
88			* Get url.
89			*
90			* @return string
91			*/
92			public function getUrl(): string
93			{
94			return $this->url;
95			}
96
97			/**
98			* Get name route
99			*
100			* @return null\|string
101			*/
102			public function getName()
103			{
104			return $this->name;
105			}
106
107			/**
108			* Get callback.
109			*
110			* @return mixed
111			*/
112			public function getCallable()
113			{
114			return $this->callable;
115			}
116
117			/**
118			* Get params.
119			*
120			* @return array
121			*/
122			public static function getParameters(): array
123			{
124			return self::$parameters;
125			}
126
127			/**
128			* Get properties on route
129			*
130			* @return array
131			*/
132			public function getRoute()
133			{
134			return [
135			'name' => $this->getName(),
136			'path' => $this->getUrl(),
137			'callable' => $this->getCallable(),
138			'parameters' => self::resolveParameters()
139			];
140			}
141
142			/**
143			* Get request
144			*
145			* @return Request
146			*/
147			public function getRequest(): Request
148			{
149			return $this->request;
150			}
151
152			/**
153			* Get reponse
154			*
155			* @return Response
156			*/
157			public function getResponse(): Response
158			{
159			return $this->response;
160			}
161
162			/**
163			* Executing route
164			*
165			* @param array $parameters
166			* @return mixed
167			*/
168			public function requestUrlCall($parameters = [])
169			{
170			$path = $this->getUrl();
171			foreach ($parameters as $key => $value) {
172			$path = str_replace(":$key", $value, $path);
173			}
174			$this->extractParameters($path);
175			return $this->run();
176			}
177
178			/**
179			* Exporta para o controlador uma coleção de dados;
180			*
181			* @param string $attribute
182			* @param string $regex
183			* @return $this
184			*/
185			public function with(string $attribute, string $regex)
186			{
187			self::$attributes[$attribute] = str_replace('(', '(?:', $regex);
188			return $this;
189			}
190
191			/**
192			* Check the type of request and define which treatment it should receive
193			*
194			* @return mixed
195			*/
196			public function run()
197			{
198			if(is_string($this->getCallable())) {
199			return $this->handleRequestController();
200			}
201			return $this->handleRequestCallable();
202			}
203			/**
204			* ...
205			*
206			* @return mixed
207			*/
208			protected function handleRequestCallable()
209			{
210			self::createReflection(new \ReflectionFunction($this->getCallable()));
211			$call = call_user_func_array($this->getCallable(), self::resolveParameters());
212			return ExecuteResponse::factory($call, $this->getRequest(), $this->getResponse());
213			}
214
215			/**
216			* ...
217			*
218			* @return mixed
219			*/
220			protected function handleRequestController()
221			{
222			$attributes = RouteController::prepare($this->getCallable());
223			self::createReflection(new \ReflectionClass($attributes['class']), $attributes['method']);
224			$call = call_user_func_array([$attributes['class'], $attributes['method']], self::resolveParameters());
225			return ExecuteResponse::factory($call, $this->getRequest(), $this->getResponse());
226			}
227			}

preetender / routing

Route::__construct() A last analyzed 2017-08-03 12:51 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Route::__construct() A
last analyzed 2017-08-03 12:51 UTC