vendor/symfony-cmf/routing/src/DynamicRouter.php line 186

  1. <?php
  3. /*
  4.  * This file is part of the Symfony CMF package.
  5.  *
  6.  * (c) Symfony CMF
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Cmf\Component\Routing;
  14. use Symfony\Cmf\Component\Routing\Enhancer\RouteEnhancerTrait;
  15. use Symfony\Cmf\Component\Routing\Event\Events;
  16. use Symfony\Cmf\Component\Routing\Event\RouterGenerateEvent;
  17. use Symfony\Cmf\Component\Routing\Event\RouterMatchEvent;
  18. use Symfony\Component\EventDispatcher\EventDispatcherInterface;
  19. use Symfony\Component\HttpFoundation\Request;
  20. use Symfony\Component\Routing\Exception\MethodNotAllowedException;
  21. use Symfony\Component\Routing\Exception\ResourceNotFoundException;
  22. use Symfony\Component\Routing\Exception\RouteNotFoundException;
  23. use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
  24. use Symfony\Component\Routing\Matcher\RequestMatcherInterface;
  25. use Symfony\Component\Routing\Matcher\UrlMatcherInterface;
  26. use Symfony\Component\Routing\RequestContext;
  27. use Symfony\Component\Routing\RequestContextAwareInterface;
  28. use Symfony\Component\Routing\RouteCollection;
  30. /**
  31.  * A flexible router accepting matcher and generator through injection and
  32.  * using the RouteEnhancer concept to generate additional data on the routes.
  33.  *
  34.  * @author Larry Garfield
  35.  * @author David Buchmann
  36.  */
  37. class DynamicRouter implements RequestMatcherInterface, ChainedRouterInterface
  38. {
  39.     use RouteEnhancerTrait;
  41.     private RequestMatcherInterface|UrlMatcherInterface $matcher;
  42.     private UrlGeneratorInterface $generator;
  43.     private ?EventDispatcherInterface $eventDispatcher;
  45.     /**
  46.      * The regexp pattern that needs to be matched before a dynamic lookup is
  47.      * made.
  48.      */
  49.     private string $uriFilterRegexp;
  51.     private ?RouteProviderInterface $provider;
  52.     private RequestContext $context;
  53.     private ?RouteCollection $routeCollection = null;
  55.     public function __construct(
  56.         RequestContext $context,
  57.         UrlMatcherInterface|RequestMatcherInterface $matcher,
  58.         UrlGeneratorInterface $generator,
  59.         string $uriFilterRegexp = '',
  60.         ?EventDispatcherInterface $eventDispatcher = null,
  61.         ?RouteProviderInterface $provider = null
  62.     ) {
  63.         $this->context = $context;
  64.         $this->matcher = $matcher;
  65.         $this->generator = $generator;
  66.         $this->eventDispatcher = $eventDispatcher;
  67.         $this->uriFilterRegexp = $uriFilterRegexp;
  68.         $this->provider = $provider;
  70.         $this->generator->setContext($context);
  71.     }
  73.     /**
  74.      * {@inheritdoc}
  75.      */
  76.     public function getRouteCollection(): ?RouteCollection
  77.     {
  78.         if (!$this->routeCollection instanceof RouteCollection) {
  79.             $this->routeCollection = $this->provider
  80.                 ? new LazyRouteCollection($this->provider) : new RouteCollection();
  81.         }
  83.         return $this->routeCollection;
  84.     }
  86.     public function getMatcher(): UrlMatcherInterface|RequestMatcherInterface
  87.     {
  88.         /* we may not set the context in DynamicRouter::setContext as this
  89.          * would lead to symfony cache warmup problems.
  90.          * a request matcher does not need the request context separately as it
  91.          * can get it from the request.
  92.          */
  93.         if ($this->matcher instanceof RequestContextAwareInterface) {
  94.             $this->matcher->setContext($this->getContext());
  95.         }
  97.         return $this->matcher;
  98.     }
  100.     public function getGenerator(): UrlGeneratorInterface
  101.     {
  102.         $this->generator->setContext($this->getContext());
  104.         return $this->generator;
  105.     }
  107.     /**
  108.      * Generates a URL from the given parameters.
  109.      *
  110.      * If the generator is not able to generate the url, it must throw the
  111.      * RouteNotFoundException as documented below.
  112.      *
  113.      * The CMF routing system used to allow to pass route objects as $name to generate the route.
  114.      * To generate the route from a string, pass the RouteObjectInterface::OBJECT_BASED_ROUTE_NAME
  115.      * as route name and the object in the parameters with key RouteObjectInterface::ROUTE_OBJECT.
  116.      *
  117.      * @throws RouteNotFoundException if route doesn't exist
  118.      */
  119.     public function generate(string $name, array $parameters = [], int $referenceType = UrlGeneratorInterface::ABSOLUTE_PATH): string
  120.     {
  121.         if ($this->eventDispatcher) {
  122.             $event = new RouterGenerateEvent($name, $parameters, $referenceType);
  123.             $this->eventDispatcher->dispatch($event, Events::PRE_DYNAMIC_GENERATE);
  124.             $name = $event->getRoute();
  125.             $parameters = $event->getParameters();
  126.             $referenceType = $event->getReferenceType();
  127.         }
  129.         return $this->getGenerator()->generate($name, $parameters, $referenceType);
  130.     }
  132.     /**
  133.      * Tries to match a URL path with a set of routes.
  134.      *
  135.      * If the matcher can not find information, it must throw one of the
  136.      * exceptions documented below.
  137.      *
  138.      * @param string $pathinfo The path info to be parsed (raw format, i.e. not
  139.      *                         urldecoded)
  140.      *
  141.      * @return array An array of parameters
  142.      *
  143.      * @throws ResourceNotFoundException If the resource could not be found
  144.      * @throws MethodNotAllowedException If the resource was found but the
  145.      *                                   request method is not allowed
  146.      *
  147.      * @api
  148.      */
  149.     public function match(string $pathinfo): array
  150.     {
  151.         $request = Request::create($pathinfo);
  152.         if ($this->eventDispatcher) {
  153.             $event = new RouterMatchEvent();
  154.             $this->eventDispatcher->dispatch($event, Events::PRE_DYNAMIC_MATCH);
  155.         }
  157.         if (!empty($this->uriFilterRegexp) && !preg_match($this->uriFilterRegexp, $pathinfo)) {
  158.             throw new ResourceNotFoundException("$pathinfo does not match the '{$this->uriFilterRegexp}' pattern");
  159.         }
  161.         $matcher = $this->getMatcher();
  162.         if (!$matcher instanceof UrlMatcherInterface) {
  163.             throw new \InvalidArgumentException('Wrong matcher type, you need to call matchRequest');
  164.         }
  166.         $defaults = $matcher->match($pathinfo);
  168.         return $this->applyRouteEnhancers($defaults, $request);
  169.     }
  171.     /**
  172.      * Tries to match a request with a set of routes and returns the array of
  173.      * information for that route.
  174.      *
  175.      * If the matcher can not find information, it must throw one of the
  176.      * exceptions documented below.
  177.      *
  178.      * @param Request $request The request to match
  179.      *
  180.      * @return array An array of parameters
  181.      *
  182.      * @throws ResourceNotFoundException If no matching resource could be found
  183.      * @throws MethodNotAllowedException If a matching resource was found but
  184.      *                                   the request method is not allowed
  185.      */
  186.     public function matchRequest(Request $request): array
  187.     {
  188.         if ($this->eventDispatcher) {
  189.             $event = new RouterMatchEvent($request);
  190.             $this->eventDispatcher->dispatch($event, Events::PRE_DYNAMIC_MATCH_REQUEST);
  191.         }
  193.         if ($this->uriFilterRegexp
  194.             && !preg_match($this->uriFilterRegexp, $request->getPathInfo())
  195.         ) {
  196.             throw new ResourceNotFoundException("{$request->getPathInfo()} does not match the '{$this->uriFilterRegexp}' pattern");
  197.         }
  199.         $matcher = $this->getMatcher();
  200.         if ($matcher instanceof UrlMatcherInterface) {
  201.             $defaults = $matcher->match($request->getPathInfo());
  202.         } else {
  203.             $defaults = $matcher->matchRequest($request);
  204.         }
  206.         return $this->applyRouteEnhancers($defaults, $request);
  207.     }
  209.     public function setContext(RequestContext $context): void
  210.     {
  211.         $this->context = $context;
  212.     }
  214.     public function getContext(): RequestContext
  215.     {
  216.         return $this->context;
  217.     }
  219.     /**
  220.      * {@inheritdoc}
  221.      *
  222.      * Forwards to the generator.
  223.      */
  224.     public function getRouteDebugMessage(string $name, array $parameters = []): string
  225.     {
  226.         if ($this->generator instanceof VersatileGeneratorInterface) {
  227.             return $this->generator->getRouteDebugMessage($name, $parameters);
  228.         }
  230.         return "Route '$name' not found";
  231.     }
  232. }