ApiRoute::prepareForMatch() - Code Metrics - Inspection of "Improved coding style, ApiRouterExtension made a b..." - ublaboo/api-router - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( c6d651...f3cc34 )

by Pavel

created 2016-03-09 23:02 UTC

ApiRoute::prepareForMatch() A

↳ Parent: ApiRoute

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	0

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

<?php

/**
 * @copyright   Copyright (c) 2016 ublaboo <[email protected]>
 * @author      Pavel Janda <[email protected]>
 * @package     Ublaboo
 */

namespace Ublaboo\ApiRouter;

use Nette\Application\IRouter;
use Nette\Application\Request;
use Nette;
use Nette\Utils\Strings;

/**
 * @Annotation
 * @Target({"CLASS", "METHOD"})
 */
class ApiRoute extends ApiRouteSpec implements IRouter
{

	/**
	 * @var callable[]
	 */
	public $onMatch;

	/**
	 * @var string
	 */
	private $presenter;

	/**
	 * @var array
	 */
	private $actions = [
		'POST'   => FALSE,
		'GET'    => FALSE,
		'PUT'    => FALSE,
		'DELETE' => FALSE
	];

	/**
	 * @var array
	 */
	private $default_actions = [
		'POST'   => 'create',
		'GET'    => 'read',
		'PUT'    => 'update',
		'DELETE' => 'delete'
	];

	/**
	 * @var array
	 */
	private $formats = [
		'json' => 'application/json',
		'xml'  => 'application/xml'
	];

	/**
	 * @var array
	 */
	private $placeholder_order = [];


	/**
	 * @param mixed  $data
	 * @param string $presenter
	 * @param array  $data
	 */
	public function __construct($path, $presenter = NULL, array $data = [])
	{
		/**
		 * Interface for setting route via annotation or directly
		 */
		if (!is_array($path)) {
			$data['value'] = $path;
			$data['presenter'] = $presenter;

			if (empty($data['methods'])) {
				$this->actions = $this->default_actions;
			} else {
				foreach ($data['methods'] as $method => $action) {
					if (is_string($method)) {
						$this->setAction($action, $method);
					} else {
						$m = $action;

						if (isset($this->default_actions[$m])) {
							$this->setAction($this->default_actions[$m], $m);
						}
					}
				}

				unset($data['methods']);
			}
		} else {
			$data = $path;
		}

		/**
		 * Set Path
		 */
		$this->setPath($data['value']);
		unset($data['value']);

		parent::__construct($data);
	}


	/**
	 * @param string $presenter
	 * @return void
	 */
	public function setPresenter($presenter)
	{
		$this->presenter = $presenter;
	}


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


	/**
	 * @param string $action
	 * @param string $method
	 * @return void
	 */
	public function setAction($action, $method = NULL) {
		if (is_null($method)) {
			$method = array_search($action, $this->default_actions);
		}

		if (!isset($this->default_actions[$method])) {
			return;
		}

		$this->actions[$method] = $action;
	}


	/**
	 * @param  string $string
	 * @return string
	 */
	private function prepareForMatch($string)
	{
		return sprintf('/%s/', str_replace('/', '\/', $string));
	}


	/**
	 * Get all parameters from url mask
	 * @return array
	 */
	public function getPlacehodlerParameters()
	{
		if (!empty($this->placeholder_order)) {
			return array_filter($this->placeholder_order);
		}

		$return = [];

		preg_replace_callback('/<(\w+)>/', function($item) use (&$return) {
			$return[] = end($item);
		}, $this->path);

		return $return;
	}


	/**
	 * Get required parameters from url mask
	 * @return array
	 */
	public function getRequiredParams()
	{
		$regex = '/\[[^\[]+?\]/';
		$path = $this->getPath();

		while (preg_match($regex, $path)) {
			$path = preg_replace($regex, '', $path);
		}

		$required = [];

		preg_replace_callback('/<(\w+)>/', function($item) use (&$required) {
			$required[] = end($item);
		}, $path);

		return $required;
	}


	/**
	 * @param  Nette\Http\IRequest $httpRequest
	 * @return void
	 */
	public function resolveFormat(Nette\Http\IRequest $httpRequest)
	{
		if ($this->getFormat()) {
			return;
		}

		$header = $httpRequest->getHeader('Accept');

		foreach ($this->formats as $format => $format_full) {
			$format_full = Strings::replace($format_full, '/\//', '\/');

			if (Strings::match($header, "/{$format_full}/")) {
				$this->setFormat($format);
			}
		}

		$this->setFormat('json');
	}


	/**
	 * @return string
	 */
	public function getFormatFull()
	{
		return $this->formats[$this->getFormat()];
	}

	/**
	 * @return array
	 */
	public function getMethods()
	{
		return array_keys(array_filter($this->actions));
	}


	/**
	 * @param  Nette\Http\IRequest $request
	 * @return string
	 */
	public function resolveMethod(Nette\Http\IRequest $request) {
		if (!empty($request->getHeader('X-HTTP-Method-Override'))) {
			return Strings::upper($request->getHeader('X-HTTP-Method-Override'));
		}

		if ($method = Strings::upper($request->getQuery('__apiRouteMethod'))) {
			if (isset($this->actions[$method])) {
				return $method;
			}
		}

		return Strings::upper($request->getMethod());
	}


	/********************************************************************************
	 *                              Interface IRouter                               *
	 ********************************************************************************/


	/**
	 * Maps HTTP request to a Request object.
	 * @return Request|NULL
	 */
	public function match(Nette\Http\IRequest $httpRequest)
	{
		$url = $httpRequest->getUrl();

		$path = '/' . preg_replace('/^' . str_replace('/', '\/', preg_quote($url->getBasePath())) . '/', '', $url->getPath());

		/**
		 * Build path mask
		 */
		$order = &$this->placeholder_order;
		$parameters = $this->parameters;

		$mask = preg_replace_callback('/(<(\w+)>)|\[|\]/', function($item) use (&$order, $parameters) {
			if ($item[0] == '[' || $item[0] == ']') {
				if ($item[0] == '[') {
					$order[] = NULL;
				}

				return $item[0];
			}

			list(, , $placeholder) = $item;

			$parameter = isset($parameters[$placeholder]) ? $parameters[$placeholder] : [];

			$regex = isset($parameter['requirement']) ? $parameter['requirement'] : '\w+';
			$has_default = array_key_exists('default', $parameter);

			if ($has_default) {
				$order[] = $placeholder;

				return sprintf('(%s)?', $regex);
			}

			$order[] = $placeholder;

			return sprintf('(%s)', $regex);
		}, $this->path);

		$mask = '^' . str_replace(['[', ']'], ['(', ')?'], $mask) . '$';

		/**
		 * Prepare paths for regex match (escape slashes)
		 */
		if (!preg_match_all($this->prepareForMatch($mask), $path, $matches)) {
			return NULL;
		}

		/**
		 * Did some action to the request method exists?
		 */
		$this->resolveFormat($httpRequest);
		$method = $this->resolveMethod($httpRequest);
		$action = $this->actions[$method];

		if (!$action) {
			return NULL;
		}

		/**
		 * Basic params
		 */
		$params = $httpRequest->getQuery();
		$params['action'] = $action;
		$required_params = $this->getRequiredParams();

		/**
		 * Route mask parameters
		 */
		array_shift($matches);

		foreach ($this->placeholder_order as $key => $name) {
			if (NULL !== $name && isset($matches[$key])) {
				$params[$name] = reset($matches[$key]) ?: NULL;

				/**
				 * Required parameters
				 */
				if (empty($params[$name]) && in_array($name, $required_params)) {
					return NULL;
				}
			}
		}

		$request = new Request(
			$this->presenter,
			$method,
			$params,
			$httpRequest->getPost(),
			$httpRequest->getFiles(),
			[Request::SECURED => $httpRequest->isSecured()]
		);

		/**
		 * Trigger event - route matches
		 */
		$this->onMatch($this, $request);
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }

		return $request;
	}


	/**
	 * Constructs absolute URL from Request object.
	 * @return string|NULL
	 */
	public function constructUrl(Request $request, Nette\Http\Url $url)
	{
		if ($this->presenter != $request->getPresenterName()) {
			return NULL;
		}

		$base_url = $url->getBaseUrl();

		$action = $request->getParameter('action');
		$parameters = $request->getParameters();
		unset($parameters['action']);
		$path = ltrim($this->getPath(), '/');

		if (FALSE === array_search($action, $this->actions)) {
			return NULL;
		}

		foreach ($parameters as $name => $value) {
			if (strpos($path, "<{$name}>") !== FALSE && $value !== NULL) {
				$path = str_replace("<{$name}>", $value, $path);

				unset($parameters[$name]);
			}
		}

		$path = preg_replace_callback('/\[.+?\]/', function($item) {
			if (strpos(end($item), '<')) {
				return '';
			}

			return end($item);
		}, $path);

		/**
		 * There are still some required parameters in url mask
		 */
		if (preg_match('/<\w+>/', $path)) {
			return NULL;
		}

		$path = str_replace(['[', ']'], '', $path);

		$query = http_build_query($parameters);

		return $base_url . $path . ($query ? '?' . $query : '');
	}

}


1			<?php
2
3			/**
4			* @copyright Copyright (c) 2016 ublaboo <[email protected]>
5			* @author Pavel Janda <[email protected]>
6			* @package Ublaboo
7			*/
8
9			namespace Ublaboo\ApiRouter;
10
11			use Nette\Application\IRouter;
12			use Nette\Application\Request;
13			use Nette;
14			use Nette\Utils\Strings;
15
16			/**
17			* @Annotation
18			* @Target({"CLASS", "METHOD"})
19			*/
20			class ApiRoute extends ApiRouteSpec implements IRouter
21			{
22
23			/**
24			* @var callable[]
25			*/
26			public $onMatch;
27
28			/**
29			* @var string
30			*/
31			private $presenter;
32
33			/**
34			* @var array
35			*/
36			private $actions = [
37			'POST' => FALSE,
38			'GET' => FALSE,
39			'PUT' => FALSE,
40			'DELETE' => FALSE
41			];
42
43			/**
44			* @var array
45			*/
46			private $default_actions = [
47			'POST' => 'create',
48			'GET' => 'read',
49			'PUT' => 'update',
50			'DELETE' => 'delete'
51			];
52
53			/**
54			* @var array
55			*/
56			private $formats = [
57			'json' => 'application/json',
58			'xml' => 'application/xml'
59			];
60
61			/**
62			* @var array
63			*/
64			private $placeholder_order = [];
65
66
67			/**
68			* @param mixed $data
69			* @param string $presenter
70			* @param array $data
71			*/
72			public function __construct($path, $presenter = NULL, array $data = [])
73			{
74			/**
75			* Interface for setting route via annotation or directly
76			*/
77			if (!is_array($path)) {
78			$data['value'] = $path;
79			$data['presenter'] = $presenter;
80
81			if (empty($data['methods'])) {
82			$this->actions = $this->default_actions;
83			} else {
84			foreach ($data['methods'] as $method => $action) {
85			if (is_string($method)) {
86			$this->setAction($action, $method);
87			} else {
88			$m = $action;
89
90			if (isset($this->default_actions[$m])) {
91			$this->setAction($this->default_actions[$m], $m);
92			}
93			}
94			}
95
96			unset($data['methods']);
97			}
98			} else {
99			$data = $path;
100			}
101
102			/**
103			* Set Path
104			*/
105			$this->setPath($data['value']);
106			unset($data['value']);
107
108			parent::__construct($data);
109			}
110
111
112			/**
113			* @param string $presenter
114			* @return void
115			*/
116			public function setPresenter($presenter)
117			{
118			$this->presenter = $presenter;
119			}
120
121
122			/**
123			* @return string
124			*/
125			public function getPresenter()
126			{
127			return $this->presenter;
128			}
129
130
131			/**
132			* @param string $action
133			* @param string $method
134			* @return void
135			*/
136			public function setAction($action, $method = NULL) {
137			if (is_null($method)) {
138			$method = array_search($action, $this->default_actions);
139			}
140
141			if (!isset($this->default_actions[$method])) {
142			return;
143			}
144
145			$this->actions[$method] = $action;
146			}
147
148
149			/**
150			* @param string $string
151			* @return string
152			*/
153			private function prepareForMatch($string)
154			{
155			return sprintf('/%s/', str_replace('/', '\/', $string));
156			}
157
158
159			/**
160			* Get all parameters from url mask
161			* @return array
162			*/
163			public function getPlacehodlerParameters()
164			{
165			if (!empty($this->placeholder_order)) {
166			return array_filter($this->placeholder_order);
167			}
168
169			$return = [];
170
171			preg_replace_callback('/<(\w+)>/', function($item) use (&$return) {
172			$return[] = end($item);
173			}, $this->path);
174
175			return $return;
176			}
177
178
179			/**
180			* Get required parameters from url mask
181			* @return array
182			*/
183			public function getRequiredParams()
184			{
185			$regex = '/\[[^\[]+?\]/';
186			$path = $this->getPath();
187
188			while (preg_match($regex, $path)) {
189			$path = preg_replace($regex, '', $path);
190			}
191
192			$required = [];
193
194			preg_replace_callback('/<(\w+)>/', function($item) use (&$required) {
195			$required[] = end($item);
196			}, $path);
197
198			return $required;
199			}
200
201
202			/**
203			* @param Nette\Http\IRequest $httpRequest
204			* @return void
205			*/
206			public function resolveFormat(Nette\Http\IRequest $httpRequest)
207			{
208			if ($this->getFormat()) {
209			return;
210			}
211
212			$header = $httpRequest->getHeader('Accept');
213
214			foreach ($this->formats as $format => $format_full) {
215			$format_full = Strings::replace($format_full, '/\//', '\/');
216
217			if (Strings::match($header, "/{$format_full}/")) {
218			$this->setFormat($format);
219			}
220			}
221
222			$this->setFormat('json');
223			}
224
225
226			/**
227			* @return string
228			*/
229			public function getFormatFull()
230			{
231			return $this->formats[$this->getFormat()];
232			}
233
234			/**
235			* @return array
236			*/
237			public function getMethods()
238			{
239			return array_keys(array_filter($this->actions));
240			}
241
242
243			/**
244			* @param Nette\Http\IRequest $request
245			* @return string
246			*/
247			public function resolveMethod(Nette\Http\IRequest $request) {
248			if (!empty($request->getHeader('X-HTTP-Method-Override'))) {
249			return Strings::upper($request->getHeader('X-HTTP-Method-Override'));
250			}
251
252			if ($method = Strings::upper($request->getQuery('__apiRouteMethod'))) {
253			if (isset($this->actions[$method])) {
254			return $method;
255			}
256			}
257
258			return Strings::upper($request->getMethod());
259			}
260
261
262			/********************************************************************************
263			* Interface IRouter *
264			********************************************************************************/
265
266
267			/**
268			* Maps HTTP request to a Request object.
269			* @return Request\|NULL
270			*/
271			public function match(Nette\Http\IRequest $httpRequest)
272			{
273			$url = $httpRequest->getUrl();
274
275			$path = '/' . preg_replace('/^' . str_replace('/', '\/', preg_quote($url->getBasePath())) . '/', '', $url->getPath());
276
277			/**
278			* Build path mask
279			*/
280			$order = &$this->placeholder_order;
281			$parameters = $this->parameters;
282
283			$mask = preg_replace_callback('/(<(\w+)>)\|\[\|\]/', function($item) use (&$order, $parameters) {
284			if ($item[0] == '[' \|\| $item[0] == ']') {
285			if ($item[0] == '[') {
286			$order[] = NULL;
287			}
288
289			return $item[0];
290			}
291
292			list(, , $placeholder) = $item;
293
294			$parameter = isset($parameters[$placeholder]) ? $parameters[$placeholder] : [];
295
296			$regex = isset($parameter['requirement']) ? $parameter['requirement'] : '\w+';
297			$has_default = array_key_exists('default', $parameter);
298
299			if ($has_default) {
300			$order[] = $placeholder;
301
302			return sprintf('(%s)?', $regex);
303			}
304
305			$order[] = $placeholder;
306
307			return sprintf('(%s)', $regex);
308			}, $this->path);
309
310			$mask = '^' . str_replace(['[', ']'], ['(', ')?'], $mask) . '$';
311
312			/**
313			* Prepare paths for regex match (escape slashes)
314			*/
315			if (!preg_match_all($this->prepareForMatch($mask), $path, $matches)) {
316			return NULL;
317			}
318
319			/**
320			* Did some action to the request method exists?
321			*/
322			$this->resolveFormat($httpRequest);
323			$method = $this->resolveMethod($httpRequest);
324			$action = $this->actions[$method];
325
326			if (!$action) {
327			return NULL;
328			}
329
330			/**
331			* Basic params
332			*/
333			$params = $httpRequest->getQuery();
334			$params['action'] = $action;
335			$required_params = $this->getRequiredParams();
336
337			/**
338			* Route mask parameters
339			*/
340			array_shift($matches);
341
342			foreach ($this->placeholder_order as $key => $name) {
343			if (NULL !== $name && isset($matches[$key])) {
344			$params[$name] = reset($matches[$key]) ?: NULL;
345
346			/**
347			* Required parameters
348			*/
349			if (empty($params[$name]) && in_array($name, $required_params)) {
350			return NULL;
351			}
352			}
353			}
354
355			$request = new Request(
356			$this->presenter,
357			$method,
358			$params,
359			$httpRequest->getPost(),
360			$httpRequest->getFiles(),
361			[Request::SECURED => $httpRequest->isSecured()]
362			);
363
364			/**
365			* Trigger event - route matches
366			*/
367			$this->onMatch($this, $request);
			0 ignored issues – show Documentation Bug introduced 2016-03-08 22:03 UTC by Report Bug Copy Issue Report The method `onMatch` does not exist on `object<Ublaboo\ApiRouter\ApiRoute>`? Since you implemented `__call`, maybe consider adding a @method annotation. If you implement `__call` and you know which methods are available, you can improve IDE auto-completion and static analysis by adding a @method annotation to the class. This is often the case, when `__call` is implemented by a parent class and only the child class knows which methods exist: class ParentClass { private $data = array(); public function __call($method, array $args) { if (0 === strpos($method, 'get')) { return $this->data[strtolower(substr($method, 3))]; } throw new \LogicException(sprintf('Unsupported method: %s', $method)); } } /** * If this class knows which fields exist, you can specify the methods here: * * @method string getName() */ class SomeClass extends ParentClass { } Loading history...
368
369			return $request;
370			}
371
372
373			/**
374			* Constructs absolute URL from Request object.
375			* @return string\|NULL
376			*/
377			public function constructUrl(Request $request, Nette\Http\Url $url)
378			{
379			if ($this->presenter != $request->getPresenterName()) {
380			return NULL;
381			}
382
383			$base_url = $url->getBaseUrl();
384
385			$action = $request->getParameter('action');
386			$parameters = $request->getParameters();
387			unset($parameters['action']);
388			$path = ltrim($this->getPath(), '/');
389
390			if (FALSE === array_search($action, $this->actions)) {
391			return NULL;
392			}
393
394			foreach ($parameters as $name => $value) {
395			if (strpos($path, "<{$name}>") !== FALSE && $value !== NULL) {
396			$path = str_replace("<{$name}>", $value, $path);
397
398			unset($parameters[$name]);
399			}
400			}
401
402			$path = preg_replace_callback('/\[.+?\]/', function($item) {
403			if (strpos(end($item), '<')) {
404			return '';
405			}
406
407			return end($item);
408			}, $path);
409
410			/**
411			* There are still some required parameters in url mask
412			*/
413			if (preg_match('/<\w+>/', $path)) {
414			return NULL;
415			}
416
417			$path = str_replace(['[', ']'], '', $path);
418
419			$query = http_build_query($parameters);
420
421			return $base_url . $path . ($query ? '?' . $query : '');
422			}
423
424			}
425

ublaboo / api-router

Push — master ( c6d651...f3cc34 )

ApiRoute::prepareForMatch() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like