vendor/symfony-cmf/routing/src/NestedMatcher/NestedMatcher.php line 95

  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\NestedMatcher;
  14. use Symfony\Cmf\Component\Routing\RouteProviderInterface;
  15. use Symfony\Component\HttpFoundation\Request;
  16. use Symfony\Component\Routing\Exception\ResourceNotFoundException;
  17. use Symfony\Component\Routing\Matcher\RequestMatcherInterface;
  19. /**
  20.  * A more flexible approach to matching. The route collection to match against
  21.  * can be dynamically determined based on the request and users can inject
  22.  * their own filters or use a custom final matching strategy.
  23.  *
  24.  * The nested matcher splits matching into three configurable steps:
  25.  *
  26.  * 1) Get potential matches from a RouteProviderInterface
  27.  * 2) Apply any RouteFilterInterface to reduce the route collection
  28.  * 3) Have FinalMatcherInterface select the best match of the remaining routes
  29.  *
  30.  * @author Larry Garfield
  31.  * @author David Buchmann
  32.  */
  33. final class NestedMatcher implements RequestMatcherInterface
  34. {
  35.     /**
  36.      * The route provider responsible for the first-pass match.
  37.      */
  38.     private RouteProviderInterface $routeProvider;
  40.     private FinalMatcherInterface $finalMatcher;
  42.     /**
  43.      * @var RouteFilterInterface[]
  44.      */
  45.     private array $filters = [];
  47.     /**
  48.      * For caching the sorted $filters.
  49.      *
  50.      * @var RouteFilterInterface[]
  51.      */
  52.     private array $sortedFilters = [];
  54.     public function __construct(RouteProviderInterface $provider, FinalMatcherInterface $final)
  55.     {
  56.         $this->setRouteProvider($provider);
  57.         $this->setFinalMatcher($final);
  58.     }
  60.     public function setRouteProvider(RouteProviderInterface $provider): static
  61.     {
  62.         $this->routeProvider = $provider;
  64.         return $this;
  65.     }
  67.     /**
  68.      * Adds a partial matcher to the matching plan.
  69.      *
  70.      * Partial matchers will be run in the order in which they are added.
  71.      *
  72.      * @param int $priority (optional) The priority of the
  73.      *                      filter. Higher number filters will
  74.      *                      be used first. Defaults to 0
  75.      */
  76.     public function addRouteFilter(RouteFilterInterface $filter, int $priority = 0): static
  77.     {
  78.         if (!\array_key_exists($priority, $this->filters)) {
  79.             $this->filters[$priority] = [];
  80.         }
  82.         $this->filters[$priority][] = $filter;
  83.         $this->sortedFilters = [];
  85.         return $this;
  86.     }
  88.     public function setFinalMatcher(FinalMatcherInterface $final): static
  89.     {
  90.         $this->finalMatcher = $final;
  92.         return $this;
  93.     }
  95.     public function matchRequest(Request $request): array
  96.     {
  97.         $collection = $this->routeProvider->getRouteCollectionForRequest($request);
  98.         if (!count($collection)) {
  99.             throw new ResourceNotFoundException();
  100.         }
  102.         // Route filters are expected to throw an exception themselves if they
  103.         // end up filtering the list down to 0.
  104.         foreach ($this->getRouteFilters() as $filter) {
  105.             $collection = $filter->filter($collection, $request);
  106.         }
  108.         return $this->finalMatcher->finalMatch($collection, $request);
  109.     }
  111.     /**
  112.      * Sorts the filters and flattens them.
  113.      *
  114.      * @return RouteFilterInterface[] the filters ordered by priority
  115.      */
  116.     public function getRouteFilters(): array
  117.     {
  118.         if (0 === count($this->sortedFilters)) {
  119.             $this->sortedFilters = $this->sortFilters();
  120.         }
  122.         return $this->sortedFilters;
  123.     }
  125.     /**
  126.      * Sort filters by priority.
  127.      *
  128.      * The highest priority number is the highest priority (reverse sorting).
  129.      *
  130.      * @return RouteFilterInterface[] the sorted filters
  131.      */
  132.     private function sortFilters(): array
  133.     {
  134.         if (0 === count($this->filters)) {
  135.             return [];
  136.         }
  138.         krsort($this->filters);
  140.         return call_user_func_array('array_merge', $this->filters);
  141.     }
  142. }