[Summary view] [Print] [Text view]

   1  <?php
   2  
   3  /*
   4   * This file is part of the Symfony package.
   5   *
   6   * (c) Fabien Potencier <fabien@symfony.com>
   7   *
   8   * For the full copyright and license information, please view the LICENSE
   9   * file that was distributed with this source code.
  10   */
  11  
  12  namespace Symfony\Component\Routing\Loader;
  13  
  14  use Doctrine\Common\Annotations\Reader;
  15  use Symfony\Component\Config\Resource\FileResource;
  16  use Symfony\Component\Routing\Route;
  17  use Symfony\Component\Routing\RouteCollection;
  18  use Symfony\Component\Config\Loader\LoaderInterface;
  19  use Symfony\Component\Config\Loader\LoaderResolverInterface;
  20  
  21  /**
  22   * AnnotationClassLoader loads routing information from a PHP class and its methods.
  23   *
  24   * You need to define an implementation for the getRouteDefaults() method. Most of the
  25   * time, this method should define some PHP callable to be called for the route
  26   * (a controller in MVC speak).
  27   *
  28   * The @Route annotation can be set on the class (for global parameters),
  29   * and on each method.
  30   *
  31   * The @Route annotation main value is the route path. The annotation also
  32   * recognizes several parameters: requirements, options, defaults, schemes,
  33   * methods, host, and name. The name parameter is mandatory.
  34   * Here is an example of how you should be able to use it:
  35   *
  36   *     /**
  37   *      * @Route("/Blog")
  38   *      * /
  39   *     class Blog
  40   *     {
  41   *         /**
  42   *          * @Route("/", name="blog_index")
  43   *          * /
  44   *         public function index()
  45   *         {
  46   *         }
  47   *
  48   *         /**
  49   *          * @Route("/{id}", name="blog_post", requirements = {"id" = "\d+"})
  50   *          * /
  51   *         public function show()
  52   *         {
  53   *         }
  54   *     }
  55   *
  56   * @author Fabien Potencier <fabien@symfony.com>
  57   */
  58  abstract class AnnotationClassLoader implements LoaderInterface
  59  {
  60      /**
  61       * @var Reader
  62       */
  63      protected $reader;
  64  
  65      /**
  66       * @var string
  67       */
  68      protected $routeAnnotationClass = 'Symfony\\Component\\Routing\\Annotation\\Route';
  69  
  70      /**
  71       * @var int
  72       */
  73      protected $defaultRouteIndex = 0;
  74  
  75      /**
  76       * Constructor.
  77       *
  78       * @param Reader $reader
  79       */
  80      public function __construct(Reader $reader)
  81      {
  82          $this->reader = $reader;
  83      }
  84  
  85      /**
  86       * Sets the annotation class to read route properties from.
  87       *
  88       * @param string $class A fully-qualified class name
  89       */
  90      public function setRouteAnnotationClass($class)
  91      {
  92          $this->routeAnnotationClass = $class;
  93      }
  94  
  95      /**
  96       * Loads from annotations from a class.
  97       *
  98       * @param string      $class A class name
  99       * @param string|null $type  The resource type
 100       *
 101       * @return RouteCollection A RouteCollection instance
 102       *
 103       * @throws \InvalidArgumentException When route can't be parsed
 104       */
 105      public function load($class, $type = null)
 106      {
 107          if (!class_exists($class)) {
 108              throw new \InvalidArgumentException(sprintf('Class "%s" does not exist.', $class));
 109          }
 110  
 111          $globals = array(
 112              'path' => '',
 113              'requirements' => array(),
 114              'options' => array(),
 115              'defaults' => array(),
 116              'schemes' => array(),
 117              'methods' => array(),
 118              'host' => '',
 119          );
 120  
 121          $class = new \ReflectionClass($class);
 122          if ($class->isAbstract()) {
 123              throw new \InvalidArgumentException(sprintf('Annotations from class "%s" cannot be read as it is abstract.', $class->getName()));
 124          }
 125  
 126          if ($annot = $this->reader->getClassAnnotation($class, $this->routeAnnotationClass)) {
 127              // for BC reasons
 128              if (null !== $annot->getPath()) {
 129                  $globals['path'] = $annot->getPath();
 130              } elseif (null !== $annot->getPattern()) {
 131                  $globals['path'] = $annot->getPattern();
 132              }
 133  
 134              if (null !== $annot->getRequirements()) {
 135                  $globals['requirements'] = $annot->getRequirements();
 136              }
 137  
 138              if (null !== $annot->getOptions()) {
 139                  $globals['options'] = $annot->getOptions();
 140              }
 141  
 142              if (null !== $annot->getDefaults()) {
 143                  $globals['defaults'] = $annot->getDefaults();
 144              }
 145  
 146              if (null !== $annot->getSchemes()) {
 147                  $globals['schemes'] = $annot->getSchemes();
 148              }
 149  
 150              if (null !== $annot->getMethods()) {
 151                  $globals['methods'] = $annot->getMethods();
 152              }
 153  
 154              if (null !== $annot->getHost()) {
 155                  $globals['host'] = $annot->getHost();
 156              }
 157          }
 158  
 159          $collection = new RouteCollection();
 160          $collection->addResource(new FileResource($class->getFileName()));
 161  
 162          foreach ($class->getMethods() as $method) {
 163              $this->defaultRouteIndex = 0;
 164              foreach ($this->reader->getMethodAnnotations($method) as $annot) {
 165                  if ($annot instanceof $this->routeAnnotationClass) {
 166                      $this->addRoute($collection, $annot, $globals, $class, $method);
 167                  }
 168              }
 169          }
 170  
 171          return $collection;
 172      }
 173  
 174      protected function addRoute(RouteCollection $collection, $annot, $globals, \ReflectionClass $class, \ReflectionMethod $method)
 175      {
 176          $name = $annot->getName();
 177          if (null === $name) {
 178              $name = $this->getDefaultRouteName($class, $method);
 179          }
 180  
 181          $defaults = array_replace($globals['defaults'], $annot->getDefaults());
 182          foreach ($method->getParameters() as $param) {
 183              if (!isset($defaults[$param->getName()]) && $param->isDefaultValueAvailable()) {
 184                  $defaults[$param->getName()] = $param->getDefaultValue();
 185              }
 186          }
 187          $requirements = array_replace($globals['requirements'], $annot->getRequirements());
 188          $options = array_replace($globals['options'], $annot->getOptions());
 189          $schemes = array_replace($globals['schemes'], $annot->getSchemes());
 190          $methods = array_replace($globals['methods'], $annot->getMethods());
 191  
 192          $host = $annot->getHost();
 193          if (null === $host) {
 194              $host = $globals['host'];
 195          }
 196  
 197          $route = new Route($globals['path'].$annot->getPath(), $defaults, $requirements, $options, $host, $schemes, $methods);
 198  
 199          $this->configureRoute($route, $class, $method, $annot);
 200  
 201          $collection->add($name, $route);
 202      }
 203  
 204      /**
 205       * {@inheritdoc}
 206       */
 207      public function supports($resource, $type = null)
 208      {
 209          return is_string($resource) && preg_match('/^(?:\\\\?[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*)+$/', $resource) && (!$type || 'annotation' === $type);
 210      }
 211  
 212      /**
 213       * {@inheritdoc}
 214       */
 215      public function setResolver(LoaderResolverInterface $resolver)
 216      {
 217      }
 218  
 219      /**
 220       * {@inheritdoc}
 221       */
 222      public function getResolver()
 223      {
 224      }
 225  
 226      /**
 227       * Gets the default route name for a class method.
 228       *
 229       * @param \ReflectionClass  $class
 230       * @param \ReflectionMethod $method
 231       *
 232       * @return string
 233       */
 234      protected function getDefaultRouteName(\ReflectionClass $class, \ReflectionMethod $method)
 235      {
 236          $name = strtolower(str_replace('\\', '_', $class->name).'_'.$method->name);
 237          if ($this->defaultRouteIndex > 0) {
 238              $name .= '_'.$this->defaultRouteIndex;
 239          }
 240          ++$this->defaultRouteIndex;
 241  
 242          return $name;
 243      }
 244  
 245      abstract protected function configureRoute(Route $route, \ReflectionClass $class, \ReflectionMethod $method, $annot);
 246  }