Ubiquity\cache\parser\ControllerParser

Complexity

Total Complexity

46

Size/Duplication

Total Lines	173
Duplicated Lines	0 %

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
C	parse()	0	42	16
A	createRouteMethod()	0	3	2
A	isRest()	0	2	1
B	asArray()	0	28	8
A	generateRouteAnnotationFromMethod()	0	4	1
B	addParamsPath()	0	25	7
A	parseRouteArray()	0	21	6
A	scanParam()	0	17	5

<?php

namespace Ubiquity\cache\parser;

use Ubiquity\orm\parser\Reflexion;
use Ubiquity\utils\base\UString;
use Ubiquity\annotations\router\RouteAnnotation;
use Ubiquity\cache\ClassUtils;
use Ubiquity\utils\base\UArray;

/**
 * Scans a controller to detect routes defined by annotations 
 * @author jc
 * @version 1.0.1
 */
class ControllerParser {
	use ControllerParserPathTrait;
	
	private $controllerClass;
	private $mainRouteClass;
	private $routesMethods=[ ];
	private $rest=false;
	private static $excludeds=[ "__construct","isValid","initialize","finalize","onInvalidControl","loadView","forward","redirectToRoute" ];

	public function parse($controllerClass) {
		$automated=false;
		$inherited=false;
		$this->controllerClass=$controllerClass;
		$restAnnotsClass=[];$annotsClass=[];

The assignment to $annotsClass is dead and can be removed.

		$reflect=new \ReflectionClass($controllerClass);
		if (!$reflect->isAbstract() && $reflect->isSubclassOf("Ubiquity\controllers\Controller")) {
			$instance=new $controllerClass();
			try{
			$annotsClass=Reflexion::getAnnotationClass($controllerClass, "@route");
			$restAnnotsClass=Reflexion::getAnnotationClass($controllerClass, "@rest");
			}catch (\Exception $e){
				//When controllerClass generates an exception
			}
			$this->rest=\sizeof($restAnnotsClass) > 0;
			if (\sizeof($annotsClass) > 0) {
				$this->mainRouteClass=$annotsClass[0];
				$inherited=$this->mainRouteClass->inherited;
				$automated=$this->mainRouteClass->automated;
			}
			$methods=Reflexion::getMethods($instance, \ReflectionMethod::IS_PUBLIC);
			foreach ( $methods as $method ) {
				if ($method->getDeclaringClass()->getName() === $controllerClass || $inherited) {
					try{
						$annots=Reflexion::getAnnotationsMethod($controllerClass, $method->name, ["@route","@get","@post"]);
						if (sizeof($annots)>0) {
							foreach ( $annots as $annot ) {
								if (UString::isNull($annot->path)) {
									$newAnnot=$this->generateRouteAnnotationFromMethod($method);
									$annot->path=$newAnnot[0]->path;
								}else{
									$annot->path=$this->parseMethodPath($method, $annot->path);
								}
							}
							$this->routesMethods[$method->name]=[ "annotations" => $annots,"method" => $method ];
						} else {
							if ($automated) {
								if ($method->class !== 'Ubiquity\\controllers\\Controller' && \array_search($method->name, self::$excludeds) === false && !UString::startswith($method->name, "_"))
									$this->routesMethods[$method->name]=[ "annotations" => $this->generateRouteAnnotationFromMethod($method),"method" => $method ];
							}
						}
					}catch(\Exception $e){
						//When controllerClass generates an exception
					}
				}
			}
		}
	}

	private function generateRouteAnnotationFromMethod(\ReflectionMethod $method) {
		$annot=new RouteAnnotation();
		$annot->path=self::getPathFromMethod($method);
		return [ $annot ];
	}

	public function asArray() {
		$result=[ ];
		$prefix="";
		$httpMethods=false;
		if ($this->mainRouteClass) {
			if (isset($this->mainRouteClass->path))
				$prefix=$this->mainRouteClass->path;
			if (isset($this->mainRouteClass->methods)) {
				$httpMethods=$this->mainRouteClass->methods;
				if ($httpMethods !== null) {
					if (\is_string($httpMethods))
						$httpMethods=[ $httpMethods ];
				}
			}
		}
		foreach ( $this->routesMethods as $method => $arrayAnnotsMethod ) {
			$routeAnnotations=$arrayAnnotsMethod["annotations"];

			foreach ( $routeAnnotations as $routeAnnotation ) {
				$params=[ "path" => $routeAnnotation->path,"methods" => $routeAnnotation->methods,"name" => $routeAnnotation->name,"cache" => $routeAnnotation->cache,"duration" => $routeAnnotation->duration,"requirements" => $routeAnnotation->requirements,"priority"=>$routeAnnotation->priority ];
				self::parseRouteArray($result, $this->controllerClass, $params, $arrayAnnotsMethod["method"], $method, $prefix, $httpMethods);
			}
		}
		uasort($result, function ($item1, $item2) {
			return UArray::getRecursive($item2,"priority",0) <=> UArray::getRecursive($item1,"priority",0);
		});
		UArray::removeRecursive($result,"priority");
		return $result;
	}

	public static function parseRouteArray(&$result, $controllerClass, $routeArray, \ReflectionMethod $method, $methodName, $prefix="", $httpMethods=NULL) {
		if (!isset($routeArray["path"])) {
			$routeArray["path"]=self::getPathFromMethod($method);
		}
		$pathParameters=self::addParamsPath($routeArray["path"], $method, $routeArray["requirements"]);
		$name=$routeArray["name"];
		if (!isset($name)) {
			$name=UString::cleanAttribute(ClassUtils::getClassSimpleName($controllerClass) . "_" . $methodName);
		}
		$cache=$routeArray["cache"];
		$duration=$routeArray["duration"];
		$path=$pathParameters["path"];
		$parameters=$pathParameters["parameters"];
		$priority=$routeArray["priority"];
		$path=self::cleanpath($prefix, $path);
		if (isset($routeArray["methods"]) && \is_array($routeArray["methods"])) {
			self::createRouteMethod($result, $controllerClass, $path, $routeArray["methods"], $methodName, $parameters, $name, $cache, $duration,$priority);
		} elseif (\is_array($httpMethods)) {
			self::createRouteMethod($result, $controllerClass, $path, $httpMethods, $methodName, $parameters, $name, $cache, $duration,$priority);
		} else {
			$result[$path]=[ "controller" => $controllerClass,"action" => $methodName,"parameters" => $parameters,"name" => $name,"cache" => $cache,"duration" => $duration,"priority"=>$priority];
		}
	}

	public static function addParamsPath($path, \ReflectionMethod $method, $requirements) {
		$parameters=[ ];
		$hasOptional=false;
		preg_match_all('@\{(\.\.\.|\~)?(.+?)\}@s', $path, $matches);
		if (isset($matches[2]) && \sizeof($matches[2]) > 0) {
			$path=\preg_quote($path);
			$params=Reflexion::getMethodParameters($method);
			$index=0;
			foreach ( $matches[2] as $paramMatch ) {
				$find=\array_search($paramMatch, $params);
				if ($find !== false) {
					$requirement='.+?';
					if (isset($requirements[$paramMatch])) {
						$requirement=$requirements[$paramMatch];
					}
					self::scanParam($parameters, $hasOptional, $matches, $index, $paramMatch, $find, $path, $requirement);
				} else {
					throw new \Exception("{$paramMatch} is not a parameter of the method " . $method->name);
				}
				$index++;
			}
		}
		if ($hasOptional)
			$path.="/(.*?)";
		return [ "path" => $path,"parameters" => $parameters ];
	}

	private static function scanParam(&$parameters, &$hasOptional, $matches, $index, $paramMatch, $find, &$path, $requirement) {
		$toReplace=true;
		if (isset($matches[1][$index])) {
			if ($matches[1][$index] === "...") {
				$parameters[]="*";
				$path=\str_replace("\{\.\.\." . $paramMatch . "\}", "(.*?)", $path);
				$toReplace=false;
			} elseif ($matches[1][$index] === "~") {
				$parameters[]="~" . $find;
				$path=\str_replace("\{~" . $paramMatch . "\}", "", $path);
				$hasOptional=true;
				$toReplace=false;
			}
		} 
		if($toReplace) {
			$parameters[]=$find;
			$path=\str_replace("\{" . $paramMatch . "\}", "({$requirement})", $path);
		}
	}

	private static function createRouteMethod(&$result, $controllerClass, $path, $httpMethods, $method, $parameters, $name, $cache, $duration,$priority) {
		foreach ( $httpMethods as $httpMethod ) {
			$result[$path][$httpMethod]=[ "controller" => $controllerClass,"action" => $method,"parameters" => $parameters,"name" => $name,"cache" => $cache,"duration" => $duration,"priority"=>$priority ];
		}
	}

	public function isRest() {
		return $this->rest;
	}
}