<?php<liu21st@gmail.com>declare (strict_types = 1);
namespace think\route;
use Closure;
use think\Container;
use think\Exception;
use think\Request;
use think\Route;
class RuleGroup extends Rule
{
protected $rules = [];
protected $rule;
protected $miss;
protected $fullName;
protected $alias;
public function __construct(Route $router, RuleGroup $parent = null, string $name = '', $rule = null)
{
$this->router = $router;
$this->parent = $parent;
$this->rule = $rule;
$this->name = trim($name, '/');
$this->setFullName();
if ($this->parent) {
$this->domain = $this->parent->getDomain();
$this->parent->addRuleItem($this);
}
if ($router->isTest()) {
$this->lazy(false);
}
}
protected function setFullName(): void
{
if (false !== strpos($this->name, ':')) {
$this->name = preg_replace(['/\[\:(\w+)\]/', '/\:(\w+)/'], ['<\1?>', '<\1>'], $this->name);
}
if ($this->parent && $this->parent->getFullName()) {
$this->fullName = $this->parent->getFullName() . ($this->name ? '/' . $this->name : '');
} else {
$this->fullName = $this->name;
}
if ($this->name) {
$this->router->getRuleName()->setGroup($this->name, $this);
}
}
public function getDomain(): string
{
return $this->domain ?: '-';
}
public function getAlias(): string
{
return $this->alias ?: '';
}
public function check(Request $request, string $url, bool $completeMatch = false)
{
if (!$this->checkOption($this->option, $request) || !$this->checkUrl($url)) {
return false;
}
if ($this instanceof Resource) {
$this->buildResourceRule();
} else {
$this->parseGroupRule($this->rule);
}
$method = strtolower($request->method());
$rules = $this->getRules($method);
$option = $this->getOption();
if (isset($option['complete_match'])) {
$completeMatch = $option['complete_match'];
}
if (!empty($option['merge_rule_regex'])) {
$result = $this->checkMergeRuleRegex($request, $rules, $url, $completeMatch);
if (false !== $result) {
return $result;
}
}
foreach ($rules as $key => $item) {
$result = $item[1]->check($request, $url, $completeMatch);
if (false !== $result) {
return $result;
}
}
if (!empty($option['dispatcher'])) {
$result = $this->parseRule($request, '', $option['dispatcher'], $url, $option);
} elseif ($this->miss && in_array($this->miss->getMethod(), ['*', $method])) {
$result = $this->parseRule($request, '', $this->miss->getRoute(), $url, $this->miss->getOption());
} else {
$result = false;
}
return $result;
}
protected function checkUrl(string $url): bool
{
if ($this->fullName) {
$pos = strpos($this->fullName, '<');
if (false !== $pos) {
$str = substr($this->fullName, 0, $pos);
} else {
$str = $this->fullName;
}
if ($str && 0 !== stripos(str_replace('|', '/', $url), $str)) {
return false;
}
}
return true;
}
public function alias(string $alias)
{
$this->alias = $alias;
$this->router->getRuleName()->setGroup($alias, $this);
return $this;
}
public function lazy(bool $lazy = true)
{
if (!$lazy) {
$this->parseGroupRule($this->rule);
$this->rule = null;
}
return $this;
}
public function parseGroupRule($rule): void
{
if (is_string($rule) && is_subclass_of($rule, Dispatch::class)) {
$this->dispatcher($rule);
return;
}
$origin = $this->router->getGroup();
$this->router->setGroup($this);
if ($rule instanceof \Closure) {
Container::getInstance()->invokeFunction($rule);
} elseif (is_string($rule) && $rule) {
$this->router->bind($rule, $this->domain);
}
$this->router->setGroup($origin);
}
protected function checkMergeRuleRegex(Request $request, array &$rules, string $url, bool $completeMatch)
{
$depr = $this->router->config('pathinfo_depr');
$url = $depr . str_replace('|', $depr, $url);
$regex = [];
$items = [];
foreach ($rules as $key => $val) {
$item = $val[1];
if ($item instanceof RuleItem) {
$rule = $depr . str_replace('/', $depr, $item->getRule());
if ($depr == $rule && $depr != $url) {
unset($rules[$key]);
continue;
}
$complete = $item->getOption('complete_match', $completeMatch);
if (false === strpos($rule, '<')) {
if (0 === strcasecmp($rule, $url) || (!$complete && 0 === strncasecmp($rule, $url, strlen($rule)))) {
return $item->checkRule($request, $url, []);
}
unset($rules[$key]);
continue;
}
$slash = preg_quote('/-' . $depr, '/');
if ($matchRule = preg_split('/[' . $slash . ']<\w+\??>/', $rule, 2)) {
if ($matchRule[0] && 0 !== strncasecmp($rule, $url, strlen($matchRule[0]))) {
unset($rules[$key]);
continue;
}
}
if (preg_match_all('/[' . $slash . ']?<?\w+\??>?/', $rule, $matches)) {
unset($rules[$key]);
$pattern = array_merge($this->getPattern(), $item->getPattern());
$option = array_merge($this->getOption(), $item->getOption());
$regex[$key] = $this->buildRuleRegex($rule, $matches[0], $pattern, $option, $complete, '_THINK_' . $key);
$items[$key] = $item;
}
}
}
if (empty($regex)) {
return false;
}
try {
$result = preg_match('~^(?:' . implode('|', $regex) . ')~u', $url, $match);
} catch (\Exception $e) {
throw new Exception('route pattern error');
}
if ($result) {
$var = [];
foreach ($match as $key => $val) {
if (is_string($key) && '' !== $val) {
[$name, $pos] = explode('_THINK_', $key);
$var[$name] = $val;
}
}
if (!isset($pos)) {
foreach ($regex as $key => $item) {
if (0 === strpos(str_replace(['\/', '\-', '\\' . $depr], ['/', '-', $depr], $item), $match[0])) {
$pos = $key;
break;
}
}
}
$rule = $items[$pos]->getRule();
$array = $this->router->getRule($rule);
foreach ($array as $item) {
if (in_array($item->getMethod(), ['*', strtolower($request->method())])) {
$result = $item->checkRule($request, $url, $var);
if (false !== $result) {
return $result;
}
}
}
}
return false;
}
public function getMissRule(): ? RuleItem
{
return $this->miss;
}
public function miss($route, string $method = '*') : RuleItem
{
$ruleItem = new RuleItem($this->router, $this, null, '', $route, strtolower($method));
$ruleItem->setMiss();
$this->miss = $ruleItem;
return $ruleItem;
}
public function addRule(string $rule, $route = null, string $method = '*'): RuleItem
{
if (is_string($route)) {
$name = $route;
} else {
$name = null;
}
$method = strtolower($method);
if ('' === $rule || '/' === $rule) {
$rule .= '$';
}
$ruleItem = new RuleItem($this->router, $this, $name, $rule, $route, $method);
$this->addRuleItem($ruleItem, $method);
return $ruleItem;
}
public function addRuleItem(Rule $rule, string $method = '*')
{
if (strpos($method, '|')) {
$rule->method($method);
$method = '*';
}
$this->rules[] = [$method, $rule];
if ($rule instanceof RuleItem && 'options' != $method) {
$this->rules[] = ['options', $rule->setAutoOptions()];
}
return $this;
}
public function prefix(string $prefix)
{
if ($this->parent && $this->parent->getOption('prefix')) {
$prefix = $this->parent->getOption('prefix') . $prefix;
}
return $this->setOption('prefix', $prefix);
}
public function mergeRuleRegex(bool $merge = true)
{
return $this->setOption('merge_rule_regex', $merge);
}
public function dispatcher(string $dispatch)
{
return $this->setOption('dispatcher', $dispatch);
}
public function getFullName(): string
{
return $this->fullName ?: '';
}
public function getRules(string $method = ''): array
{
if ('' === $method) {
return $this->rules;
}
return array_filter($this->rules, function ($item) use ($method) {
return $method == $item[0] || '*' == $item[0];
});
}
public function clear(): void
{
$this->rules = [];
}
}