/**
* {@inheritDoc}
*
* @throws \LogicException If a variable is referenced more than once
* @throws \DomainException If a variable name is numeric because PHP raises an error for such
* subpatterns in PCRE and thus would break matching, e.g. "(?<123>.+)".
*/
public function compile(Route $route)
{
$pattern = $route->getPattern();
$len = strlen($pattern);
$tokens = array();
$variables = array();
$pos = 0;
preg_match_all('#.\\{(\\w+)\\}#', $pattern, $matches, PREG_OFFSET_CAPTURE | PREG_SET_ORDER);
foreach ($matches as $match) {
if ($text = substr($pattern, $pos, $match[0][1] - $pos)) {
$tokens[] = array('text', $text);
}
$pos = $match[0][1] + strlen($match[0][0]);
$var = $match[1][0];
if (null !== ($req = $route->getRequirement($var))) {
$regexp = $req;
} else {
// Use the character preceding the variable as a separator
$separators = array($match[0][0][0]);
if ($pos !== $len) {
// Use the character following the variable as the separator when available
$separators[] = $pattern[$pos];
}
$regexp = sprintf('[^%s]+', preg_quote(implode('', array_unique($separators)), self::REGEX_DELIMITER));
}
$tokens[] = array('variable', $match[0][0][0], $regexp, $var);
if (is_numeric($var)) {
throw new \DomainException(sprintf('Variable name "%s" cannot be numeric in route pattern "%s". Please use a different name.', $var, $route->getPattern()));
}
if (in_array($var, $variables)) {
throw new \LogicException(sprintf('Route pattern "%s" cannot reference variable name "%s" more than once.', $route->getPattern(), $var));
}
$variables[] = $var;
}
if ($pos < $len) {
$tokens[] = array('text', substr($pattern, $pos));
}
// find the first optional token
$firstOptional = INF;
for ($i = count($tokens) - 1; $i >= 0; $i--) {
$token = $tokens[$i];
if ('variable' === $token[0] && $route->hasDefault($token[3])) {
$firstOptional = $i;
} else {
break;
}
}
// compute the matching regexp
$regexp = '';
for ($i = 0, $nbToken = count($tokens); $i < $nbToken; $i++) {
$regexp .= $this->computeRegexp($tokens, $i, $firstOptional);
}
return new CompiledRoute('text' === $tokens[0][0] ? $tokens[0][1] : '', self::REGEX_DELIMITER . '^' . $regexp . '$' . self::REGEX_DELIMITER . 's', array_reverse($tokens), $variables);
}
/**
* Compiles the current route instance.
*
* @param Route $route A Route instance
*
* @return CompiledRoute A CompiledRoute instance
*/
public function compile(Route $route)
{
$pattern = $route->getPattern();
$len = strlen($pattern);
$tokens = array();
$variables = array();
$pos = 0;
preg_match_all('#.\\{([\\w\\d_]+)\\}#', $pattern, $matches, PREG_OFFSET_CAPTURE | PREG_SET_ORDER);
foreach ($matches as $match) {
if ($text = substr($pattern, $pos, $match[0][1] - $pos)) {
$tokens[] = array('text', $text);
}
$seps = array($pattern[$pos]);
$pos = $match[0][1] + strlen($match[0][0]);
$var = $match[1][0];
if ($req = $route->getRequirement($var)) {
$regexp = $req;
} else {
if ($pos !== $len) {
$seps[] = $pattern[$pos];
}
$regexp = sprintf('[^%s]+?', preg_quote(implode('', array_unique($seps)), '#'));
}
$tokens[] = array('variable', $match[0][0][0], $regexp, $var);
if (in_array($var, $variables)) {
throw new \LogicException(sprintf('Route pattern "%s" cannot reference variable name "%s" more than once.', $route->getPattern(), $var));
}
$variables[] = $var;
}
if ($pos < $len) {
$tokens[] = array('text', substr($pattern, $pos));
}
// find the first optional token
$firstOptional = PHP_INT_MAX;
for ($i = count($tokens) - 1; $i >= 0; $i--) {
$token = $tokens[$i];
if ('variable' === $token[0] && $route->hasDefault($token[3])) {
$firstOptional = $i;
} else {
break;
}
}
// compute the matching regexp
$regexp = '';
for ($i = 0, $nbToken = count($tokens); $i < $nbToken; $i++) {
$regexp .= $this->computeRegexp($tokens, $i, $firstOptional);
}
return new CompiledRoute($route, 'text' === $tokens[0][0] ? $tokens[0][1] : '', sprintf("#^%s\$#s", $regexp), array_reverse($tokens), $variables);
}
/**
* {@inheritDoc}
*
* @throws \LogicException If a variable is referenced more than once
* @throws \DomainException If a variable name is numeric because PHP raises an error for such
* subpatterns in PCRE and thus would break matching, e.g. "(?<123>.+)".
*/
public function compile(Route $route)
{
$pattern = $route->getPattern();
$tokens = array();
$variables = array();
$matches = array();
$pos = 0;
// Match all variables enclosed in "{}" and iterate over them. But we only want to match the innermost variable
// in case of nested "{}", e.g. {foo{bar}}. This in ensured because \w does not match "{" or "}" itself.
preg_match_all('#\{\w+\}#', $pattern, $matches, PREG_OFFSET_CAPTURE | PREG_SET_ORDER);
foreach ($matches as $match) {
$varName = substr($match[0][0], 1, -1);
// get all static text preceding the current variable
$precedingText = substr($pattern, $pos, $match[0][1] - $pos);
$pos = $match[0][1] + strlen($match[0][0]);
$precedingChar = strlen($precedingText) > 0 ? substr($precedingText, -1) : '';
$isSeparator = '' !== $precedingChar && false !== strpos(static::SEPARATORS, $precedingChar);
if (is_numeric($varName)) {
throw new \DomainException(sprintf('Variable name "%s" cannot be numeric in route pattern "%s". Please use a different name.', $varName, $pattern));
}
if (in_array($varName, $variables)) {
throw new \LogicException(sprintf('Route pattern "%s" cannot reference variable name "%s" more than once.', $pattern, $varName));
}
if ($isSeparator && strlen($precedingText) > 1) {
$tokens[] = array('text', substr($precedingText, 0, -1));
} elseif (!$isSeparator && strlen($precedingText) > 0) {
$tokens[] = array('text', $precedingText);
}
$regexp = $route->getRequirement($varName);
if (null === $regexp) {
$followingPattern = (string) substr($pattern, $pos);
// Find the next static character after the variable that functions as a separator. By default, this separator and '/'
// are disallowed for the variable. This default requirement makes sure that optional variables can be matched at all
// and that the generating-matching-combination of URLs unambiguous, i.e. the params used for generating the URL are
// the same that will be matched. Example: new Route('/{page}.{_format}', array('_format' => 'html'))
// If {page} would also match the separating dot, {_format} would never match as {page} will eagerly consume everything.
// Also even if {_format} was not optional the requirement prevents that {page} matches something that was originally
// part of {_format} when generating the URL, e.g. _format = 'mobile.html'.
$nextSeparator = $this->findNextSeparator($followingPattern);
$regexp = sprintf('[^/%s]+', '/' !== $nextSeparator && '' !== $nextSeparator ? preg_quote($nextSeparator, self::REGEX_DELIMITER) : '');
if (('' !== $nextSeparator && !preg_match('#^\{\w+\}#', $followingPattern)) || '' === $followingPattern) {
// When we have a separator, which is disallowed for the variable, we can optimize the regex with a possessive
// quantifier. This prevents useless backtracking of PCRE and improves performance by 20% for matching those patterns.
// Given the above example, there is no point in backtracking into {page} (that forbids the dot) when a dot must follow
// after it. This optimization cannot be applied when the next char is no real separator or when the next variable is
// directly adjacent, e.g. '/{x}{y}'.
$regexp .= '+';
}
}
$tokens[] = array('variable', $isSeparator ? $precedingChar : '', $regexp, $varName);
$variables[] = $varName;
}
if ($pos < strlen($pattern)) {
$tokens[] = array('text', substr($pattern, $pos));
}
// find the first optional token
$firstOptional = INF;
for ($i = count($tokens) - 1; $i >= 0; $i--) {
$token = $tokens[$i];
if ('variable' === $token[0] && $route->hasDefault($token[3])) {
$firstOptional = $i;
} else {
break;
}
}
// compute the matching regexp
$regexp = '';
for ($i = 0, $nbToken = count($tokens); $i < $nbToken; $i++) {
$regexp .= $this->computeRegexp($tokens, $i, $firstOptional);
}
return new CompiledRoute(
'text' === $tokens[0][0] ? $tokens[0][1] : '',
self::REGEX_DELIMITER.'^'.$regexp.'$'.self::REGEX_DELIMITER.'s',
array_reverse($tokens),
$variables
);
}
/**
* map individual route patterns
*
* @return mixed[object|void]
*/
function translatePattern(Route $object)
{
//empty and move on
if (empty($object)) {
return $object;
}
$pattern = $object->getPattern();
//loop through our route map array and switch values in both uri and pattern strings
foreach ($this->getrouteMap() as $key => $value) {
//look for any matches within our pattern
if (stripos($pattern, $key) !== false) {
//if we have a key called '{method}' and its empty, we're at the root level, so add 'index'
$value = (in_array($key, array('{method}', '{submethod}')) and $value == '') ? 'index' : $value;
//update our pattern variable
$pattern = str_ireplace($key, $value, $pattern);
}
}
//prepend the request type to the method, if we have a normal route
if (strpos($pattern, '::') and $object->is_special === false) {
//explode $pattern into $class and $method
list($class, $method) = explode('::', $pattern);
//put back together - and check we dont add the request type to the method twice
$pattern = $class . '::' . (!strstr($method, $this->request_type) ? $this->request_type . '_' : '') . $method;
}
//update the mapped pattern, keeping the original pattern
$object->setMappedPattern($pattern);
return $object;
}
/**
* @param Huxtable\Web\Route $route
* @param string $httpMethod
* @return Huxtable\Web\Route A reference to the Route object, for chaining
*/
public function ®isterRoute(Route $route, $httpMethod)
{
$pattern = $route->getPattern();
$this->routes[$pattern][$httpMethod] = $route;
return $this->routes[$pattern][$httpMethod];
}
/**
* @param Context $context
* @param Route $route
* @return array
*/
public function extract(Context $context, Route $route) : array
{
$names = $this->getCompiler()->getNames($route->getPattern());
$regex = $this->getRouteCollection()->getRegex($route->getID());
$values = $this->getCompiler()->getValues($regex, (string) $context);
return array_intersect_key($values, array_flip($names)) + $route->getDefaults();
}
/**
* Compiles the current route instance.
*
* @param Route $route A Route instance
*
* @return CompiledRoute A CompiledRoute instance
*/
public function compile(Route $route)
{
$pattern = $route->getPattern();
$len = strlen($pattern);
$tokens = array();
$variables = array();
$pos = 0;
preg_match_all('#.\{([\w\d_]+)\}#', $pattern, $matches, PREG_OFFSET_CAPTURE | PREG_SET_ORDER);
foreach ($matches as $match) {
if ($text = substr($pattern, $pos, $match[0][1] - $pos)) {
$tokens[] = array('text', $text);
}
$seps = array($pattern[$pos]);
$pos = $match[0][1] + strlen($match[0][0]);
$var = $match[1][0];
if ($req = $route->getRequirement($var)) {
$regexp = $req;
} else {
if ($pos !== $len) {
$seps[] = $pattern[$pos];
}
$regexp = sprintf('[^%s]*?', preg_quote(implode('', array_unique($seps)), '#'));
}
$tokens[] = array('variable', $match[0][0][0], $regexp, $var);
$variables[] = $var;
}
if ($pos < $len) {
$tokens[] = array('text', substr($pattern, $pos));
}
// find the first optional token
$firstOptional = INF;
for ($i = count($tokens) - 1; $i >= 0; $i--) {
if ('variable' === $tokens[$i][0] && $route->hasDefault($tokens[$i][3])) {
$firstOptional = $i;
} else {
break;
}
}
// compute the matching regexp
$regex = '';
$indent = 1;
foreach ($tokens as $i => $token) {
if ('text' === $token[0]) {
$regex .= str_repeat(' ', $indent * 4).preg_quote($token[1], '#')."\n";
} else {
if ($i >= $firstOptional) {
$regex .= str_repeat(' ', $indent * 4)."(?:\n";
++$indent;
}
$regex .= str_repeat(' ', $indent * 4).sprintf("%s(?P<%s>%s)\n", preg_quote($token[1], '#'), $token[3], $token[2]);
}
}
while (--$indent) {
$regex .= str_repeat(' ', $indent * 4).")?\n";
}
return new CompiledRoute(
$route,
'text' === $tokens[0][0] ? $tokens[0][1] : '',
sprintf("#^\n%s$#x", $regex),
array_reverse($tokens),
$variables
);
}
/**
* Tries to match a route to a given URI
*
* @static
* @param Route Route
* @param string URI
* @return boolean|string[] If route doesn't match, false is returned - otherwise it returns an array containing matched params
*/
private static function matchRoute(Route $route, $uri)
{
// We want to store the params giving by the URI
$p_keys = array();
$p_values = array();
// Given pattern
$pattern = $route->getPattern();
// Transform the given pattern into a regular expression
$pattern_regexp = preg_replace('~:(.*?):~u', '(.*?)', $pattern);
// Customise pattern_regexp
$pattern_regexp = preg_replace('~(.*?)\\(\\.\\*\\?\\)$~u', '$1(.*)', $pattern_regexp);
// Retrieve all keys
preg_match_all('~:(.*?):~u', $pattern, $matches);
if (count($matches[0]) == 0) {
// obviously the pattern doesn't contain
// any params -> must have been matched in case 1
return false;
}
foreach ($matches[1] as $m) {
$p_keys[] = $m;
}
unset($matches);
// Now try to match the URI and store its values
preg_match_all('~^' . $pattern_regexp . '$~u', $uri, $matches);
if (count($matches[0]) == 0) {
// URI doesn't match -> go on!
return false;
}
$count = count($matches);
for ($i = 1; $i < $count; ++$i) {
$p_values[] = $matches[$i][0];
}
return Router::buildArray($p_keys, $p_values);
}
