hdabo_sf: comparison vendor/symfony/src/Symfony/Component/Routing/Loader/AnnotationClassLoader.php

equal deleted inserted replaced

--1:000000000000
+:7f95f8617b0b
+<?php
+/*
+* This file is part of the Symfony package.
+*
+* (c) Fabien Potencier <fabien@symfony.com>
+*
+* For the full copyright and license information, please view the LICENSE
+* file that was distributed with this source code.
+*/
+namespace Symfony\Component\Routing\Loader;
+use Doctrine\Common\Annotations\Reader;
+use Symfony\Component\Routing\Annotation\Route as RouteAnnotation;
+use Symfony\Component\Config\Resource\FileResource;
+use Symfony\Component\Routing\Route;
+use Symfony\Component\Routing\RouteCollection;
+use Symfony\Component\Config\Loader\LoaderInterface;
+use Symfony\Component\Config\Loader\LoaderResolver;
+/**
+* AnnotationClassLoader loads routing information from a PHP class and its methods.
+*
+* You need to define an implementation for the getRouteDefaults() method. Most of the
+* time, this method should define some PHP callable to be called for the route
+* (a controller in MVC speak).
+*
+* The @Route annotation can be set on the class (for global parameters),
+* and on each method.
+*
+* The @Route annotation main value is the route pattern. The annotation also
+* recognizes three parameters: requirements, options, and name. The name parameter
+* is mandatory. Here is an example of how you should be able to use it:
+*
+*     /**
+*      * @Route("/Blog")
+*      * /
+*     class Blog
+*     {
+*         /**
+*          * @Route("/", name="blog_index")
+*          * /
+*         public function index()
+*         {
+*         }
+*
+*         /**
+*          * @Route("/{id}", name="blog_post", requirements = {"id" = "\d+"})
+*          * /
+*         public function show()
+*         {
+*         }
+*     }
+*
+* @author Fabien Potencier <fabien@symfony.com>
+*/
+abstract class AnnotationClassLoader implements LoaderInterface
+{
+protected $reader;
+protected $routeAnnotationClass  = 'Symfony\\Component\\Routing\\Annotation\\Route';
+protected $defaultRouteIndex;
+/**
+* Constructor.
+*
+* @param Reader $reader
+*/
+public function __construct(Reader $reader)
+{
+$this->reader = $reader;
+}
+/**
+* Sets the annotation class to read route properties from.
+*
+* @param string $class A fully-qualified class name
+*/
+public function setRouteAnnotationClass($class)
+{
+$this->routeAnnotationClass = $class;
+}
+/**
+* Loads from annotations from a class.
+*
+* @param string $class A class name
+* @param string $type  The resource type
+*
+* @return RouteCollection A RouteCollection instance
+*
+* @throws \InvalidArgumentException When route can't be parsed
+*/
+public function load($class, $type = null)
+{
+if (!class_exists($class)) {
+throw new \InvalidArgumentException(sprintf('Class "%s" does not exist.', $class));
+}
+$globals = array(
+'pattern'      => '',
+'requirements' => array(),
+'options'      => array(),
+'defaults'     => array(),
+);
+$class = new \ReflectionClass($class);
+if ($annot = $this->reader->getClassAnnotation($class, $this->routeAnnotationClass)) {
+if (null !== $annot->getPattern()) {
+$globals['pattern'] = $annot->getPattern();
+}
+if (null !== $annot->getRequirements()) {
+$globals['requirements'] = $annot->getRequirements();
+}
+if (null !== $annot->getOptions()) {
+$globals['options'] = $annot->getOptions();
+}
+if (null !== $annot->getDefaults()) {
+$globals['defaults'] = $annot->getDefaults();
+}
+}
+$collection = new RouteCollection();
+$collection->addResource(new FileResource($class->getFileName()));
+foreach ($class->getMethods() as $method) {
+$this->defaultRouteIndex = 0;
+foreach ($this->reader->getMethodAnnotations($method) as $annot) {
+if ($annot instanceof $this->routeAnnotationClass) {
+$this->addRoute($collection, $annot, $globals, $class, $method);
+}
+}
+}
+return $collection;
+}
+protected function addRoute(RouteCollection $collection, $annot, $globals, \ReflectionClass $class, \ReflectionMethod $method)
+{
+if (null === $annot->getName()) {
+$annot->setName($this->getDefaultRouteName($class, $method));
+}
+$defaults = array_merge($globals['defaults'], $annot->getDefaults());
+$requirements = array_merge($globals['requirements'], $annot->getRequirements());
+$options = array_merge($globals['options'], $annot->getOptions());
+$route = new Route($globals['pattern'].$annot->getPattern(), $defaults, $requirements, $options);
+$this->configureRoute($route, $class, $method, $annot);
+$collection->add($annot->getName(), $route);
+}
+/**
+* Returns true if this class supports the given resource.
+*
+* @param mixed  $resource A resource
+* @param string $type     The resource type
+*
+* @return Boolean True if this class supports the given resource, false otherwise
+*/
+public function supports($resource, $type = null)
+{
+return is_string($resource) && preg_match('/^(?:\\\\?[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*)+$/', $resource) && (!$type || 'annotation' === $type);
+}
+/**
+* Sets the loader resolver.
+*
+* @param LoaderResolver $resolver A LoaderResolver instance
+*/
+public function setResolver(LoaderResolver $resolver)
+{
+}
+/**
+* Gets the loader resolver.
+*
+* @return LoaderResolver A LoaderResolver instance
+*/
+public function getResolver()
+{
+}
+/**
+* Gets the default route name for a class method.
+*
+* @param \ReflectionClass $class
+* @param \ReflectionMethod $method
+*
+* @return string
+*/
+protected function getDefaultRouteName(\ReflectionClass $class, \ReflectionMethod $method)
+{
+$name = strtolower(str_replace('\\', '_', $class->getName()).'_'.$method->getName());
+if ($this->defaultRouteIndex > 0) {
+$name .= '_'.$this->defaultRouteIndex;
+}
+$this->defaultRouteIndex++;
+return $name;
+}
+abstract protected function configureRoute(Route $route, \ReflectionClass $class, \ReflectionMethod $method, $annot);
+}