PHP Route::getMethods方法代码示例

    /**
     * {@inheritdoc}
     */
    protected function describeRoute(Route $route, array $options = array())
    {
        $requirements = $route->getRequirements();
        unset($requirements['_scheme'], $requirements['_method']);

        // fixme: values were originally written as raw
        $description = array(
            '<comment>Path</comment>         '.$route->getPath(),
            '<comment>Host</comment>         '.('' !== $route->getHost() ? $route->getHost() : 'ANY'),
            '<comment>Scheme</comment>       '.($route->getSchemes() ? implode('|', $route->getSchemes()) : 'ANY'),
            '<comment>Method</comment>       '.($route->getMethods() ? implode('|', $route->getMethods()) : 'ANY'),
            '<comment>Class</comment>        '.get_class($route),
            '<comment>Defaults</comment>     '.$this->formatRouterConfig($route->getDefaults()),
            '<comment>Requirements</comment> '.$this->formatRouterConfig($requirements) ?: 'NO CUSTOM',
            '<comment>Options</comment>      '.$this->formatRouterConfig($route->getOptions()),
            '<comment>Path-Regex</comment>   '.$route->compile()->getRegex(),
        );

        if (isset($options['name'])) {
            array_unshift($description, '<comment>Name</comment>         '.$options['name']);
            array_unshift($description, $this->formatSection('router', sprintf('Route "%s"', $options['name'])));
        }

        if (null !== $route->compile()->getHostRegex()) {
            $description[] = '<comment>Host-Regex</comment>   '.$route->compile()->getHostRegex();
        }

        $this->writeText(implode("\n", $description)."\n", $options);
    }

 /**
  * {@inheritdoc}
  */
 protected function describeRoute(Route $route, array $options = array())
 {
     $requirements = $route->getRequirements();
     unset($requirements['_scheme'], $requirements['_method']);
     $output = '- Path: ' . $route->getPath() . "\n" . '- Host: ' . ('' !== $route->getHost() ? $route->getHost() : 'ANY') . "\n" . '- Scheme: ' . ($route->getSchemes() ? implode('|', $route->getSchemes()) : 'ANY') . "\n" . '- Method: ' . ($route->getMethods() ? implode('|', $route->getMethods()) : 'ANY') . "\n" . '- Class: ' . get_class($route) . "\n" . '- Defaults: ' . $this->formatRouterConfig($route->getDefaults()) . "\n" . '- Requirements: ' . $this->formatRouterConfig($requirements) ?: 'NONE' . "\n" . '- Options: ' . $this->formatRouterConfig($route->getOptions()) . "\n" . '- Path-Regex: ' . $route->compile()->getRegex();
     $this->write(isset($options['name']) ? $options['name'] . "\n" . str_repeat('-', strlen($options['name'])) . "\n\n" . $output : $output);
     $this->write("\n");
 }

 /**
  * {@inheritdoc}
  */
 protected function describeRoute(Route $route, array $options = array())
 {
     $tableHeaders = array('Property', 'Value');
     $tableRows = array(array('Route Name', $options['name']), array('Path', $route->getPath()), array('Path Regex', $route->compile()->getRegex()), array('Host', '' !== $route->getHost() ? $route->getHost() : 'ANY'), array('Host Regex', '' !== $route->getHost() ? $route->compile()->getHostRegex() : ''), array('Scheme', $route->getSchemes() ? implode('|', $route->getSchemes()) : 'ANY'), array('Method', $route->getMethods() ? implode('|', $route->getMethods()) : 'ANY'), array('Requirements', $route->getRequirements() ? $this->formatRouterConfig($route->getRequirements()) : 'NO CUSTOM'), array('Class', get_class($route)), array('Defaults', $this->formatRouterConfig($route->getDefaults())), array('Options', $this->formatRouterConfig($route->getOptions())));
     $table = new Table($this->getOutput());
     $table->setHeaders($tableHeaders)->setRows($tableRows);
     $table->render();
 }

 /**
  * {@inheritdoc}
  */
 public function resolve(Route $route, RouteCollectionAccessor $routes)
 {
     if (!in_array('OPTIONS', $route->getMethods(), true)) {
         return;
     }
     $entryPath = $this->getEntryPath($route);
     if (!$entryPath) {
         return;
     }
     $nameFromController = $this->getNameFromController($route);
     if (!$nameFromController) {
         return;
     }
     $nameFromPath = str_replace('/', '', $entryPath);
     if ($nameFromPath === $nameFromController) {
         return;
     }
     if (false !== ($pos = strrpos($entryPath, '/'))) {
         $pluralName = substr($entryPath, $pos + 1);
         $singleName = substr($nameFromController, $pos - substr_count($entryPath, '/') + 1);
     } else {
         $pluralName = $entryPath;
         $singleName = $nameFromController;
     }
     if ($pluralName === $singleName || $pluralName !== Inflector::pluralize($singleName)) {
         return;
     }
     $singlePath = str_replace('/' . $pluralName, '/' . $singleName, $route->getPath());
     $singleRoute = $routes->cloneRoute($route);
     $singleRoute->setPath($singlePath);
     $singleRoute->setOption('old_options', true);
     $pluralRouteName = $routes->getName($route);
     $routes->insert($routes->generateRouteName($pluralRouteName), $singleRoute, $pluralRouteName);
 }

 /**
  * @param Route $route
  * @return Action
  */
 public function getActionForRoute(Route $route)
 {
     foreach ($this->actions as $action) {
         // TODO this should be improved to be more precise (route prefix)
         $sameSchema = strpos($route->getPath(), $action->getUrlSchema()) >= 0;
         $sameMethods = $action->getMethods() == $route->getMethods();
         if ($sameMethods && $sameSchema) {
             return $action;
         }
     }
 }

 private function isAccessedAnonymously($routeName, Route $route)
 {
     if (!in_array('GET', $route->getMethods()) && $route->getMethods()) {
         return false;
         // GET method must be allowed
     }
     if (strpos($routeName, '_') === 0) {
         return false;
         // internal|private routes
     }
     $compiled = $route->compile();
     $params = [];
     foreach ($compiled->getPathVariables() as $key) {
         $params[$key] = 'any';
         // we do not care about it
     }
     foreach ($route->getRequirements() as $key => $regex) {
         $params[$key] = 'any';
         // we do not care about it
     }
     foreach ($route->getDefaults() as $key => $default) {
         $params[$key] = $default;
     }
     if (!array_key_exists('_controller', $params)) {
         return false;
         // route is dynamic, should not be index by robots
     }
     $uri = $this->get('router')->generate($routeName, $params);
     // mock the request
     $request = Request::create('http://mock.com' . $uri);
     $request->setSession(new Session(new MockFileSessionStorage()));
     // run the request through security firewall
     $event = new GetResponseEvent($this->getApplication()->getKernel(), $request, HttpKernelInterface::MASTER_REQUEST);
     try {
         $this->get('security.firewall')->onKernelRequest($event);
     } catch (AccessDeniedException $e) {
         return false;
         // access is denied
     }
     return !$event->getResponse() instanceof RedirectResponse;
 }

 /**
  * get collection and id from route
  *
  * @param Route  $route route to look at
  * @param string $value value of reference as URI
  *
  * @return array
  */
 private function getDataFromRoute(Route $route, $value)
 {
     if ($route->getRequirement('id') !== null && $route->getMethods() === ['GET'] && preg_match($route->compile()->getRegex(), $value, $matches)) {
         $id = $matches['id'];
         list($routeService) = explode(':', $route->getDefault('_controller'));
         list($core, $bundle, , $name) = explode('.', $routeService);
         $serviceName = implode('.', [$core, $bundle, 'rest', $name]);
         $collection = array_search($serviceName, $this->mapping);
         return [$collection, $id];
     }
     return [null, null];
 }

 /**
  * @param Route $route the route we're tried to add
  * @param int $name the name given to the route we tried to add
  * @param Route $routeWithSameName the existing route with the same name
  */
 public function __construct(Route $route, $name, Route $routeWithSameName)
 {
     // host to string
     if (!($host = $route->getHost())) {
         $host = 'any';
     }
     if (!($hostRouteWithSameName = $routeWithSameName->getHost())) {
         $hostRouteWithSameName = 'any';
     }
     // methods to string
     if ($methods = $route->getMethods()) {
         $methods = implode($methods, ', ');
     } else {
         $methods = 'any';
     }
     if ($methodsRouteWithSameName = $routeWithSameName->getMethods()) {
         $methodsRouteWithSameName = implode($methodsRouteWithSameName, ', ');
     } else {
         $methodsRouteWithSameName = 'any';
     }
     $message = sprintf("Cannot add the route [path: %s, host: %s, methods: %s] with the name '%s'\n                as it is already used by the route [path: %s, host: %s, methods: %s].", $route->getPath(), $host, $methods, $name, $routeWithSameName->getPath(), $hostRouteWithSameName, $methodsRouteWithSameName);
     parent::__construct($message);
 }

 /**
  * @param Route $route
  *
  * @return array
  */
 protected function getRouteData(Route $route)
 {
     return array('path' => $route->getPath(), 'pathRegex' => $route->compile()->getRegex(), 'host' => '' !== $route->getHost() ? $route->getHost() : 'ANY', 'hostRegex' => '' !== $route->getHost() ? $route->compile()->getHostRegex() : '', 'scheme' => $route->getSchemes() ? implode('|', $route->getSchemes()) : 'ANY', 'method' => $route->getMethods() ? implode('|', $route->getMethods()) : 'ANY', 'class' => get_class($route), 'defaults' => $route->getDefaults(), 'requirements' => $route->getRequirements() ?: 'NO CUSTOM', 'options' => $route->getOptions());
 }

 /**
  * Returns methods allowed for a route.
  *
  * @param Route $route
  *        	The route
  *        	
  * @return array The methods
  */
 private function getRouteMethods(Route $route)
 {
     $methods = $route->getMethods();
     // GET and HEAD are equivalent
     if (in_array('GET', $methods) && !in_array('HEAD', $methods)) {
         $methods[] = 'HEAD';
     }
     return $methods;
 }

 /**
  * Generates a route name based on details of this route.
  *
  * @return string
  */
 private function generateRouteName(Route $route)
 {
     $methods = implode('_', $route->getMethods()) . '_';
     $routeName = $methods . $route->getPath();
     $routeName = str_replace(array('/', ':', '|', '-'), '_', $routeName);
     $routeName = preg_replace('/[^a-z0-9A-Z_.]+/', '', $routeName);
     // Collapse consecutive underscores down into a single underscore.
     $routeName = preg_replace('/_+/', '_', $routeName);
     return $routeName;
 }

 public function addPageRoute($admin_name, $action_name, \Symfony\Component\Routing\Route $route, \ReflectionMethod $m, \Symforce\AdminBundle\Compiler\Annotation\Route $annot)
 {
     if (null === $this->route_page_collection) {
         throw new \Exception('should call getRouteCollection first');
     }
     $_path = array('s' => $route->getSchemes(), 'h' => $route->getHost(), 'p' => $route->getPath(), 'm' => $route->getMethods());
     $path = json_encode($_path);
     $admin_action = $admin_name . ':' . $action_name;
     if (isset($this->page_path_map[$path])) {
         $_admin_action = $this->page_path_map[$path];
         throw new \Exception(sprintf("web page path:`%s` duplicate(%s,%s)", $route->getPath(), $this->page_actions_map[$admin_action], $this->page_actions_map[$_admin_action]));
     }
     $this->page_path_map[$path] = $admin_action;
     if (isset($this->page_route_map[$annot->name])) {
         $_admin_action = $this->page_route_map[$annot->name];
         throw new \Exception(sprintf("web page route name:`%s` duplicate method(%s,%s), action(%s,%s)", $annot->name, $this->page_actions_map[$admin_action], $this->page_actions_map[$_admin_action], $admin_action, $_admin_action));
     }
     $this->page_route_map[$annot->name] = $admin_action;
     $this->route_page_collection->add($annot->name, $route);
     $this->page_dispatch_map[$admin_action] = array('name' => $annot->name, 'path' => $route->getPath(), 'requirements' => $route->getRequirements(), 'entity' => $annot->entity, 'template' => $annot->template, 'generator' => null, 'dispatcher' => null);
 }

 /**
  * @param Route $route
  * @return string
  */
 protected function getRouteMethods(Route $route) : string
 {
     return strtolower(implode(',', $route->getMethods()) ?: 'get');
 }

    /**
     * Compiles a single Route to PHP code used to match it against the path info.
     *
     * @param Route       $route                A Route instance
     * @param string      $name                 The name of the Route
     * @param bool        $supportsRedirections Whether redirections are supported by the base class
     * @param string|null $parentPrefix         The prefix of the parent collection used to optimize the code
     *
     * @return string PHP code
     *
     * @throws \LogicException
     */
    private function compileRoute(Route $route, $name, $supportsRedirections, $parentPrefix = null)
    {
        $code = '';
        $compiledRoute = $route->compile();
        $conditions = array();
        $hasTrailingSlash = false;
        $matches = false;
        $hostMatches = false;
        $methods = $route->getMethods();
        // GET and HEAD are equivalent
        if (in_array('GET', $methods) && !in_array('HEAD', $methods)) {
            $methods[] = 'HEAD';
        }
        $supportsTrailingSlash = $supportsRedirections && (!$methods || in_array('HEAD', $methods));
        if (!count($compiledRoute->getPathVariables()) && false !== preg_match('#^(.)\\^(?P<url>.*?)\\$\\1#', $compiledRoute->getRegex(), $m)) {
            if ($supportsTrailingSlash && substr($m['url'], -1) === '/') {
                $conditions[] = sprintf("rtrim(\$pathinfo, '/') === %s", var_export(rtrim(str_replace('\\', '', $m['url']), '/'), true));
                $hasTrailingSlash = true;
            } else {
                $conditions[] = sprintf("\$pathinfo === %s", var_export(str_replace('\\', '', $m['url']), true));
            }
        } else {
            if ($compiledRoute->getStaticPrefix() && $compiledRoute->getStaticPrefix() !== $parentPrefix) {
                $conditions[] = sprintf("0 === strpos(\$pathinfo, %s)", var_export($compiledRoute->getStaticPrefix(), true));
            }
            $regex = $compiledRoute->getRegex();
            if ($supportsTrailingSlash && ($pos = strpos($regex, '/$'))) {
                $regex = substr($regex, 0, $pos) . '/?$' . substr($regex, $pos + 2);
                $hasTrailingSlash = true;
            }
            $conditions[] = sprintf("preg_match(%s, \$pathinfo, \$matches)", var_export($regex, true));
            $matches = true;
        }
        if ($compiledRoute->getHostVariables()) {
            $hostMatches = true;
        }
        if ($route->getCondition()) {
            $conditions[] = $this->getExpressionLanguage()->compile($route->getCondition(), array('context', 'request'));
        }
        $conditions = implode(' && ', $conditions);
        $code .= <<<EOF
        // {$name}
        if ({$conditions}) {

EOF;
        $gotoname = 'not_' . preg_replace('/[^A-Za-z0-9_]/', '', $name);
        if ($methods) {
            if (1 === count($methods)) {
                $code .= <<<EOF
            if (\$this->context->getMethod() != '{$methods['0']}') {
                \$allow[] = '{$methods['0']}';
                goto {$gotoname};
            }


EOF;
            } else {
                $methods = implode("', '", $methods);
                $code .= <<<EOF
            if (!in_array(\$this->context->getMethod(), array('{$methods}'))) {
                \$allow = array_merge(\$allow, array('{$methods}'));
                goto {$gotoname};
            }


EOF;
            }
        }
        if ($hasTrailingSlash) {
            $code .= <<<EOF
            if (substr(\$pathinfo, -1) !== '/') {
                return \$this->redirect(\$pathinfo.'/', '{$name}');
            }


EOF;
        }
        if ($schemes = $route->getSchemes()) {
            if (!$supportsRedirections) {
                throw new \LogicException('The "schemes" requirement is only supported for URL matchers that implement RedirectableUrlMatcherInterface.');
            }
            $schemes = str_replace("\n", '', var_export(array_flip($schemes), true));
            $code .= <<<EOF
            \$requiredSchemes = {$schemes};
            if (!isset(\$requiredSchemes[\$this->context->getScheme()])) {
                return \$this->redirect(\$pathinfo, '{$name}', key(\$requiredSchemes));
            }

//.........这里部分代码省略.........

 /**
  * @group legacy
  */
 public function testLegacyMethodRequirement()
 {
     $this->iniSet('error_reporting', -1 & ~E_USER_DEPRECATED);
     $route = new Route('/');
     $route->setRequirement('_method', 'GET|POST');
     $this->assertEquals('GET|POST', $route->getRequirement('_method'));
     $this->assertEquals(array('GET', 'POST'), $route->getMethods());
     $route->setMethods(array('gEt'));
     $this->assertEquals('GET', $route->getRequirement('_method'));
     $route->setMethods(array());
     $this->assertNull($route->getRequirement('_method'));
 }