PHP Route::getPattern方法代码示例

 /**
  * {@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 &registerRoute(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);
 }