{$router->__toString()}{$router->__toString()}{$router->toString()}{$string}$path$method: $pathMethod not allowed. Must be one of: $allow
$pathMethod not allowed for $method $path
The request method must be one of $allow
+ +HTML; + }; + } + + /** + * Defines callback on happen event + * + * @param string $event + * @param callable $handler + */ + public function on(string $event, $handler): void + { + if (self::isSupportedEvent($event)) { + $this->options[$event] = $handler; + } + } + + /** + * Trigger event + * + * @param string $event + * @param array $args + * + * @return mixed + * @throws InvalidArgumentException + */ + protected function fire(string $event, array $args = []): mixed + { + if (!$cb = $this->getOption($event)) { + return null; + } + + return RouteHelper::call($cb, $args); + } + + /** + * @param string $name + * @param mixed $value + */ + public function setOption(string $name, mixed $value): void + { + $this->options[$name] = $value; + } + + /** + * @param string $name + * @param mixed|null $default + * + * @return mixed + */ + public function getOption(string $name, mixed $default = null): mixed + { + return $this->options[$name] ?? $default; + } + + /** + * @return array + */ + public static function getSupportedEvents(): array + { + return [ + self::ON_FOUND, + self::ON_NOT_FOUND, + self::ON_METHOD_NOT_ALLOWED, + self::ON_EXEC_START, + self::ON_EXEC_END, + self::ON_EXEC_ERROR + ]; + } + + /** + * @param string $name + * + * @return bool + */ + public static function isSupportedEvent(string $name): bool + { + return in_array($name, static::getSupportedEvents(), true); + } + + /** + * @return bool + */ + public function hasRouter(): bool + { + return $this->router !== null; + } + + /** + * @return RouterInterface + */ + public function getRouter(): RouterInterface + { + return $this->router; + } + + /** + * @param RouterInterface $router + */ + public function setRouter(RouterInterface $router): void + { + $this->router = $router; + } + + /** + * @return array + */ + public function getOptions(): array + { + return $this->options; + } + + /** + * @param array $options + */ + public function setOptions(array $options): void + { + $this->options = array_merge($this->options, $options); + } +} diff --git a/src/DispatcherInterface.php b/src/DispatcherInterface.php deleted file mode 100644 index 787be41..0000000 --- a/src/DispatcherInterface.php +++ /dev/null @@ -1,44 +0,0 @@ - '/' + if (false !== strpos($path, '//')) { + $path = preg_replace('#\/\/+#', '/', $path); + } + + // Must be start withs '/' + if (strpos($path, '/') !== 0) { + $path = '/' . $path; + } + + // Decode + $path = rawurldecode($path); + + return $ignoreLastSlash ? rtrim($path, '/') : $path; + } + + /** + * convert 'first-second' to 'firstSecond' + * + * @param string $str + * @param bool $ucFirst + * + * @return string + */ + public static function str2Camel(string $str, bool $ucFirst = false): string + { + $str = trim($str, '-'); + + // convert 'first-second' to 'firstSecond' + if (strpos($str, '-')) { + $str = preg_replace_callback('/-+([a-z])/', static function ($c) { + return strtoupper($c[1]); + }, trim($str, '- ')); + } + + return $ucFirst ? ucfirst($str) : $str; + } + + /** + * handle auto route match, when config `'autoRoute' => true` + * + * @param string $path The route path + * @param string $cnp controller namespace. eg: 'app\\controllers' + * @param string $sfx controller suffix. eg: 'Controller' + * @param bool $ucFirst + * + * @return bool|string + */ + public static function parseAutoRoute(string $path, string $cnp, string $sfx, bool $ucFirst = false): bool|string + { + $tmp = trim($path, '/- '); + + // one node. eg: 'home' + if (!strpos($tmp, '/')) { + $tmp = self::str2Camel($tmp); + $class = "$cnp\\" . ucfirst($tmp) . $sfx; + + return class_exists($class) ? $class : false; + } + + $nodes = array_filter(explode('/', $tmp)); + + if ($ucFirst) { + foreach ($nodes as $i => $node) { + $nodes[$i] = self::str2Camel($nodes[$i], true); + } + } else { + $nodes = array_map(self::class . '::str2Camel', $nodes); + } + + $count = count($nodes); + + // two nodes. eg: 'home/test' 'admin/user' + if ($count === 2) { + [$n1, $n2] = $nodes; + + // last node is an controller class name. eg: 'admin/user' + $class = "$cnp\\$n1\\" . ucfirst($n2) . $sfx; + + if (class_exists($class)) { + return $class; + } + + // first node is an controller class name, second node is a action name, + $class = "$cnp\\" . ucfirst($n1) . $sfx; + + return class_exists($class) ? $class . '@' . lcfirst($n2) : false; + } + + // max allow 5 nodes + if ($count > 5) { + return false; + } + + // last node is an controller class name + $n2 = array_pop($nodes); + $class = sprintf('%s\\%s\\%s', $cnp, implode('\\', $nodes), ucfirst($n2) . $sfx); + + if (class_exists($class)) { + return $class; + } + + // last second is an controller class name, last node is a action name, + $n1 = array_pop($nodes); + $class = sprintf('%s\\%s\\%s', $cnp, implode('\\', $nodes), ucfirst($n1) . $sfx); + + return class_exists($class) ? $class . '@' . lcfirst($n2) : false; + } + + /** + * @param callable|mixed $cb + * string - func name, class name + * array - [class, method] + * object - Closure, Object + * + * @param array $args + * + * @return mixed + * @throws InvalidArgumentException + */ + public static function call($cb, array $args = []) + { + if (!$cb) { + return true; + } + + if (is_array($cb)) { + [$obj, $mhd] = $cb; + + return is_object($obj) ? $obj->$mhd(...$args) : $obj::$mhd(...$args); + } + + if (is_string($cb)) { + if (function_exists($cb)) { + return $cb(...$args); + } + + // a class name + if (class_exists($cb)) { + $cb = new $cb; + } + } + + // a \Closure or Object implement '__invoke' + if (is_object($cb) && method_exists($cb, '__invoke')) { + return $cb(...$args); + } + + throw new InvalidArgumentException('the callback handler is not callable!'); + } +} diff --git a/src/Helper/functions.php b/src/Helper/functions.php new file mode 100644 index 0000000..d9d3970 --- /dev/null +++ b/src/Helper/functions.php @@ -0,0 +1,73 @@ +completed(); + + return $router; +} + +/** + * @param Closure $closure + * @param string $path + * @param string $method + * @param array $config + * + * @return PreMatchRouter + */ +function createPreMatchRouter( + Closure $closure, + string $path = '', + string $method = '', + array $config = [] +): PreMatchRouter { + $router = new PreMatchRouter($config, $path, $method); + + $closure($router); + + return $router; +} + +/** + * @param Closure $closure + * @param array $config + * + * @return ServerRouter + */ +function createServerRouter(Closure $closure, array $config = []): ServerRouter +{ + $closure($router = new ServerRouter($config)); + + return $router; +} diff --git a/src/ORouter.php b/src/ORouter.php deleted file mode 100644 index b120cfb..0000000 --- a/src/ORouter.php +++ /dev/null @@ -1,608 +0,0 @@ - [ 'localhost' ], // allowed domains - // 'schemas' => [ 'http' ], // allowed schemas - // 'time' => ['12'], - ]; - - /** @var string */ - private $currentGroupPrefix; - - /** @var array */ - private $currentGroupOption; - - /** @var bool */ - private $initialized = false; - - /** - * static Routes - no dynamic argument match - * 整个路由 path 都是静态字符串 e.g. '/user/login' - * @var array[] - * [ - * '/user/login' => [ - * // METHODS => [...] // 这里 key 和 value里的 'methods' 是一样的。仅是为了防止重复添加 - * 'GET,POST' => [ - * 'handler' => 'handler', - * 'methods' => 'GET,POST', - * 'option' => [...], - * ], - * 'PUT' => [ - * 'handler' => 'handler', - * 'methods' => 'PUT', - * 'option' => [...], - * ], - * ... - * ] - * ] - */ - private $staticRoutes = []; - - /** - * regular Routes - have dynamic arguments, but the first node is normal string. - * 第一节是个静态字符串，称之为有规律的动态路由。按第一节的信息进行分组存储 - * e.g '/hello[/{name}]' '/user/{id}' - * @var array[] - * [ - * // 使用完整的第一节作为key进行分组 - * 'a' => [ - * [ - * 'start' => '/a/', - * 'regex' => '/a/(\w+)', - * 'methods' => 'GET,POST', - * 'handler' => 'handler', - * 'option' => [...], - * ], - * ... ... - * ], - * 'add' => [ - * [ - * 'start' => '/add/', - * 'regex' => '/add/(\w+)', - * 'methods' => 'GET', - * 'handler' => 'handler', - * 'option' => [...], - * ], - * ... ... - * ], - * 'blog' => [ - * [ - * 'start' => '/blog/post-', - * 'regex' => '/blog/post-(\w+)', - * 'methods' => 'GET', - * 'handler' => 'handler', - * 'option' => [...], - * ], - * ... ... - * ], - * ] - */ - private $regularRoutes = []; - - /** - * vague Routes - have dynamic arguments,but the first node is exists regex. - * 第一节就包含了正则匹配，称之为无规律/模糊的动态路由 - * e.g '/{name}/profile' '/{some}/{some2}' - * @var array - * [ - * [ - * // 必定包含的字符串 - * 'include' => '/profile', - * 'regex' => '/(\w+)/profile', - * 'methods' => 'GET', - * 'handler' => 'handler', - * 'option' => [...], - * ], - * [ - * 'include' => null, - * 'regex' => '/(\w+)/(\w+)', - * 'methods' => 'GET,POST', - * 'handler' => 'handler', - * 'option' => [...], - * ], - * ... ... - * ] - */ - private $vagueRoutes = []; - - /** - * There are last route caches - * @see $staticRoutes - * @var array[] - */ - private $routeCaches = []; - - /** - * some setting for self - * @var array - */ - protected $config = [ - // the routes php file. - 'routesFile' => '', - - // ignore last '/' char. If is True, will clear last '/'. - 'ignoreLastSep' => false, - - // 'tmpCacheNumber' => 100, - 'tmpCacheNumber' => 0, - - // match all request. - // 1. If is a valid URI path, will matchAll all request uri to the path. - // 2. If is a closure, will matchAll all request then call it - // eg: '/site/maintenance' or `function () { echo 'System Maintaining ... ...'; }` - 'matchAll' => false, - - // auto route match @like yii framework - // If is True, will auto find the handler controller file. - 'autoRoute' => false, - // The default controllers namespace, is valid when `'enable' = true` - 'controllerNamespace' => '', // eg: 'app\\controllers' - // controller suffix, is valid when `'enable' = true` - 'controllerSuffix' => '', // eg: 'Controller' - ]; - - /** @var DispatcherInterface */ - private $dispatcher; - - /** - * object creator. - * @param array $config - * @return self - * @throws \LogicException - */ - public static function make(array $config = []) - { - return new static($config); - } - - /** - * object constructor. - * @param array $config - * @throws \LogicException - */ - public function __construct(array $config = []) - { - $this->setConfig($config); - - $this->currentGroupPrefix = ''; - $this->currentGroupOption = []; - - // load routes - if (($file = $this->config['routesFile']) && is_file($file)) { - require $file; - } - } - - /** - * @param array $config - * @throws \LogicException - */ - public function setConfig(array $config) - { - if ($this->initialized) { - throw new \LogicException('Routing has been added, and configuration is not allowed!'); - } - - foreach ($config as $name => $value) { - if (isset($this->config[$name])) { - $this->config[$name] = $value; - } - } - } - - /******************************************************************************* - * route collection - ******************************************************************************/ - - /** - * Defines a route callback and method - * @param string $method - * @param array $args - * @return ORouter - * @throws \LogicException - * @throws \InvalidArgumentException - */ - public function __call($method, array $args) - { - if (\count($args) < 2) { - throw new \InvalidArgumentException("The method [$method] parameters is missing."); - } - - return $this->map($method, $args[0], $args[1], isset($args[2]) ? $args[2] : []); - } - - /** - * Create a route group with a common prefix. - * All routes created in the passed callback will have the given group prefix prepended. - * @ref package 'nikic/fast-route' - * @param string $prefix - * @param \Closure $callback - * @param array $opts - */ - public function group($prefix, \Closure $callback, array $opts = []) - { - $previousGroupPrefix = $this->currentGroupPrefix; - $this->currentGroupPrefix = $previousGroupPrefix . '/' . trim($prefix, '/'); - - $previousGroupOption = $this->currentGroupOption; - $this->currentGroupOption = $opts; - - $callback($this); - - $this->currentGroupPrefix = $previousGroupPrefix; - $this->currentGroupOption = $previousGroupOption; - } - - /** - * @param string|array $methods The match request method(s). - * e.g - * string: 'get' - * array: ['get','post'] - * @param string $route The route path string. is allow empty string. eg: '/user/login' - * @param callable|string $handler - * @param array $opts some option data - * [ - * 'params' => [ 'id' => '[0-9]+', ], - * 'defaults' => [ 'id' => 10, ], - * 'domains' => [ 'a-domain.com', '*.b-domain.com'], - * 'schemas' => ['https'], - * ] - * @return static - * @throws \LogicException - * @throws \InvalidArgumentException - */ - public function map($methods, $route, $handler, array $opts = []) - { - if (!$this->initialized) { - $this->initialized = true; - } - - $hasPrefix = (bool)$this->currentGroupPrefix; - // validate and format arguments - $methods = static::validateArguments($methods, $handler); - - if ($route = trim($route)) { - // always add '/' prefix. - $route = $route{0} === '/' ? $route : '/' . $route; - } elseif (!$hasPrefix) { - $route = '/'; - } - - $route = $this->currentGroupPrefix . $route; - - // setting 'ignoreLastSep' - if ($route !== '/' && $this->config['ignoreLastSep']) { - $route = rtrim($route, '/'); - } - - $this->routeCounter++; - $opts = array_replace([ - 'params' => null, - // 'domains' => null, - ], $this->currentGroupOption, $opts); - $conf = [ - 'methods' => $methods, - 'handler' => $handler, - 'option' => $opts, - ]; - - // no dynamic param params - if (self::isNoDynamicParam($route)) { - $this->staticRoutes[$route][$methods] = $conf; - - return $this; - } - - // have dynamic param params - - // replace param name To pattern regex - $params = static::getAvailableParams(self::$globalParams, $opts['params']); - list($first, $conf) = static::parseParamRoute($route, $params, $conf); - - // route string have regular - if ($first) { - $this->regularRoutes[$first][] = $conf; - } else { - $this->vagueRoutes[] = $conf; - } - - return $this; - } - - /******************************************************************************* - * route match - ******************************************************************************/ - - /** - * find the matched route info for the given request uri path - * @param string $method - * @param string $path - * @return array - */ - public function match($path, $method = self::GET) - { - // if enable 'matchAll' - if ($matchAll = $this->config['matchAll']) { - if (\is_string($matchAll) && $matchAll{0} === '/') { - $path = $matchAll; - } elseif (\is_callable($matchAll)) { - return [self::FOUND, $path, [ - 'handler' => $matchAll, - 'option' => [], - ]]; - } - } - - // clear '//', '///' => '/' - $path = rawurldecode(preg_replace('#\/\/+#', '/', $path)); - $method = strtoupper($method); - - // setting 'ignoreLastSep' - if ($path !== '/' && $this->config['ignoreLastSep']) { - $path = rtrim($path, '/'); - } - - // find in route caches. - if ($this->routeCaches && isset($this->routeCaches[$path])) { - return self::findInStaticRoutes($this->routeCaches[$path], $path, $method); - } - - // is a static route path - if ($this->staticRoutes && isset($this->staticRoutes[$path])) { - return self::findInStaticRoutes($this->staticRoutes[$path], $path, $method); - } - - $first = self::getFirstFromPath($path); - - // is a regular dynamic route(the first node is 1th level index key). - if (isset($this->regularRoutes[$first])) { - foreach ($this->regularRoutes[$first] as $conf) { - if (0 === strpos($path, $conf['start']) && preg_match($conf['regex'], $path, $matches)) { - $conf['matches'] = $matches; - - return $this->checkMatched($path, $method, $conf); - } - } - } - - // is a irregular dynamic route - foreach ($this->vagueRoutes as $conf) { - if ($conf['include'] && false === strpos($path, $conf['include'])) { - continue; - } - - if (preg_match($conf['regex'], $path, $matches)) { - $conf['matches'] = $matches; - - return $this->checkMatched($path, $method, $conf); - } - } - - // handle Auto Route - if ( - $this->config['autoRoute'] && - ($handler = self::matchAutoRoute($path, $this->config['controllerNamespace'], $this->config['controllerSuffix'])) - ) { - return [self::FOUND, $path, [ - 'handler' => $handler, - 'option' => [], - ]]; - } - - // oo ... not found - return [self::NOT_FOUND, $path, null]; - } - - /******************************************************************************* - * route callback handler dispatch - ******************************************************************************/ - - /** - * Runs the callback for the given request - * @param DispatcherInterface|array $dispatcher - * @param null|string $path - * @param null|string $method - * @return mixed - * @throws \Throwable - */ - public function dispatch($dispatcher = null, $path = null, $method = null) - { - if ($dispatcher) { - if ($dispatcher instanceof DispatcherInterface) { - $this->dispatcher = $dispatcher; - } elseif (\is_array($dispatcher)) { - $this->dispatcher = new Dispatcher($dispatcher); - } - } - - if (!$this->dispatcher) { - $this->dispatcher = new Dispatcher; - } - - return $this->dispatcher->setMatcher(function ($p, $m) { - return $this->match($p, $m); - })->dispatch($path, $method); - } - - /******************************************************************************* - * helper methods - ******************************************************************************/ - - /** - * checkMatched - * @param string $path - * @param string $method - * @param array $conf - * @return array - */ - protected function checkMatched($path, $method, array $conf) - { - $methods = $conf['methods']; - $cacheNumber = (int)$this->config['tmpCacheNumber']; - - // method not allowed - if (false === strpos($methods . ',', $method . ',')) { - return [self::METHOD_NOT_ALLOWED, $path, explode(',', $methods)]; - } - - $conf['matches'] = self::filterMatches($conf['matches'], $conf); - - // cache last $cacheNumber routes. - if ($cacheNumber > 0) { - if ($this->cacheCounter === $cacheNumber) { - array_shift($this->routeCaches); - } - - if (!isset($this->routeCaches[$path][$methods])) { - $this->cacheCounter++; - $this->routeCaches[$path][$methods] = $conf; - } - } - - return [self::FOUND, $path, $conf]; - } - - /** - * @return int - */ - public function count() - { - return $this->routeCounter; - } - - /** - * @param array $staticRoutes - */ - public function setStaticRoutes(array $staticRoutes) - { - $this->staticRoutes = $staticRoutes; - } - - /** - * @return array - */ - public function getStaticRoutes() - { - return $this->staticRoutes; - } - - /** - * @param \array[] $regularRoutes - */ - public function setRegularRoutes(array $regularRoutes) - { - $this->regularRoutes = $regularRoutes; - } - - /** - * @return \array[] - */ - public function getRegularRoutes() - { - return $this->regularRoutes; - } - - /** - * @param array $vagueRoutes - */ - public function setVagueRoutes($vagueRoutes) - { - $this->vagueRoutes = $vagueRoutes; - } - - /** - * @return array - */ - public function getVagueRoutes() - { - return $this->vagueRoutes; - } - - /** - * @return array - */ - public function getRouteCaches() - { - return $this->routeCaches; - } - - /** - * @param null|string $name - * @param null|mixed $default - * @return array|string - */ - public function getConfig($name = null, $default = null) - { - if ($name) { - return isset($this->config[$name]) ? $this->config[$name] : $default; - } - - return $this->config; - } - - /** - * @return DispatcherInterface - */ - public function getDispatcher() - { - return $this->dispatcher; - } - - /** - * @param DispatcherInterface $dispatcher - * @return $this - */ - public function setDispatcher(DispatcherInterface $dispatcher) - { - $this->dispatcher = $dispatcher; - - return $this; - } - - /** - * @return array - */ - public function getGlobalOptions(): array - { - return $this->globalOptions; - } - - /** - * @param array $globalOptions - * @return $this - */ - public function setGlobalOptions(array $globalOptions) - { - $this->globalOptions = $globalOptions; - - return $this; - } -} diff --git a/src/PreMatchRouter.php b/src/PreMatchRouter.php new file mode 100644 index 0000000..74fcfb0 --- /dev/null +++ b/src/PreMatchRouter.php @@ -0,0 +1,133 @@ +setRequest($path, $method); + } + + /** + * @param string $path + * @param string $method + */ + public function setRequest(string $path = '', string $method = ''): void + { + if (!$path) { + $path = $_SERVER['REQUEST_URI'] ?? ''; + } + + if (strpos($path, '?')) { + $path = (string)parse_url(http://github.com/$path,%20PHP_URL_PATH); + } + + $this->reqPath = RouteHelper::formatPath($path, $this->ignoreLastSlash); + $this->reqMethod = $method ? strtoupper($method) : $_SERVER['REQUEST_METHOD']; + } + + /** + * @param Route $route + * + * @return Route + */ + public function addRoute(Route $route): Route + { + // Has been matched. don't add again. + if ($this->preFounded) { + return $route; + } + + $path = $route->getPath(); + $method = $route->getMethod(); + + $this->routeCounter++; + + // Success match + if ($path === $this->reqPath && $method === $this->reqMethod) { + $this->preFounded = $route; + return $route; + } + + return parent::addRoute($route); + } + + /** + * {@inheritdoc} + */ + public function match(string $path, string $method = 'GET'): array + { + // If has been pre-matched. + if ($this->preFounded) { + return [self::FOUND, $path, $this->preFounded]; + } + + return parent::match($path, $method); + } + + /** + * @return Route|null + */ + public function getPreFounded(): ?Route + { + return $this->preFounded; + } + + /** + * @return string + */ + public function getReqPath(): string + { + return $this->reqPath; + } +} diff --git a/src/Route.php b/src/Route.php new file mode 100644 index 0000000..25636ce --- /dev/null +++ b/src/Route.php @@ -0,0 +1,653 @@ + regular expression path (or symbol name)] + * @var string[] + */ + private array $bindVars; + + /** + * dynamic route param values, only use for route cache + * [param name => value] + * @var string[] + */ + private array $params = []; + + // -- match condition. it is parsed from route path string. + + /** + * path var names. + * @var array '/users/{id}' => ['id'] + */ + private array $pathVars = []; + + /** + * @var string eg. '#^/users/(\d+)$#' + */ + private string $pathRegex = ''; + + /** + * '/users/{id}' -> '/users/' + * '/blog/post-{id}' -> '/blog/post-' + * @var string + */ + private string $pathStart = ''; + + // -- extra properties + + /** + * middleware handler chains + * @var callable[] + */ + private array $chains = []; + + /** + * some custom route options data. + * @var array + */ + private array $options; + + /** + * @param string $method + * @param string $path + * @param mixed $handler + * @param array $pathParams + * @param array $options + * + * @return Route + */ + public static function create( + string $method, + string $path, + mixed $handler, + array $pathParams = [], + array $options = [] + ): Route { + return new self($method, $path, $handler, $pathParams, $options); + } + + /** + * @param array $config + * + * @return Route + */ + public static function createFromArray(array $config = []): self + { + $route = new self('GET', '/', ''); + + foreach ($config as $property => $value) { + if (property_exists($route, $property)) { + $route->$property = $value; + } + } + + return $route; + } + + /** + * Route constructor. + * + * @param string $method + * @param string $path + * @param mixed $handler + * @param array $pathParams + * @param array $options + */ + public function __construct(string $method, string $path, mixed $handler, array $pathParams = [], array $options = []) + { + $this->initialize($method, $path, $handler, $pathParams, $options); + } + + public function initialize( + string $method, + string $path, + $handler, + array $pathParams = [], + array $options = [] + ): self { + $this->path = trim($path); + $this->method = strtoupper($method); + $this->bindVars = $pathParams; + $this->handler = $handler; + $this->options = $options; + + if (isset($options['name'])) { + $this->setName($options['name']); + } + + return $this; + } + + /** + * register route to the router + * + * @param Router $router + * + * @return Route + */ + public function attachTo(Router $router): self + { + $router->addRoute($this); + return $this; + } + + /** + * name the route and bind name to router. + * + * @param string $name + * @param Router $router + * @param bool $register + */ + public function namedTo(string $name, Router $router, bool $register = false): void + { + // not empty + if ($name = $this->setName($name)->name) { + if ($register) { + $router->addRoute($this); + } else { + $router->nameRoute($name, $this); + } + } + } + + /******************************************************************************* + * parse route path + ******************************************************************************/ + + /** + * parse route path string. fetch route params + * + * @param array $bindParams + * + * @return string returns the first node string. + */ + public function parseParam(array $bindParams = []): string + { + $argPos = strpos($this->path, '{'); + $optPos = strpos($this->path, '['); + + return $this->quickParseParams($argPos, $optPos, $bindParams); + } + + /** + * @param int|false $argPos + * @param int|false $optPos + * @param array $bindParams + * + * @return string + */ + public function quickParseParams($argPos, $optPos, array $bindParams = []): string + { + $first = $start = ''; + $path = $this->path; + + // regular: first node is a normal string e.g '/user/{id}' -> 'user', '/a/{post}' -> 'a' + if (preg_match('#^/([\w-]+)/(?:[\w\/-]*)#', $path, $m)) { + [$start, $first] = $m; + $this->pathStart = $start === '/' ? '' : $start; + } + + // quote '.','/' to '\.','\/' + if (false !== strpos($path, '.')) { + $path = str_replace('.', '\.', $path); + } + + // Parse the optional parameters + if (false !== $optPos) { + $noClosingOptionals = rtrim($path, ']'); + $optionalNum = strlen($path) - strlen($noClosingOptionals); + if ($optionalNum !== substr_count($noClosingOptionals, '[')) { + throw new LogicException('Optional segments can only occur at the end of a route'); + } + + // '/hello[/{name}]' -> '/hello(?:/{name})?' + $path = str_replace(['[', ']'], ['(?:', ')?'], $path); + // No params + if ($argPos === false) { + $this->pathRegex = '#^' . $path . '$#'; + return $first; + } + } + + if ($bindVars = $this->getBindVars()) { // merge current route vars + $bindParams = array_merge($bindParams, $bindVars); + } + + // Parse the parameters and replace them with the corresponding regular + $path = preg_replace_callback('#\{([a-zA-Z_][\w-]*)\}#', function ($m) use ($bindParams) { + $this->pathVars[] = $m[1]; + + $regex = $bindParams[$m[1]] ?? Router::DEFAULT_REGEX; + return '(' . $regex . ')'; + }, $path); + + $this->pathRegex = '#^' . $path . '$#'; + return $first; + } + + /******************************************************************************* + * route match + ******************************************************************************/ + + /** + * @param string $path + * + * @return array returns match result. has two elements. + * [ + * match ok?, + * route params values + * ] + */ + public function match(string $path): array + { + // Check start string + if ($this->pathStart !== '' && strpos($path, $this->pathStart) !== 0) { + return [false,]; + } + + return $this->matchRegex($path); + } + + /** + * @param string $path + * + * @return array + * [ + * match ok?, + * route params values + * ] + */ + public function matchRegex(string $path): array + { + // If don't match + if (!preg_match($this->pathRegex, $path, $matches)) { + return [false,]; + } + + // No params. eg: only use optional. '/about[.html]' + if (count($this->pathVars) === 0) { + return [true, []]; + } + + $params = []; + + // First is full match. + array_shift($matches); + foreach ($matches as $index => $value) { + $params[$this->pathVars[$index]] = $value; + } + + // If has default values + if (isset($this->options['defaults'])) { + $params = array_merge($this->options['defaults'], $params); + } + + return [true, $params]; + } + + /******************************************************************************* + * helper methods + ******************************************************************************/ + + /** + * @param array $params + * + * @return Route + */ + public function copyWithParams(array $params): self + { + $route = clone $this; + $route->params = $params; + + return $route; + } + + /** + * push middleware(s) to the route + * + * @param array ...$middleware + * + * @return Route + */ + public function middleware(...$middleware): self + { + foreach ($middleware as $handler) { + $this->chains[] = $handler; + } + + return $this; + } + + /** + * alias of the method: middleware() + * + * @param mixed ...$middleware + * + * @return Route + * @see middleware() + */ + public function push(...$middleware): self + { + return $this->middleware(...$middleware); + } + + /** + * replace set chains. + * + * @param callable[] $chains + */ + public function setChains(array $chains): void + { + $this->chains = $chains; + } + + /** + * build uri string. + * + * @param array $pathVars + * + * @return string + */ + public function toUri(array $pathVars = []): string + { + if ($pathVars) { + return strtr($this->path, $pathVars); + } + + return $this->path; + } + + /** + * get basic info data + * @return array + */ + public function info(): array + { + return [ + 'path' => $this->path, + 'method' => $this->method, + 'handlerName' => $this->getHandlerName(), + ]; + } + + /** + * get all info data + * @return array + */ + public function toArray(): array + { + return [ + 'name' => $this->name, + 'path' => $this->path, + 'method' => $this->method, + 'handler' => $this->handler, + 'binds' => $this->bindVars, + 'params' => $this->params, + 'options' => $this->options, + // + 'pathVars' => $this->pathVars, + 'pathStart' => $this->pathStart, + 'pathRegex' => $this->pathRegex, + // + 'chains' => $this->chains, + ]; + } + + /** + * @return string + */ + public function __toString(): string + { + return $this->toString(); + } + + /** + * @return string + */ + public function toString(): string + { + return sprintf( + '%-7s %-25s --> %s (%d middleware)', + $this->method, + $this->path, + $this->getHandlerName(), + count($this->chains) + ); + } + + /** + * @param string $name + * + * @return Route + */ + public function setName(string $name): self + { + if ($name = trim($name)) { + $this->name = $name; + } + + return $this; + } + + /** + * @param string $path + */ + public function setPath(string $path): void + { + $this->path = trim($path); + } + + /** + * @param string $name + * @param $value + * + * @return Route + */ + public function addOption(string $name, $value): self + { + $this->options[$name] = $value; + return $this; + } + + /** + * @param array $options + * + * @return Route + */ + public function setOptions(array $options): self + { + $this->options = $options; + return $this; + } + + /******************************************************************************* + * getter methods + ******************************************************************************/ + + /** + * Retrieve an external iterator + * @link https://php.net/manual/en/iteratoraggregate.getiterator.php + * @return Traversable An instance of an object implementing Iterator or Traversable + * @since 5.0.0 + */ + public function getIterator(): Traversable + { + return new ArrayIterator($this->toArray()); + } + + /** + * @return string + */ + public function getPath(): string + { + return $this->path; + } + + /** + * @return mixed + */ + public function getHandler() + { + return $this->handler; + } + + /** + * @return string[] + */ + public function getParams(): array + { + return $this->params; + } + + /** + * @param string $name + * @param null|mixed $default + * + * @return string|mixed + */ + public function getParam(string $name, $default = null) + { + return $this->params[$name] ?? $default; + } + + /** + * @return array + */ + public function getOptions(): array + { + return $this->options; + } + + /** + * @return string[] + */ + public function getBindVars(): array + { + return $this->bindVars; + } + + /** + * @return string + */ + public function getMethod(): string + { + return $this->method; + } + + /** + * @return array + */ + public function getPathVars(): array + { + return $this->pathVars; + } + + /** + * @return string + */ + public function getPathRegex(): string + { + return $this->pathRegex; + } + + /** + * @return string + */ + public function getPathStart(): string + { + return $this->pathStart; + } + + /** + * @return array + */ + public function getChains(): array + { + return $this->chains; + } + + /** + * @return string + */ + public function getName(): string + { + return $this->name; + } + + /** + * @return string + */ + public function getHandlerName(): string + { + $handlerName = 'unknown'; + + if (is_object($this->handler)) { + $handlerName = get_class($this->handler); + } elseif (is_array($this->handler)) { + $handlerName = '[array callback]'; + } elseif (is_string($this->handler)) { + $handlerName = $this->handler; + } + + return $handlerName; + } +} diff --git a/src/Router.php b/src/Router.php new file mode 100644 index 0000000..2371417 --- /dev/null +++ b/src/Router.php @@ -0,0 +1,824 @@ + Route] + */ + protected array $namedRoutes = []; + + /** + * static Routes - no dynamic argument match + * 整个路由 path 都是静态字符串 e.g. '/user/login' + * + * @var Route[] + * [ + * 'GET /user/login' => Route, + * 'POST /user/login' => Route, + * ] + */ + protected array $staticRoutes = []; + + /** + * regular Routes - have dynamic arguments, but the first node is normal string. + * 第一节是个静态字符串，称之为有规律的动态路由。按第一节的信息进行分组存储 + * + * @var Route[][] + * [ + * // 使用完整的第一节作为key进行分组 + * 'edit' => [ + * Route, // '/edit/{id}' + * ], + * 'blog' => [ + * Route, // '/blog/post-{id}' + * ], + * ] + */ + protected array $regularRoutes = []; + + /** + * vague Routes - have dynamic arguments,but the first node is exists regex. + * 第一节就包含了正则匹配，称之为无规律/模糊的动态路由 + * + * @var Route[][] + * [ + * // 使用 HTTP METHOD 作为 key进行分组 + * 'GET' => [ + * Route, // '/{name}/profile' + * ... + * ], + * 'POST' => [ + * Route, // '/{some}/{some2}' + * ... + * ], + * ] + */ + protected array $vagueRoutes = []; + + /** + * object creator. + * + * @param array $config + * + * @return self + * @throws LogicException + */ + public static function create(array $config = []): Router + { + return new static($config); + } + + /** + * object constructor. + * + * @param array $config = [ + * 'name' => 'my-router', + * 'chains' => [], + * // 'defaultRoute' => '', + * 'ignoreLastSlash' => false, + * 'tmpCacheNumber' => 100, + * 'handleMethodNotAllowed' => false, + * 'autoRoute' => false, + * 'controllerNamespace' => '', + * 'controllerSuffix' => 'Controller', + * ]; + * + * @throws LogicException + */ + public function __construct(array $config = []) + { + $this->config($config); + $this->basicRoute = new Route('GET', '/', null); + + $this->currentGroupPrefix = ''; + $this->currentGroupOption = []; + } + + /******************************************************************************* + * router middleware + ******************************************************************************/ + + /** + * alias of the method: middleware() + * + * @param array ...$middleware + * + * @return self + */ + public function use(...$middleware): Router + { + return $this->middleware(...$middleware); + } + + /** + * push middleware(s) for the route + * + * @param mixed ...$middleware + * + * @return Router + */ + public function middleware(...$middleware): Router + { + foreach ($middleware as $handler) { + $this->chains[] = $handler; + } + + return $this; + } + + /******************************************************************************* + * route register + ******************************************************************************/ + + /** + * register a route, allow GET request method. + * + * @param string $path + * @param mixed $handler + * @param array $pathParams + * @param array $opts + * + * @return Route + */ + public function get(string $path, mixed $handler, array $pathParams = [], array $opts = []): Route + { + return $this->add('GET', $path, $handler, $pathParams, $opts); + // return $this->map(['GET', 'HEAD'], $path, $handler, $pathParams, $opts); + } + + /** + * register a route, allow POST request method. + * + * @param string $path + * @param mixed $handler + * @param array $pathParams + * @param array $opts + * + * @return Route + */ + public function post(string $path, mixed $handler, array $pathParams = [], array $opts = []): Route + { + return $this->add('POST', $path, $handler, $pathParams, $opts); + } + + /** + * register a route, allow PUT request method. + * + * @param string $path + * @param mixed $handler + * @param array $pathParams + * @param array $opts + * + * @return Route + */ + public function put(string $path, mixed $handler, array $pathParams = [], array $opts = []): Route + { + return $this->add('PUT', $path, $handler, $pathParams, $opts); + } + + /** + * register a route, allow PATCH request method. + * + * @param string $path + * @param mixed $handler + * @param array $pathParams + * @param array $opts + * + * @return Route + */ + public function patch(string $path, mixed $handler, array $pathParams = [], array $opts = []): Route + { + return $this->add('PATCH', $path, $handler, $pathParams, $opts); + } + + /** + * register a route, allow DELETE request method. + * + * @param string $path + * @param mixed $handler + * @param array $pathParams + * @param array $opts + * + * @return Route + */ + public function delete(string $path, mixed $handler, array $pathParams = [], array $opts = []): Route + { + return $this->add('DELETE', $path, $handler, $pathParams, $opts); + } + + /** + * register a route, allow HEAD request method. + * + * @param string $path + * @param mixed $handler + * @param array $pathParams + * @param array $opts + * + * @return Route + */ + public function head(string $path, mixed $handler, array $pathParams = [], array $opts = []): Route + { + return $this->add('HEAD', $path, $handler, $pathParams, $opts); + } + + /** + * register a route, allow OPTIONS request method. + * + * @param string $path + * @param mixed $handler + * @param array $pathParams + * @param array $opts + * + * @return Route + */ + public function options(string $path, mixed $handler, array $pathParams = [], array $opts = []): Route + { + return $this->add('OPTIONS', $path, $handler, $pathParams, $opts); + } + + /** + * register a route, allow CONNECT request method. + * + * @param string $path + * @param mixed $handler + * @param array $pathParams + * @param array $opts + * + * @return Route + */ + public function connect(string $path, mixed $handler, array $pathParams = [], array $opts = []): Route + { + return $this->add('CONNECT', $path, $handler, $pathParams, $opts); + } + + /** + * register a route, allow any request METHOD. + * + * @param string $path + * @param mixed $handler + * @param array $pathParams + * @param array $opts + */ + public function any(string $path, mixed $handler, array $pathParams = [], array $opts = []): void + { + $this->map(self::METHODS_ARRAY, $path, $handler, $pathParams, $opts); + } + + /** + * @param array|string $methods + * @param string $path + * @param callable|string $handler + * @param array $pathParams + * @param array $opts + */ + public function map($methods, string $path, mixed $handler, array $pathParams = [], array $opts = []): void + { + foreach ((array)$methods as $method) { + $this->add($method, $path, $handler, $pathParams, $opts); + } + } + + /** + * @param string $method + * @param string $path + * @param mixed $handler + * @param array $pathParams + * @param array $opts + * + * @return Route + */ + public function add(string $method, string $path, mixed $handler, array $pathParams = [], array $opts = []): Route + { + if (!$method || !$handler) { + throw new InvalidArgumentException('The method and route handler is not allow empty.'); + } + + $route = $this->cloneRoute(); + $method = strtoupper($method); + if ($method === 'ANY') { + $this->any($path, $handler, $pathParams, $opts); + return $route; // Only use for return type + } + + if (!str_contains(self::METHODS_STRING, ',' . $method . ',')) { + throw new InvalidArgumentException( + "The method [$method] is not supported, Allow: " . trim(self::METHODS_STRING, ',') + ); + } + + // Initialize Route + $route->initialize($method, $path, $handler, $pathParams, $opts); + + return $this->addRoute($route); + } + + /** + * @param Route $route + * + * @return Route + */ + public function addRoute(Route $route): Route + { + $this->routeCounter++; + $this->appendGroupInfo($route); + + $path = $route->getPath(); + $method = $route->getMethod(); + if ($name = $route->getName()) { + $this->namedRoutes[$name] = $route; + } + + // It is static route + $argPos = strpos($path, '{'); + $optPos = strpos($path, '['); + if ($argPos === false && $optPos === false) { + $this->staticRoutes[$method . ' ' . $path] = $route; + return $route; + } + + // Parse param route + // - If the first node is static string. + $globalParams = self::$globalParams; + if ($first = $route->quickParseParams($argPos, $optPos, $globalParams)) { + $this->regularRoutes[$method . ' ' . $first][] = $route; + } else { + $this->vagueRoutes[$method][] = $route; + } + + return $route; + } + + /** + * Create a route group with a common prefix. + * All routes created in the passed callback will have the given group prefix prepended. + * + * @param string $prefix + * @param Closure $callback + * @param array $middleware + * @param array $opts + */ + public function group(string $prefix, Closure $callback, array $middleware = [], array $opts = []): void + { + // Backups + $previousGroupPrefix = $this->currentGroupPrefix; + $previousGroupOption = $this->currentGroupOption; + $previousGroupChains = $this->currentGroupChains; + + $this->currentGroupOption = $opts; + $this->currentGroupChains = $middleware; + $this->currentGroupPrefix = $previousGroupPrefix . '/' . trim($prefix, '/'); + + // Run callback. + $callback($this); + + // Reverts + $this->currentGroupPrefix = $previousGroupPrefix; + $this->currentGroupOption = $previousGroupOption; + $this->currentGroupChains = $previousGroupChains; + } + + /** + * prepare for add + * + * @param Route $route + * + * @return void + */ + protected function appendGroupInfo(Route $route): void + { + $path = $bak = $route->getPath(); + + // Always add '/' prefix. + $path = str_starts_with($path, '/') ? $path : '/' . $path; + $path = $this->currentGroupPrefix . $path; + + // Has setting 'ignoreLastSlash' + if ($path !== '/' && $this->ignoreLastSlash) { + $path = rtrim($path, '/'); + } + + // Not in group and path not change. + if ($bak === $path) { + return; + } + + $route->setPath($path); + + // Not in group + if (!$this->currentGroupPrefix) { + return; + } + + if ($this->currentGroupOption) { + $route->setOptions(array_merge($this->currentGroupOption, $route->getOptions())); + } + + // Prepend group middleware at before. + if ($this->currentGroupChains) { + $route->setChains(array_merge($this->currentGroupChains, $route->getChains())); + } + } + + /******************************************************************************* + * route match + ******************************************************************************/ + + /** + * find the matched route info for the given request uri path + * + * @param string $method + * @param string $path + * + * @return array returns array. + * [ + * match status, // found, not found, method not allowed + * formatted path, + * (Route object) OR (allowed methods list) + * ] + */ + public function match(string $path, string $method = 'GET'): array + { + // For HEAD requests, attempt fallback to GET + $method = strtoupper($method); + if ($method === 'HEAD') { + $method = 'GET'; + } + + $path = RouteHelper::formatPath($path, $this->ignoreLastSlash); + $sKey = $method . ' ' . $path; + + // It is a static route path + if (isset($this->staticRoutes[$sKey])) { + return [self::FOUND, $path, $this->staticRoutes[$sKey]]; + } + + // It is a dynamic route, match by regexp + $result = $this->matchDynamicRoute($path, $method); + if ($result[0] === self::FOUND) { + return $result; + } + + // Handle Auto Route. always return new Route object. + if ($this->autoRoute && ($handler = $this->matchAutoRoute($path))) { + return [self::FOUND, $path, Route::create($method, $path, $handler)]; + } + + // If nothing else matches, try fallback routes. $router->any('*', 'handler'); + $sKey = $method . ' /*'; + if (isset($this->staticRoutes[$sKey])) { + return [self::FOUND, $path, $this->staticRoutes[$sKey]]; + } + + if ($this->handleMethodNotAllowed) { + return $this->findAllowedMethods($path, $method); + } + + return [self::NOT_FOUND, $path, null]; + } + + /** + * is a dynamic route, match by regexp + * + * @param string $path + * @param string $method + * + * @return array + * [ + * status, + * path, + * Route(object) -> it's a raw Route clone. + * ] + */ + protected function matchDynamicRoute(string $path, string $method): array + { + $first = strstr(ltrim($path, '/'), '/', true); + $fKey = $first ? $method . ' ' . $first : ''; + + // It is a regular dynamic route(the first node is 1th level index key). + if ($fKey && isset($this->regularRoutes[$fKey])) { + foreach ($this->regularRoutes[$fKey] as $route) { + // Check path start string + $pathStart = $route->getPathStart(); + if (!str_starts_with($path, $pathStart)) { + continue; + } + + $result = $route->matchRegex($path); + if ($result[0]) { + return [self::FOUND, $path, $route->copyWithParams($result[1])]; + } + } + } + + // It is a irregular dynamic route + // if ($routeList = $this->vagueRoutes[$method] ?? false) { + if (isset($this->vagueRoutes[$method])) { + foreach ($this->vagueRoutes[$method] as $route) { + $result = $route->matchRegex($path); + if ($result[0]) { + return [self::FOUND, $path, $route->copyWithParams($result[1])]; + } + } + } + + return [self::NOT_FOUND, $path, null]; + } + + /** + * handle auto route match, when config `'autoRoute' => true` + * + * @param string $path The route path + * + * @return bool|string + */ + public function matchAutoRoute(string $path): string|bool + { + if (!$cnp = trim($this->controllerNamespace)) { + return false; + } + + $sfx = trim($this->controllerSuffix); + + return RouteHelper::parseAutoRoute($path, $cnp, $sfx, $this->namespaceUcFirst); + } + + /** + * @param string $path + * @param string $method + * + * @return array + */ + protected function findAllowedMethods(string $path, string $method): array + { + $methods = []; + foreach (self::METHODS_ARRAY as $m) { + if ($method === $m) { + continue; + } + + $sKey = $m . ' ' . $path; + if (isset($this->staticRoutes[$sKey])) { + $methods[$m] = 1; + continue; + } + + $result = $this->matchDynamicRoute($path, $m); + if ($result[0] === self::FOUND) { + $methods[$m] = 1; + } + } + + if ($methods) { + return [self::METHOD_NOT_ALLOWED, $path, array_keys($methods)]; + } + return [self::NOT_FOUND, $path, null]; + } + + /******************************************************************************* + * route dispatch + ******************************************************************************/ + + /** + * Runs the callback for the given request + * + * @param array|DispatcherInterface|null $dispatcher + * @param string $path + * @param string $method + * + * @return mixed + * @throws LogicException + * @throws Throwable + */ + public function dispatch(DispatcherInterface|array|null $dispatcher = null, string $path = '', string $method = ''): mixed + { + if (!$dispatcher) { + $dispatcher = new Dispatcher; + } elseif (is_array($dispatcher)) { + $dispatcher = new Dispatcher($dispatcher); + } + + if (!$dispatcher instanceof DispatcherInterface) { + throw new InvalidArgumentException( + 'The first argument is must an array OR an object instanceof the DispatcherInterface' + ); + } + + if (!$dispatcher->hasRouter()) { + $dispatcher->setRouter($this); + } + + return $dispatcher->dispatchUri($path, $method); + } + + /******************************************************************************* + * helper methods + ******************************************************************************/ + + /** + * @param string $name Route name + * @param array $pathVars + * + * @return string + */ + public function createUri(string $name, array $pathVars = []): string + { + if ($route = $this->getRoute($name)) { + return $route->toUri($pathVars); + } + + return ''; + } + + /** + * @param string $name + * @param Route $route + */ + public function nameRoute(string $name, Route $route): void + { + if ($name = trim($name)) { + $this->namedRoutes[$name] = $route; + } + } + + /** + * get a name route by given name. + * + * @param string $name + * + * @return Route|null + */ + public function getRoute(string $name): ?Route + { + return $this->namedRoutes[$name] ?? null; + } + + /** + * @return int + */ + public function count(): int + { + return $this->routeCounter; + } + + /** + * @param Closure $func + */ + public function each(Closure $func): void + { + foreach ($this->staticRoutes as $route) { + $func($route); + } + + foreach ($this->regularRoutes as $routes) { + foreach ($routes as $route) { + $func($route); + } + } + + foreach ($this->vagueRoutes as $routes) { + foreach ($routes as $route) { + $func($route); + } + } + } + + /** + * get all routes + * + * @return array + */ + public function getRoutes(): array + { + $routes = []; + $this->each(static function (Route $route) use (&$routes) { + $routes[] = $route; + }); + + return $routes; + } + + /** + * @return array + */ + public function getChains(): array + { + return $this->chains; + } + + protected function cloneRoute(): Route + { + return clone $this->basicRoute; + } + + /** + * Retrieve an external iterator + * + * @link https://php.net/manual/en/iteratoraggregate.getiterator.php + * @return Traversable An instance of an object implementing Iterator or + * Traversable + * @since 5.0.0 + */ + public function getIterator(): Traversable + { + return new ArrayIterator($this->getRoutes()); + } + + /** + * @return string + */ + public function __toString(): string + { + return $this->toString(); + } + + /** + * @return string + */ + public function toString(): string + { + $indent = ' '; + $strings = ['#Routes Number: ' . $this->count()]; + $strings[] = "\n#Static Routes:"; + foreach ($this->staticRoutes as $route) { + $strings[] = $indent . $route->toString(); + } + + $strings[] = "\n# Regular Routes:"; + foreach ($this->regularRoutes as $routes) { + foreach ($routes as $route) { + $strings[] = $indent . $route->toString(); + } + } + + $strings[] = "\n# Vague Routes:"; + foreach ($this->vagueRoutes as $routes) { + foreach ($routes as $route) { + $strings[] = $indent . $route->toString(); + } + } + + return implode("\n", $strings); + } +} diff --git a/src/RouterConfigTrait.php b/src/RouterConfigTrait.php new file mode 100644 index 0000000..b2b22d8 --- /dev/null +++ b/src/RouterConfigTrait.php @@ -0,0 +1,216 @@ +get('/user/{id}', 'handler'); + * + * @var array + */ + protected static array $globalParams = [ + 'all' => '.*', + 'any' => '[^/]+', // match any except '/' + 'num' => '[1-9][0-9]*', // match a number and gt 0 + 'int' => '\d+', // match a number + 'act' => '[a-zA-Z][\w-]+', // match a action name + ]; + + /******************************************************************************* + * router config + ******************************************************************************/ + + /* + * Can define an default route path + * + * @var string + */ + // public $defaultRoute = ''; + + /** + * Ignore last slash char('/'). If is True, will clear last '/'. + * + * @var bool + */ + public bool $ignoreLastSlash = false; + + /** + * Whether handle method not allowed. If True, will find allowed methods. + * + * @var bool + */ + public bool $handleMethodNotAllowed = false; + + /** + * Enable auto route match like yii framework + * If is True, will auto find the handler controller file. + * + * @var bool + */ + public bool $autoRoute = false; + + /** + * The default controllers namespace. eg: 'App\\Controllers' + * + * @var string + */ + public string $controllerNamespace = ''; + + /** + * The first char case of namespace. + * + * false - lower case. eg: 'controllers\admin' + * true - upper case. eg: 'Controllers\Admin' + * + * @var bool + */ + protected bool $namespaceUcFirst = false; + + /** + * Controller suffix, is valid when '$autoRoute' = true. eg: 'Controller' + * + * @var string + */ + public string $controllerSuffix = 'Controller'; + + /** + * @var array global Options + */ + private array $globalOptions = [ + // 'domains' => [ 'localhost' ], // allowed domains + // 'schemas' => [ 'http' ], // allowed schemas + // 'time' => ['12'], + ]; + + /** + * config the router + * + * @param array $config + * + * @throws LogicException + */ + public function config(array $config): void + { + if ($this->routeCounter > 0) { + throw new LogicException('Routing has been added, and configuration is not allowed!'); + } + + $props = [ + 'name' => 1, + 'chains' => 1, + // 'defaultRoute' => 1, + 'ignoreLastSlash' => 1, + 'handleMethodNotAllowed' => 1, + 'autoRoute' => 1, + 'controllerNamespace' => 1, + 'controllerSuffix' => 1, + ]; + + foreach ($config as $name => $value) { + $setter = 'set' . ucfirst($name); + if (method_exists($this, $setter)) { + $this->$setter($value); + } elseif (isset($props[$name])) { + $this->$name = $value; + } + } + } + + /** + * @return string + */ + public function getName(): string + { + return $this->name; + } + + /** + * @param string $name + */ + public function setName(string $name): void + { + $this->name = $name; + } + + /** + * @param array $params + */ + public function addGlobalParams(array $params): void + { + foreach ($params as $name => $pattern) { + $this->addGlobalParam($name, $pattern); + } + } + + /** + * @param string $name + * @param string $pattern + */ + public function addGlobalParam(string $name, string $pattern): void + { + $name = trim($name, '{} '); + + self::$globalParams[$name] = $pattern; + } + + /** + * @return array + */ + public function getGlobalParams(): array + { + return self::$globalParams; + } + + /** + * @return array + */ + public function getGlobalOptions(): array + { + return $this->globalOptions; + } + + /** + * @param array $globalOptions + */ + public function setGlobalOptions(array $globalOptions): void + { + $this->globalOptions = $globalOptions; + } + + /** + * @return bool + */ + public function isNamespaceUcFirst(): bool + { + return $this->namespaceUcFirst; + } + + /** + * @param bool $namespaceUcFirst + */ + public function setNamespaceUcFirst($namespaceUcFirst): void + { + $this->namespaceUcFirst = (bool)$namespaceUcFirst; + } +} diff --git a/src/RouterInterface.php b/src/RouterInterface.php index be69196..78179df 100644 --- a/src/RouterInterface.php +++ b/src/RouterInterface.php @@ -1,4 +1,4 @@ - '[0-9]+', ] + * @param array $opts Extra options + * - name: string + * - ... more + * + * @return Route */ - const SUPPORTED_METHODS = [ - 'ANY', - 'GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS', 'HEAD', 'SEARCH', 'CONNECT', 'TRACE', - ]; + public function add(string $method, string $path, $handler, array $pathParams = [], array $opts = []): Route; + + /** + * add a Route to the router + * + * @param Route $route + * + * @return Route + */ + public function addRoute(Route $route): Route; /** - * the matched result index key + * @param array|string $methods The match request method(s). e.g ['get','post'] + * @param string $path The route path string. is allow empty string. eg: '/user/login' + * @param callable|string $handler + * @param array $pathParams route path var bind. eg. [ 'id' => '[0-9]+', ] + * @param array $opts some option data + * [ + * 'defaults' => [ 'id' => 10, ], + * 'domains' => [ 'a-domain.com', '*.b-domain.com'], + * 'schemas' => ['https'], + * ] + */ + public function map($methods, string $path, $handler, array $pathParams = [], array $opts = []): void; + + /** + * find the matched route info for the given request uri path + * + * @param string $method + * @param string $path + * + * @return array + * + * [self::NOT_FOUND, $path, null] + * [self::METHOD_NOT_ALLOWED, $path, ['GET', 'OTHER_METHODS_ARRAY']] + * [self::FOUND, $path, array () // routeData ] + * */ - const INDEX_STATUS = 0; - const INDEX_PATH = 1; - const INDEX_INFO = 2; + public function match(string $path, string $method = 'GET'): array; /** * @return array */ - public static function getSupportedMethods(); + public function getChains(): array; } diff --git a/src/RouterManager.php b/src/RouterManager.php new file mode 100644 index 0000000..ee676fb --- /dev/null +++ b/src/RouterManager.php @@ -0,0 +1,313 @@ + Object(Router), + * ... ... + * ] + */ + private $routers = []; + + /** + * @var array Available router driver + */ + private $drivers = [ + 'default' => Router::class, + 'cached' => CachedRouter::class, + 'preMatch' => PreMatchRouter::class, + 'server' => ServerRouter::class, + ]; + + /** + * @var array[] + * [ + * 'default' => 'main-site', // this is default router. + * 'main-site' => [ + * 'driver' => 'default', + * 'conditions' => [ + * 'domains' => 'abc.com', + * 'schemes' => ['https'], + * ], + * 'options' => [ + * // some setting for router. + * 'name' => 'value' + * ], + * ], + * 'doc-site' => [ + * 'driver' => 'cached', + * 'conditions' => [ + * 'domains' => 'docs.abc.com', + * ], + * 'options' => [ + * 'cacheFile' => '/path/to/routes-cache.php', + * 'cacheEnable' => true, + * ], + * ], + * ] + */ + private $configs; + + /** + * @var array + * [ + * 'main-site' => [ + * 'domains' => 'abc.com', + * 'schemes' => ['https'], + * ], + * 'doc-site' => [ + * 'domains' => 'docs.abc.com', + * 'schemes' => ['https'], + * ], + * 'th3-site' => [ + * 'domains' => 'th3.abc.com', + * ], + * ] + */ + private $conditions = []; + + /** + * @var array + */ + private $supportedConditions = [ + 'domains' => 'domain', + 'schemes' => 'scheme', + ]; + + /** + * @var array + */ + // private $onCollected = [ + // 'cached' => 'completed', + // 'server' => 'flattenStatics' + // ]; + + /** + * @return RouterManager + */ + public static function instance(): RouterManager + { + return self::$_instance; + } + + /** + * RouterManager constructor. + * + * @param array $configs + */ + public function __construct(array $configs = []) + { + self::$_instance = $this; + + if ($configs) { + $this->configs($configs); + } + } + + // match by $_SERVER info. + + /** + * get router by condition + * + * @param array|string $condition + * array: + * [ + * 'domain' => 'abc.com', + * 'scheme' => 'https', + * ] + * string: + * get by name. same of call getByName() + * + * @return Router |RouterInterface + * @throws InvalidArgumentException + */ + public function get($condition = null): Router + { + if (!$condition) { + return $this->getDefault(); + } + + // alias of getByName() + if (is_string($condition)) { + return $this->getByName($condition); + } + + $useName = self::DEFAULT_ROUTER; + + foreach ($this->conditions as $name => $cond) { + if ($this->compareArray($cond, $condition)) { + $useName = $name; + break; + } + } + + return $this->getByName($useName); + } + + /** + * @param array $define + * @param array $input + * + * @return bool + */ + protected function compareArray(array $define, array $input): bool + { + $match = true; + + foreach ($this->supportedConditions as $def => $key) { + if (isset($define[$def], $input[$key])) { + $defValues = (array)$define[$def]; + + if (!in_array($input[$key], $defValues, true)) { + $match = false; + break; + } + } + } + + return $match; + } + + /** + * @param string $name + * + * @return Router + * @throws InvalidArgumentException + */ + public function getByName(string $name): Router + { + if (!isset($this->configs[$name])) { + throw new InvalidArgumentException("The named router '$name' does not exists!"); + } + + // if created + if (isset($this->routers[$name])) { + return $this->routers[$name]; + } + + // create + $config = $this->configs[$name]; + + if (is_string($config)) { + if (!isset($this->configs[$config])) { + throw new InvalidArgumentException("The reference config '$config' does not exists of the '$name'!"); + } + + $config = $this->configs[$config]; + } + + return ($this->routers[$name] = $this->createRouter($config, $name)); + } + + /** + * @return Router + * @throws InvalidArgumentException + */ + public function getDefault(): Router + { + return $this->getByName(self::DEFAULT_ROUTER); + } + + /** + * @param array $config + * @param string $name + * + * @return Router + * @throws InvalidArgumentException + */ + private function createRouter(array $config, string $name = ''): Router + { + $driver = $config['driver'] ?? self::DEFAULT_ROUTER; + $options = $config['options'] ?? []; + + if (!$class = $this->drivers[$driver] ?? null) { + throw new InvalidArgumentException("The router driver name '$driver' does not exists!"); + } + + if ($name && !isset($options['name'])) { + $options['name'] = $name; + } + + return new $class($options); + } + + /** + * @param string $name + * @param string $class + */ + public function setDriver(string $name, string $class): void + { + $this->drivers[$name] = $class; + } + + /** + * @return Router[] + */ + public function getRouters(): array + { + return $this->routers; + } + + /** + * @return array + */ + public function getDrivers(): array + { + return $this->drivers; + } + + /** + * @return array[] + */ + public function getConfigs(): array + { + return $this->configs; + } + + /** + * @param array[] $configs + */ + public function configs(array $configs): void + { + $this->configs = $configs; + + foreach ($configs as $name => $config) { + if (isset($config['conditions'])) { + $this->conditions[$name] = $config['conditions']; + } + } + } + + /** + * @return array + */ + public function getConditions(): array + { + return $this->conditions; + } +} diff --git a/src/SRouter.php b/src/SRouter.php index 3bc1a76..87a8eae 100644 --- a/src/SRouter.php +++ b/src/SRouter.php @@ -1,4 +1,4 @@ - '', - 'ignoreLastSep' => false, - 'tmpCacheNumber' => 0, - 'matchAll' => false, - - // auto route match @like yii framework - 'autoRoute' => false, - 'controllerNamespace' => '', // eg: 'app\\controllers' - 'controllerSuffix' => '', // eg: 'Controller' - ]; - - /** @var DispatcherInterface */ - private static $dispatcher; - - /** - * @param array $config - * @throws \LogicException - */ - public static function setConfig(array $config) + private function __construct() { - if (self::$initialized) { - throw new \LogicException('Routing has been added, and configuration is not allowed!'); - } - - foreach ($config as $name => $value) { - if (isset(self::$config[$name])) { - self::$config[$name] = $value; - } - } - - // load routes - if (($file = self::$config['routesFile']) && is_file($file)) { - require $file; - } } - /******************************************************************************* - * route collection - ******************************************************************************/ - /** * Defines a route callback and method - * @param string $method - * @param array $args - * @throws \InvalidArgumentException - * @throws \LogicException - */ - public static function __callStatic($method, array $args) - { - if (\count($args) < 2) { - throw new \InvalidArgumentException("The method [$method] parameters is required."); - } - - self::map($method, $args[0], $args[1], isset($args[2]) ? $args[2] : []); - } - - /** - * Create a route group with a common prefix. - * All routes created in the passed callback will have the given group prefix prepended. * - * @ref package 'nikic/fast-route' - * @param string $prefix - * @param \Closure $callback - * @param array $opts - */ - public static function group($prefix, \Closure $callback, array $opts = []) - { - $previousGroupPrefix = self::$currentGroupPrefix; - self::$currentGroupPrefix = $previousGroupPrefix . $prefix; - - $previousGroupOption = self::$currentGroupOption; - self::$currentGroupOption = $opts; - - $callback(); - - self::$currentGroupPrefix = $previousGroupPrefix; - self::$currentGroupOption = $previousGroupOption; - } - - /** - * @see ORouter::map() - * @param string|array $methods The match request method. - * @param string $route The route path string. eg: '/user/login' - * @param callable|string $handler - * @param array $opts some option data - * @return true - * @throws \LogicException - * @throws \InvalidArgumentException - */ - public static function map($methods, $route, $handler, array $opts = []) - { - if (!self::$initialized) { - self::$initialized = true; - } - - // validate arguments - $methods = static::validateArguments($methods, $handler); - - if ($route = trim($route)) { - // always add '/' prefix. - $route = $route{0} === '/' ? $route : '/' . $route; - } else { - $route = '/'; - } - - $route = self::$currentGroupPrefix . $route; - - // setting 'ignoreLastSep' - if ($route !== '/' && self::$config['ignoreLastSep']) { - $route = rtrim($route, '/'); - } - - self::$routeCounter++; - $opts = array_replace([ - 'params' => null, - // 'domains' => null, - ], self::$currentGroupOption, $opts); - $conf = [ - 'methods' => $methods, - 'handler' => $handler, - 'option' => $opts, - ]; - - // no dynamic param params - if (self::isNoDynamicParam($route)) { - self::$staticRoutes[$route][] = $conf; - - return true; - } - - // have dynamic param params - - // replace param name To pattern regex - $params = self::getAvailableParams(self::$globalParams, $opts['params']); - list($first, $conf) = static::parseParamRoute($route, $params, $conf); - - // route string have regular - if ($first) { - self::$regularRoutes[$first][] = $conf; - } else { - self::$vagueRoutes[] = $conf; - } - - return true; - } - - /******************************************************************************* - * route match - ******************************************************************************/ - - /** - * find the matched route info for the given request uri path * @param string $method - * @param string $path - * @return array + * @param array $args + * + * @return Router|mixed + * @throws InvalidArgumentException + * @throws LogicException */ - public static function match($path, $method = self::GET) + public static function __callStatic($method, array $args) { - // if enable 'matchAll' - if ($matchAll = static::$config['matchAll']) { - if (\is_string($matchAll) && $matchAll{0} === '/') { - $path = $matchAll; - } elseif (\is_callable($matchAll)) { - return [self::FOUND, $path, [ - 'handler' => $matchAll, - 'option' => [], - ]]; - } + if (method_exists(self::getRouter(), $method)) { + return self::getRouter()->$method(...$args); } - // clear '//', '///' => '/' - $path = rawurldecode(preg_replace('#\/\/+#', '/', $path)); - $method = strtoupper($method); - - // find in class cache. - if (self::$routeCaches && isset(self::$routeCaches[$path])) { - return self::findInStaticRoutes(self::$staticRoutes[$path], $path, $method); - } - - // is a static path route - if (self::$staticRoutes && isset(self::$staticRoutes[$path])) { - return self::findInStaticRoutes(self::$staticRoutes[$path], $path, $method); - } - - $first = self::getFirstFromPath($path); - - // is a regular dynamic route(the first char is 1th level index key). - if (isset(self::$regularRoutes[$first])) { - foreach (self::$regularRoutes[$first] as $conf) { - if (0 === strpos($path, $conf['start']) && preg_match($conf['regex'], $path, $matches)) { - $conf['matches'] = $matches; - - return self::checkMatched($path, $method, $conf); - } - } - } - - // is a irregular dynamic route - foreach (self::$vagueRoutes as $conf) { - if ($conf['include'] && false === strpos($path, $conf['include'])) { - continue; - } - - if (preg_match($conf['regex'], $path, $matches)) { - $conf['matches'] = $matches; - - return self::checkMatched($path, $method, $conf); - } - } - - // handle Auto Route - if ( - self::$config['autoRoute'] && - ($handler = self::matchAutoRoute($path, self::$config['controllerNamespace'], self::$config['controllerSuffix'])) - ) { - return [self::FOUND, $path, [ - 'handler' => $handler, - 'option' => [], - ]]; - } - - // oo ... not found - return [self::NOT_FOUND, $path, null]; + throw new InvalidArgumentException("call invalid method: $method"); } - /******************************************************************************* - * route callback handler dispatch - ******************************************************************************/ - /** - * Runs the callback for the given request - * @param DispatcherInterface|array $dispatcher - * @param null|string $path - * @param null|string $method - * @return mixed - * @throws \Throwable + * @return Router|RouterInterface */ - public static function dispatch($dispatcher = null, $path = null, $method = null) + public static function getRouter(): RouterInterface { - if ($dispatcher) { - if ($dispatcher instanceof DispatcherInterface) { - self::$dispatcher = $dispatcher; - } elseif (\is_array($dispatcher)) { - self::$dispatcher = new Dispatcher($dispatcher); - } - } - - if (!self::$dispatcher) { - self::$dispatcher = new Dispatcher; + if (!self::$router) { + self::$router = new Router(); } - return self::$dispatcher->setMatcher(function ($p, $m) { - return self::match($p, $m); - })->dispatch($path, $method); + return self::$router; } - /******************************************************************************* - * helper methods - ******************************************************************************/ - /** - * checkMatched - * @param string $path - * @param string $method - * @param array $conf - * @return array + * @param RouterInterface $router */ - protected static function checkMatched($path, $method, array $conf) + public static function setRouter(RouterInterface $router): void { - $methods = $conf['methods']; - $cacheNumber = (int)self::$config['tmpCacheNumber']; - - // method not allowed - if (false === strpos($methods . ',', $method . ',')) { - return [self::METHOD_NOT_ALLOWED, $path, explode(',', $methods)]; - } - - $conf['matches'] = self::filterMatches($conf['matches'], $conf); - - // cache last $cacheNumber routes. - if ($cacheNumber > 0) { - if (self::$cacheCounter === $cacheNumber) { - array_shift(self::$routeCaches); - } - - if (!isset(self::$routeCaches[$path][$methods])) { - self::$cacheCounter++; - self::$routeCaches[$path][$methods] = $conf; - } - } - - return [self::FOUND, $path, $conf]; + self::$router = $router; } - - /** - * @return int - */ - public static function count() - { - return self::$routeCounter; - } - - /** - * @return array - */ - public static function getStaticRoutes() - { - return self::$staticRoutes; - } - - /** - * @return \array[] - */ - public static function getRegularRoutes() - { - return self::$regularRoutes; - } - - /** - * @return array - */ - public static function getVagueRoutes() - { - return self::$vagueRoutes; - } - - /** - * @return array - */ - public static function getConfig() - { - return static::$config; - } - - /** - * @return DispatcherInterface - */ - public static function getDispatcher() - { - return self::$dispatcher; - } - - /** - * @param DispatcherInterface $dispatcher - */ - public static function setDispatcher(DispatcherInterface $dispatcher) - { - self::$dispatcher = $dispatcher; - } - } diff --git a/src/ServerRouter.php b/src/ServerRouter.php new file mode 100644 index 0000000..92f4dc4 --- /dev/null +++ b/src/ServerRouter.php @@ -0,0 +1,152 @@ + Route, + * 'PUT /user/login' => Route, + * ] + */ + private array $cacheRoutes = []; + + /** + * object constructor. + * + * @param array $config + * + * @throws LogicException + */ + public function __construct(array $config = []) + { + parent::__construct($config); + + if (isset($config['tmpCacheNumber'])) { + $this->tmpCacheNumber = (int)$config['tmpCacheNumber']; + } + } + + /******************************************************************************* + * route match + ******************************************************************************/ + + /** + * {@inheritdoc} + */ + public function match(string $path, string $method = 'GET'): array + { + // For HEAD requests, attempt fallback to GET + $method = strtoupper($method); + if ($method === 'HEAD') { + $method = 'GET'; + } + + $path = RouteHelper::formatPath($path, $this->ignoreLastSlash); + $sKey = $method . ' ' . $path; + + // It is a static route path + if (isset($this->staticRoutes[$sKey])) { + return [self::FOUND, $path, $this->staticRoutes[$sKey]]; + } + + // Find in route caches. + if ($this->cacheRoutes && isset($this->cacheRoutes[$sKey])) { + return [self::FOUND, $path, $this->cacheRoutes[$sKey]]; + } + + // It is a dynamic route, match by regexp + $result = $this->matchDynamicRoute($path, $method); + if ($result[0] === self::FOUND) { // will cache param route. + $this->cacheMatchedParamRoute($path, $method, $result[2]); + return $result; + } + + // Handle Auto Route + if ($this->autoRoute && ($handler = $this->matchAutoRoute($path))) { + return [self::FOUND, $path, Route::create($method, $path, $handler)]; + } + + // If nothing else matches, try fallback routes. $router->any('*', 'handler'); + $sKey = $method . ' /*'; + if ($this->staticRoutes && isset($this->staticRoutes[$sKey])) { + return [self::FOUND, $path, $this->staticRoutes[$sKey]]; + } + + if ($this->handleMethodNotAllowed) { + return $this->findAllowedMethods($path, $method); + } + + return [self::NOT_FOUND, $path, null]; + } + + /******************************************************************************* + * helper methods + ******************************************************************************/ + + /** + * @param string $path + * @param string $method + * @param Route $route + */ + protected function cacheMatchedParamRoute(string $path, string $method, Route $route): void + { + $cacheKey = $method . ' ' . $path; + $cacheNumber = $this->tmpCacheNumber; + + // cache last $cacheNumber routes. + if ($cacheNumber > 0 && !isset($this->cacheRoutes[$cacheKey])) { + if ($this->getCacheCount() >= $cacheNumber) { + array_shift($this->cacheRoutes); + } + + $this->cacheRoutes[$cacheKey] = $route; + } + } + + /** + * @return array[] + */ + public function getCacheRoutes(): array + { + return $this->cacheRoutes; + } + + /** + * @return int + */ + public function getCacheCount(): int + { + return count($this->cacheRoutes); + } +} diff --git a/test/CachedRouterTest.php b/test/CachedRouterTest.php new file mode 100644 index 0000000..b26d992 --- /dev/null +++ b/test/CachedRouterTest.php @@ -0,0 +1,67 @@ + $cacheFile, + 'cacheEnable' => 1, + ]; + $callback = function (CachedRouter $router) { + $router->get('/path0', 'handler0'); + }; + + $router = createCachedRouter($callback, $config); + + $this->assertFalse($router->isCacheLoaded()); + $this->assertTrue($router->isCacheExists()); + + /** @var Route $route */ + [$sts, , $route] = $router->match('/path0'); + + $this->assertSame(CachedRouter::FOUND, $sts); + $this->assertSame('/path0', $route->getPath()); + + // create again, will load caches. + $router = createCachedRouter($callback, $config); + + $this->assertTrue($router->isCacheExists()); + $this->assertTrue($router->isCacheLoaded()); + + /** @var Route $route */ + [$sts, , $route] = $router->match('/path0'); + + $this->assertSame(CachedRouter::FOUND, $sts); + $this->assertSame('/path0', $route->getPath()); + + // if (file_exists($cacheFile)) { + // unlink($cacheFile); + // } + } +} diff --git a/examples/Controllers/Admin/UserController.php b/test/Controllers/Admin/UserController.php similarity index 57% rename from examples/Controllers/Admin/UserController.php rename to test/Controllers/Admin/UserController.php index b3f77fe..0a14df2 100644 --- a/examples/Controllers/Admin/UserController.php +++ b/test/Controllers/Admin/UserController.php @@ -1,4 +1,4 @@ -'; } - public function infoAction() + public function infoAction(): void { echo 'hello, this is ' . __METHOD__ . '