Upgrade framework

vendor/symfony/routing/Loader/AnnotationClassLoader.php

@@ -12,16 +12,17 @@
 namespace Symfony\Component\Routing\Loader;
 
 use Doctrine\Common\Annotations\Reader;
-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\LoaderResolverInterface;
+use Symfony\Component\Config\Resource\FileResource;
+use Symfony\Component\Routing\Annotation\Route as RouteAnnotation;
+use Symfony\Component\Routing\Route;
+use Symfony\Component\Routing\RouteCollection;
 
 /**
  * AnnotationClassLoader loads routing information from a PHP class and its methods.
  *
- * You need to define an implementation for the getRouteDefaults() method. Most of the
+ * You need to define an implementation for the configureRoute() method. Most of the
  * time, this method should define some PHP callable to be called for the route
  * (a controller in MVC speak).
  *
@@ -32,7 +33,6 @@ use Symfony\Component\Config\Loader\LoaderResolverInterface;
  * recognizes several parameters: requirements, options, defaults, schemes,
  * methods, host, and name. The name parameter is mandatory.
  * Here is an example of how you should be able to use it:
- *
  *     /**
  *      * @Route("/Blog")
  *      * /
@@ -44,7 +44,6 @@ use Symfony\Component\Config\Loader\LoaderResolverInterface;
  *         public function index()
  *         {
  *         }
- *
  *         /**
  *          * @Route("/{id}", name="blog_post", requirements = {"id" = "\d+"})
  *          * /
@@ -52,42 +51,50 @@ use Symfony\Component\Config\Loader\LoaderResolverInterface;
  *         {
  *         }
  *     }
+ *
+ * On PHP 8, the annotation class can be used as an attribute as well:
+ *     #[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>
+ * @author Alexander M. Turek <me@derrabus.de>
  */
 abstract class AnnotationClassLoader implements LoaderInterface
 {
-    /**
-     * @var Reader
-     */
     protected $reader;
+    protected $env;
 
     /**
      * @var string
      */
-    protected $routeAnnotationClass = 'Symfony\\Component\\Routing\\Annotation\\Route';
+    protected $routeAnnotationClass = RouteAnnotation::class;
 
     /**
      * @var int
      */
     protected $defaultRouteIndex = 0;
 
-    /**
-     * Constructor.
-     *
-     * @param Reader $reader
-     */
-    public function __construct(Reader $reader)
+    public function __construct(Reader $reader = null, string $env = null)
     {
         $this->reader = $reader;
+        $this->env = $env;
     }
 
     /**
      * Sets the annotation class to read route properties from.
-     *
-     * @param string $class A fully-qualified class name
      */
-    public function setRouteAnnotationClass($class)
+    public function setRouteAnnotationClass(string $class)
     {
         $this->routeAnnotationClass = $class;
     }
@@ -95,14 +102,9 @@ abstract class AnnotationClassLoader implements LoaderInterface
     /**
      * Loads from annotations from a class.
      *
-     * @param string      $class A class name
-     * @param string|null $type  The resource type
-     *
-     * @return RouteCollection A RouteCollection instance
-     *
      * @throws \InvalidArgumentException When route can't be parsed
      */
-    public function load($class, $type = null)
+    public function load(mixed $class, string $type = null): RouteCollection
     {
         if (!class_exists($class)) {
             throw new \InvalidArgumentException(sprintf('Class "%s" does not exist.', $class));
@@ -118,37 +120,52 @@ abstract class AnnotationClassLoader implements LoaderInterface
         $collection = new RouteCollection();
         $collection->addResource(new FileResource($class->getFileName()));
 
+        if ($globals['env'] && $this->env !== $globals['env']) {
+            return $collection;
+        }
+
         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);
-                }
+            foreach ($this->getAnnotations($method) as $annot) {
+                $this->addRoute($collection, $annot, $globals, $class, $method);
             }
         }
 
-        if (0 === $collection->count() && $class->hasMethod('__invoke') && $annot = $this->reader->getClassAnnotation($class, $this->routeAnnotationClass)) {
-            $globals['path'] = '';
-            $this->addRoute($collection, $annot, $globals, $class, $class->getMethod('__invoke'));
+        if (0 === $collection->count() && $class->hasMethod('__invoke')) {
+            $globals = $this->resetGlobals();
+            foreach ($this->getAnnotations($class) as $annot) {
+                $this->addRoute($collection, $annot, $globals, $class, $class->getMethod('__invoke'));
+            }
         }
 
         return $collection;
     }
 
-    protected function addRoute(RouteCollection $collection, $annot, $globals, \ReflectionClass $class, \ReflectionMethod $method)
+    /**
+     * @param RouteAnnotation $annot or an object that exposes a similar interface
+     */
+    protected function addRoute(RouteCollection $collection, object $annot, array $globals, \ReflectionClass $class, \ReflectionMethod $method)
     {
+        if ($annot->getEnv() && $annot->getEnv() !== $this->env) {
+            return;
+        }
+
         $name = $annot->getName();
         if (null === $name) {
             $name = $this->getDefaultRouteName($class, $method);
         }
+        $name = $globals['name'].$name;
 
-        $defaults = array_replace($globals['defaults'], $annot->getDefaults());
-        foreach ($method->getParameters() as $param) {
-            if (false !== strpos($globals['path'].$annot->getPath(), sprintf('{%s}', $param->getName())) && !isset($defaults[$param->getName()]) && $param->isDefaultValueAvailable()) {
-                $defaults[$param->getName()] = $param->getDefaultValue();
+        $requirements = $annot->getRequirements();
+
+        foreach ($requirements as $placeholder => $requirement) {
+            if (\is_int($placeholder)) {
+                throw new \InvalidArgumentException(sprintf('A placeholder name must be a string (%d given). Did you forget to specify the placeholder key for the requirement "%s" of route "%s" in "%s::%s()"?', $placeholder, $requirement, $name, $class->getName(), $method->getName()));
             }
         }
-        $requirements = array_replace($globals['requirements'], $annot->getRequirements());
+
+        $defaults = array_replace($globals['defaults'], $annot->getDefaults());
+        $requirements = array_replace($globals['requirements'], $requirements);
         $options = array_replace($globals['options'], $annot->getOptions());
         $schemes = array_merge($globals['schemes'], $annot->getSchemes());
         $methods = array_merge($globals['methods'], $annot->getMethods());
@@ -158,24 +175,69 @@ abstract class AnnotationClassLoader implements LoaderInterface
             $host = $globals['host'];
         }
 
-        $condition = $annot->getCondition();
-        if (null === $condition) {
-            $condition = $globals['condition'];
+        $condition = $annot->getCondition() ?? $globals['condition'];
+        $priority = $annot->getPriority() ?? $globals['priority'];
+
+        $path = $annot->getLocalizedPaths() ?: $annot->getPath();
+        $prefix = $globals['localized_paths'] ?: $globals['path'];
+        $paths = [];
+
+        if (\is_array($path)) {
+            if (!\is_array($prefix)) {
+                foreach ($path as $locale => $localePath) {
+                    $paths[$locale] = $prefix.$localePath;
+                }
+            } elseif ($missing = array_diff_key($prefix, $path)) {
+                throw new \LogicException(sprintf('Route to "%s" is missing paths for locale(s) "%s".', $class->name.'::'.$method->name, implode('", "', array_keys($missing))));
+            } else {
+                foreach ($path as $locale => $localePath) {
+                    if (!isset($prefix[$locale])) {
+                        throw new \LogicException(sprintf('Route to "%s" with locale "%s" is missing a corresponding prefix in class "%s".', $method->name, $locale, $class->name));
+                    }
+
+                    $paths[$locale] = $prefix[$locale].$localePath;
+                }
+            }
+        } elseif (\is_array($prefix)) {
+            foreach ($prefix as $locale => $localePrefix) {
+                $paths[$locale] = $localePrefix.$path;
+            }
+        } else {
+            $paths[] = $prefix.$path;
         }
 
-        $route = $this->createRoute($globals['path'].$annot->getPath(), $defaults, $requirements, $options, $host, $schemes, $methods, $condition);
+        foreach ($method->getParameters() as $param) {
+            if (isset($defaults[$param->name]) || !$param->isDefaultValueAvailable()) {
+                continue;
+            }
+            foreach ($paths as $locale => $path) {
+                if (preg_match(sprintf('/\{%s(?:<.*?>)?\}/', preg_quote($param->name)), $path)) {
+                    $defaults[$param->name] = $param->getDefaultValue();
+                    break;
+                }
+            }
+        }
 
-        $this->configureRoute($route, $class, $method, $annot);
-
-        $collection->add($name, $route);
+        foreach ($paths as $locale => $path) {
+            $route = $this->createRoute($path, $defaults, $requirements, $options, $host, $schemes, $methods, $condition);
+            $this->configureRoute($route, $class, $method, $annot);
+            if (0 !== $locale) {
+                $route->setDefault('_locale', $locale);
+                $route->setRequirement('_locale', preg_quote($locale));
+                $route->setDefault('_canonical_route', $name);
+                $collection->add($name.'.'.$locale, $route, $priority);
+            } else {
+                $collection->add($name, $route, $priority);
+            }
+        }
     }
 
     /**
      * {@inheritdoc}
      */
-    public function supports($resource, $type = null)
+    public function supports(mixed $resource, string $type = null): bool
     {
-        return is_string($resource) && preg_match('/^(?:\\\\?[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*)+$/', $resource) && (!$type || 'annotation' === $type);
+        return \is_string($resource) && preg_match('/^(?:\\\\?[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*)+$/', $resource) && (!$type || 'annotation' === $type);
     }
 
     /**
@@ -188,21 +250,19 @@ abstract class AnnotationClassLoader implements LoaderInterface
     /**
      * {@inheritdoc}
      */
-    public function getResolver()
+    public function getResolver(): LoaderResolverInterface
     {
     }
 
     /**
      * 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->name).'_'.$method->name);
+        $name = str_replace('\\', '_', $class->name).'_'.$method->name;
+        $name = \function_exists('mb_strtolower') && preg_match('//u', $name) ? mb_strtolower($name, 'UTF-8') : strtolower($name);
         if ($this->defaultRouteIndex > 0) {
             $name .= '_'.$this->defaultRouteIndex;
         }
@@ -213,22 +273,27 @@ abstract class AnnotationClassLoader implements LoaderInterface
 
     protected function getGlobals(\ReflectionClass $class)
     {
-        $globals = array(
-            'path' => '',
-            'requirements' => array(),
-            'options' => array(),
-            'defaults' => array(),
-            'schemes' => array(),
-            'methods' => array(),
-            'host' => '',
-            'condition' => '',
-        );
+        $globals = $this->resetGlobals();
+
+        $annot = null;
+        if ($attribute = $class->getAttributes($this->routeAnnotationClass, \ReflectionAttribute::IS_INSTANCEOF)[0] ?? null) {
+            $annot = $attribute->newInstance();
+        }
+        if (!$annot && $this->reader) {
+            $annot = $this->reader->getClassAnnotation($class, $this->routeAnnotationClass);
+        }
+
+        if ($annot) {
+            if (null !== $annot->getName()) {
+                $globals['name'] = $annot->getName();
+            }
 
-        if ($annot = $this->reader->getClassAnnotation($class, $this->routeAnnotationClass)) {
             if (null !== $annot->getPath()) {
                 $globals['path'] = $annot->getPath();
             }
 
+            $globals['localized_paths'] = $annot->getLocalizedPaths();
+
             if (null !== $annot->getRequirements()) {
                 $globals['requirements'] = $annot->getRequirements();
             }
@@ -256,15 +321,68 @@ abstract class AnnotationClassLoader implements LoaderInterface
             if (null !== $annot->getCondition()) {
                 $globals['condition'] = $annot->getCondition();
             }
+
+            $globals['priority'] = $annot->getPriority() ?? 0;
+            $globals['env'] = $annot->getEnv();
+
+            foreach ($globals['requirements'] as $placeholder => $requirement) {
+                if (\is_int($placeholder)) {
+                    throw new \InvalidArgumentException(sprintf('A placeholder name must be a string (%d given). Did you forget to specify the placeholder key for the requirement "%s" in "%s"?', $placeholder, $requirement, $class->getName()));
+                }
+            }
         }
 
         return $globals;
     }
 
-    protected function createRoute($path, $defaults, $requirements, $options, $host, $schemes, $methods, $condition)
+    private function resetGlobals(): array
+    {
+        return [
+            'path' => null,
+            'localized_paths' => [],
+            'requirements' => [],
+            'options' => [],
+            'defaults' => [],
+            'schemes' => [],
+            'methods' => [],
+            'host' => '',
+            'condition' => '',
+            'name' => '',
+            'priority' => 0,
+            'env' => null,
+        ];
+    }
+
+    protected function createRoute(string $path, array $defaults, array $requirements, array $options, ?string $host, array $schemes, array $methods, ?string $condition)
     {
         return new Route($path, $defaults, $requirements, $options, $host, $schemes, $methods, $condition);
     }
 
-    abstract protected function configureRoute(Route $route, \ReflectionClass $class, \ReflectionMethod $method, $annot);
+    abstract protected function configureRoute(Route $route, \ReflectionClass $class, \ReflectionMethod $method, object $annot);
+
+    /**
+     * @param \ReflectionClass|\ReflectionMethod $reflection
+     *
+     * @return iterable<int, RouteAnnotation>
+     */
+    private function getAnnotations(object $reflection): iterable
+    {
+        foreach ($reflection->getAttributes($this->routeAnnotationClass, \ReflectionAttribute::IS_INSTANCEOF) as $attribute) {
+            yield $attribute->newInstance();
+        }
+
+        if (!$this->reader) {
+            return;
+        }
+
+        $anntotations = $reflection instanceof \ReflectionClass
+            ? $this->reader->getClassAnnotations($reflection)
+            : $this->reader->getMethodAnnotations($reflection);
+
+        foreach ($anntotations as $annotation) {
+            if ($annotation instanceof $this->routeAnnotationClass) {
+                yield $annotation;
+            }
+        }
+    }
 }

vendor/symfony/routing/Loader/AnnotationDirectoryLoader.php

@@ -11,8 +11,8 @@
 
 namespace Symfony\Component\Routing\Loader;
 
-use Symfony\Component\Routing\RouteCollection;
 use Symfony\Component\Config\Resource\DirectoryResource;
+use Symfony\Component\Routing\RouteCollection;
 
 /**
  * AnnotationDirectoryLoader loads routing information from annotations set
@@ -23,18 +23,13 @@ use Symfony\Component\Config\Resource\DirectoryResource;
 class AnnotationDirectoryLoader extends AnnotationFileLoader
 {
     /**
-     * Loads from annotations from a directory.
-     *
-     * @param string      $path A directory path
-     * @param string|null $type The resource type
-     *
-     * @return RouteCollection A RouteCollection instance
-     *
      * @throws \InvalidArgumentException When the directory does not exist or its routes cannot be parsed
      */
-    public function load($path, $type = null)
+    public function load(mixed $path, string $type = null): ?RouteCollection
     {
-        $dir = $this->locator->locate($path);
+        if (!is_dir($dir = $this->locator->locate($path))) {
+            return parent::supports($path, $type) ? parent::load($path, $type) : new RouteCollection();
+        }
 
         $collection = new RouteCollection();
         $collection->addResource(new DirectoryResource($dir, '/\.php$/'));
@@ -52,7 +47,7 @@ class AnnotationDirectoryLoader extends AnnotationFileLoader
         });
 
         foreach ($files as $file) {
-            if (!$file->isFile() || '.php' !== substr($file->getFilename(), -4)) {
+            if (!$file->isFile() || !str_ends_with($file->getFilename(), '.php')) {
                 continue;
             }
 
@@ -72,18 +67,20 @@ class AnnotationDirectoryLoader extends AnnotationFileLoader
     /**
      * {@inheritdoc}
      */
-    public function supports($resource, $type = null)
+    public function supports(mixed $resource, string $type = null): bool
     {
-        if (!is_string($resource)) {
+        if ('annotation' === $type) {
+            return true;
+        }
+
+        if ($type || !\is_string($resource)) {
             return false;
         }
 
         try {
-            $path = $this->locator->locate($resource);
+            return is_dir($this->locator->locate($resource));
         } catch (\Exception $e) {
             return false;
         }
-
-        return is_dir($path) && (!$type || 'annotation' === $type);
     }
 }

vendor/symfony/routing/Loader/AnnotationFileLoader.php

@@ -11,10 +11,10 @@
 
 namespace Symfony\Component\Routing\Loader;
 
-use Symfony\Component\Routing\RouteCollection;
-use Symfony\Component\Config\Resource\FileResource;
-use Symfony\Component\Config\Loader\FileLoader;
 use Symfony\Component\Config\FileLocatorInterface;
+use Symfony\Component\Config\Loader\FileLoader;
+use Symfony\Component\Config\Resource\FileResource;
+use Symfony\Component\Routing\RouteCollection;
 
 /**
  * AnnotationFileLoader loads routing information from annotations set
@@ -26,18 +26,10 @@ class AnnotationFileLoader extends FileLoader
 {
     protected $loader;
 
-    /**
-     * Constructor.
-     *
-     * @param FileLocatorInterface  $locator A FileLocator instance
-     * @param AnnotationClassLoader $loader  An AnnotationClassLoader instance
-     *
-     * @throws \RuntimeException
-     */
     public function __construct(FileLocatorInterface $locator, AnnotationClassLoader $loader)
     {
-        if (!function_exists('token_get_all')) {
-            throw new \RuntimeException('The Tokenizer extension is required for the routing annotation loaders.');
+        if (!\function_exists('token_get_all')) {
+            throw new \LogicException('The Tokenizer extension is required for the routing annotation loaders.');
         }
 
         parent::__construct($locator);
@@ -48,26 +40,24 @@ class AnnotationFileLoader extends FileLoader
     /**
      * Loads from annotations from a file.
      *
-     * @param string      $file A PHP file path
-     * @param string|null $type The resource type
-     *
-     * @return RouteCollection A RouteCollection instance
-     *
      * @throws \InvalidArgumentException When the file does not exist or its routes cannot be parsed
      */
-    public function load($file, $type = null)
+    public function load(mixed $file, string $type = null): ?RouteCollection
     {
         $path = $this->locator->locate($file);
 
         $collection = new RouteCollection();
         if ($class = $this->findClass($path)) {
+            $refl = new \ReflectionClass($class);
+            if ($refl->isAbstract()) {
+                return null;
+            }
+
             $collection->addResource(new FileResource($path));
             $collection->addCollection($this->loader->load($class, $type));
         }
-        if (\PHP_VERSION_ID >= 70000) {
-            // PHP 7 memory manager will not release after token_get_all(), see https://bugs.php.net/70098
-            gc_mem_caches();
-        }
+
+        gc_mem_caches();
 
         return $collection;
     }
@@ -75,69 +65,71 @@ class AnnotationFileLoader extends FileLoader
     /**
      * {@inheritdoc}
      */
-    public function supports($resource, $type = null)
+    public function supports(mixed $resource, string $type = null): bool
     {
-        return is_string($resource) && 'php' === pathinfo($resource, PATHINFO_EXTENSION) && (!$type || 'annotation' === $type);
+        return \is_string($resource) && 'php' === pathinfo($resource, \PATHINFO_EXTENSION) && (!$type || 'annotation' === $type);
     }
 
     /**
      * Returns the full class name for the first class in the file.
-     *
-     * @param string $file A PHP file path
-     *
-     * @return string|false Full class name if found, false otherwise
      */
-    protected function findClass($file)
+    protected function findClass(string $file): string|false
     {
         $class = false;
         $namespace = false;
         $tokens = token_get_all(file_get_contents($file));
 
-        if (1 === count($tokens) && T_INLINE_HTML === $tokens[0][0]) {
+        if (1 === \count($tokens) && \T_INLINE_HTML === $tokens[0][0]) {
             throw new \InvalidArgumentException(sprintf('The file "%s" does not contain PHP code. Did you forgot to add the "<?php" start tag at the beginning of the file?', $file));
         }
 
+        $nsTokens = [\T_NS_SEPARATOR => true, \T_STRING => true];
+        if (\defined('T_NAME_QUALIFIED')) {
+            $nsTokens[\T_NAME_QUALIFIED] = true;
+        }
         for ($i = 0; isset($tokens[$i]); ++$i) {
             $token = $tokens[$i];
-
             if (!isset($token[1])) {
                 continue;
             }
 
-            if (true === $class && T_STRING === $token[0]) {
+            if (true === $class && \T_STRING === $token[0]) {
                 return $namespace.'\\'.$token[1];
             }
 
-            if (true === $namespace && T_STRING === $token[0]) {
+            if (true === $namespace && isset($nsTokens[$token[0]])) {
                 $namespace = $token[1];
-                while (isset($tokens[++$i][1]) && in_array($tokens[$i][0], array(T_NS_SEPARATOR, T_STRING))) {
+                while (isset($tokens[++$i][1], $nsTokens[$tokens[$i][0]])) {
                     $namespace .= $tokens[$i][1];
                 }
                 $token = $tokens[$i];
             }
 
-            if (T_CLASS === $token[0]) {
-                // Skip usage of ::class constant
-                $isClassConstant = false;
+            if (\T_CLASS === $token[0]) {
+                // Skip usage of ::class constant and anonymous classes
+                $skipClassToken = false;
                 for ($j = $i - 1; $j > 0; --$j) {
                     if (!isset($tokens[$j][1])) {
+                        if ('(' === $tokens[$j] || ',' === $tokens[$j]) {
+                            $skipClassToken = true;
+                        }
                         break;
                     }
 
-                    if (T_DOUBLE_COLON === $tokens[$j][0]) {
-                        $isClassConstant = true;
+                    if (\T_DOUBLE_COLON === $tokens[$j][0] || \T_NEW === $tokens[$j][0]) {
+                        $skipClassToken = true;
                         break;
-                    } elseif (!in_array($tokens[$j][0], array(T_WHITESPACE, T_DOC_COMMENT, T_COMMENT))) {
+                    } elseif (!\in_array($tokens[$j][0], [\T_WHITESPACE, \T_DOC_COMMENT, \T_COMMENT])) {
                         break;
                     }
                 }
 
-                if (!$isClassConstant) {
+                if (!$skipClassToken) {
                     $class = true;
                 }
             }
 
-            if (T_NAMESPACE === $token[0]) {
+            if (\T_NAMESPACE === $token[0]) {
                 $namespace = true;
             }
         }

vendor/symfony/routing/Loader/ClosureLoader.php

@@ -25,21 +25,16 @@ class ClosureLoader extends Loader
 {
     /**
      * Loads a Closure.
-     *
-     * @param \Closure    $closure A Closure
-     * @param string|null $type    The resource type
-     *
-     * @return RouteCollection A RouteCollection instance
      */
-    public function load($closure, $type = null)
+    public function load(mixed $closure, string $type = null): RouteCollection
     {
-        return $closure();
+        return $closure($this->env);
     }
 
     /**
      * {@inheritdoc}
      */
-    public function supports($resource, $type = null)
+    public function supports(mixed $resource, string $type = null): bool
     {
         return $resource instanceof \Closure && (!$type || 'closure' === $type);
     }

vendor/symfony/routing/Loader/Configurator/AliasConfigurator.php

@@ -0,0 +1,43 @@
+<?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\Configurator;
+
+use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
+use Symfony\Component\Routing\Alias;
+
+class AliasConfigurator
+{
+    private $alias;
+
+    public function __construct(Alias $alias)
+    {
+        $this->alias = $alias;
+    }
+
+    /**
+     * Whether this alias is deprecated, that means it should not be called anymore.
+     *
+     * @param string $package The name of the composer package that is triggering the deprecation
+     * @param string $version The version of the package that introduced the deprecation
+     * @param string $message The deprecation message to use
+     *
+     * @return $this
+     *
+     * @throws InvalidArgumentException when the message template is invalid
+     */
+    public function deprecate(string $package, string $version, string $message): static
+    {
+        $this->alias->setDeprecated($package, $version, $message);
+
+        return $this;
+    }
+}

vendor/symfony/routing/Loader/Configurator/CollectionConfigurator.php

@@ -0,0 +1,122 @@
+<?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\Configurator;
+
+use Symfony\Component\Routing\Route;
+use Symfony\Component\Routing\RouteCollection;
+
+/**
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+class CollectionConfigurator
+{
+    use Traits\AddTrait;
+    use Traits\HostTrait;
+    use Traits\RouteTrait;
+
+    private $parent;
+    private $parentConfigurator;
+    private ?array $parentPrefixes;
+    private string|array|null $host = null;
+
+    public function __construct(RouteCollection $parent, string $name, self $parentConfigurator = null, array $parentPrefixes = null)
+    {
+        $this->parent = $parent;
+        $this->name = $name;
+        $this->collection = new RouteCollection();
+        $this->route = new Route('');
+        $this->parentConfigurator = $parentConfigurator; // for GC control
+        $this->parentPrefixes = $parentPrefixes;
+    }
+
+    public function __sleep(): array
+    {
+        throw new \BadMethodCallException('Cannot serialize '.__CLASS__);
+    }
+
+    public function __wakeup()
+    {
+        throw new \BadMethodCallException('Cannot unserialize '.__CLASS__);
+    }
+
+    public function __destruct()
+    {
+        if (null === $this->prefixes) {
+            $this->collection->addPrefix($this->route->getPath());
+        }
+        if (null !== $this->host) {
+            $this->addHost($this->collection, $this->host);
+        }
+
+        $this->parent->addCollection($this->collection);
+    }
+
+    /**
+     * Creates a sub-collection.
+     */
+    final public function collection(string $name = ''): self
+    {
+        return new self($this->collection, $this->name.$name, $this, $this->prefixes);
+    }
+
+    /**
+     * Sets the prefix to add to the path of all child routes.
+     *
+     * @param string|array $prefix the prefix, or the localized prefixes
+     *
+     * @return $this
+     */
+    final public function prefix(string|array $prefix): static
+    {
+        if (\is_array($prefix)) {
+            if (null === $this->parentPrefixes) {
+                // no-op
+            } elseif ($missing = array_diff_key($this->parentPrefixes, $prefix)) {
+                throw new \LogicException(sprintf('Collection "%s" is missing prefixes for locale(s) "%s".', $this->name, implode('", "', array_keys($missing))));
+            } else {
+                foreach ($prefix as $locale => $localePrefix) {
+                    if (!isset($this->parentPrefixes[$locale])) {
+                        throw new \LogicException(sprintf('Collection "%s" with locale "%s" is missing a corresponding prefix in its parent collection.', $this->name, $locale));
+                    }
+
+                    $prefix[$locale] = $this->parentPrefixes[$locale].$localePrefix;
+                }
+            }
+            $this->prefixes = $prefix;
+            $this->route->setPath('/');
+        } else {
+            $this->prefixes = null;
+            $this->route->setPath($prefix);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Sets the host to use for all child routes.
+     *
+     * @param string|array $host the host, or the localized hosts
+     *
+     * @return $this
+     */
+    final public function host(string|array $host): static
+    {
+        $this->host = $host;
+
+        return $this;
+    }
+
+    private function createRoute(string $path): Route
+    {
+        return (clone $this->route)->setPath($path);
+    }
+}

vendor/symfony/routing/Loader/Configurator/ImportConfigurator.php

@@ -0,0 +1,87 @@
+<?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\Configurator;
+
+use Symfony\Component\Routing\RouteCollection;
+
+/**
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+class ImportConfigurator
+{
+    use Traits\HostTrait;
+    use Traits\PrefixTrait;
+    use Traits\RouteTrait;
+
+    private $parent;
+
+    public function __construct(RouteCollection $parent, RouteCollection $route)
+    {
+        $this->parent = $parent;
+        $this->route = $route;
+    }
+
+    public function __sleep(): array
+    {
+        throw new \BadMethodCallException('Cannot serialize '.__CLASS__);
+    }
+
+    public function __wakeup()
+    {
+        throw new \BadMethodCallException('Cannot unserialize '.__CLASS__);
+    }
+
+    public function __destruct()
+    {
+        $this->parent->addCollection($this->route);
+    }
+
+    /**
+     * Sets the prefix to add to the path of all child routes.
+     *
+     * @param string|array $prefix the prefix, or the localized prefixes
+     *
+     * @return $this
+     */
+    final public function prefix(string|array $prefix, bool $trailingSlashOnRoot = true): static
+    {
+        $this->addPrefix($this->route, $prefix, $trailingSlashOnRoot);
+
+        return $this;
+    }
+
+    /**
+     * Sets the prefix to add to the name of all child routes.
+     *
+     * @return $this
+     */
+    final public function namePrefix(string $namePrefix): static
+    {
+        $this->route->addNamePrefix($namePrefix);
+
+        return $this;
+    }
+
+    /**
+     * Sets the host to use for all child routes.
+     *
+     * @param string|array $host the host, or the localized hosts
+     *
+     * @return $this
+     */
+    final public function host(string|array $host): static
+    {
+        $this->addHost($this->route, $host);
+
+        return $this;
+    }
+}

vendor/symfony/routing/Loader/Configurator/RouteConfigurator.php

@@ -0,0 +1,49 @@
+<?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\Configurator;
+
+use Symfony\Component\Routing\RouteCollection;
+
+/**
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+class RouteConfigurator
+{
+    use Traits\AddTrait;
+    use Traits\HostTrait;
+    use Traits\RouteTrait;
+
+    protected $parentConfigurator;
+
+    public function __construct(RouteCollection $collection, RouteCollection $route, string $name = '', CollectionConfigurator $parentConfigurator = null, array $prefixes = null)
+    {
+        $this->collection = $collection;
+        $this->route = $route;
+        $this->name = $name;
+        $this->parentConfigurator = $parentConfigurator; // for GC control
+        $this->prefixes = $prefixes;
+    }
+
+    /**
+     * Sets the host to use for all child routes.
+     *
+     * @param string|array $host the host, or the localized hosts
+     *
+     * @return $this
+     */
+    final public function host(string|array $host): static
+    {
+        $this->addHost($this->route, $host);
+
+        return $this;
+    }
+}

vendor/symfony/routing/Loader/Configurator/RoutingConfigurator.php

@@ -0,0 +1,78 @@
+<?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\Configurator;
+
+use Symfony\Component\Routing\Loader\PhpFileLoader;
+use Symfony\Component\Routing\RouteCollection;
+
+/**
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+class RoutingConfigurator
+{
+    use Traits\AddTrait;
+
+    private $loader;
+    private string $path;
+    private string $file;
+    private ?string $env;
+
+    public function __construct(RouteCollection $collection, PhpFileLoader $loader, string $path, string $file, string $env = null)
+    {
+        $this->collection = $collection;
+        $this->loader = $loader;
+        $this->path = $path;
+        $this->file = $file;
+        $this->env = $env;
+    }
+
+    /**
+     * @param string|string[]|null $exclude Glob patterns to exclude from the import
+     */
+    final public function import(string|array $resource, string $type = null, bool $ignoreErrors = false, string|array $exclude = null): ImportConfigurator
+    {
+        $this->loader->setCurrentDir(\dirname($this->path));
+
+        $imported = $this->loader->import($resource, $type, $ignoreErrors, $this->file, $exclude) ?: [];
+        if (!\is_array($imported)) {
+            return new ImportConfigurator($this->collection, $imported);
+        }
+
+        $mergedCollection = new RouteCollection();
+        foreach ($imported as $subCollection) {
+            $mergedCollection->addCollection($subCollection);
+        }
+
+        return new ImportConfigurator($this->collection, $mergedCollection);
+    }
+
+    final public function collection(string $name = ''): CollectionConfigurator
+    {
+        return new CollectionConfigurator($this->collection, $name);
+    }
+
+    /**
+     * Get the current environment to be able to write conditional configuration.
+     */
+    final public function env(): ?string
+    {
+        return $this->env;
+    }
+
+    final public function withPath(string $path): static
+    {
+        $clone = clone $this;
+        $clone->path = $clone->file = $path;
+
+        return $clone;
+    }
+}

vendor/symfony/routing/Loader/Configurator/Traits/AddTrait.php

@@ -0,0 +1,60 @@
+<?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\Configurator\Traits;
+
+use Symfony\Component\Routing\Loader\Configurator\AliasConfigurator;
+use Symfony\Component\Routing\Loader\Configurator\CollectionConfigurator;
+use Symfony\Component\Routing\Loader\Configurator\RouteConfigurator;
+use Symfony\Component\Routing\RouteCollection;
+
+/**
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+trait AddTrait
+{
+    use LocalizedRouteTrait;
+
+    /**
+     * @var RouteCollection
+     */
+    protected $collection;
+    protected $name = '';
+    protected $prefixes;
+
+    /**
+     * Adds a route.
+     *
+     * @param string|array $path the path, or the localized paths of the route
+     */
+    public function add(string $name, string|array $path): RouteConfigurator
+    {
+        $parentConfigurator = $this instanceof CollectionConfigurator ? $this : ($this instanceof RouteConfigurator ? $this->parentConfigurator : null);
+        $route = $this->createLocalizedRoute($this->collection, $name, $path, $this->name, $this->prefixes);
+
+        return new RouteConfigurator($this->collection, $route, $this->name, $parentConfigurator, $this->prefixes);
+    }
+
+    public function alias(string $name, string $alias): AliasConfigurator
+    {
+        return new AliasConfigurator($this->collection->addAlias($name, $alias));
+    }
+
+    /**
+     * Adds a route.
+     *
+     * @param string|array $path the path, or the localized paths of the route
+     */
+    public function __invoke(string $name, string|array $path): RouteConfigurator
+    {
+        return $this->add($name, $path);
+    }
+}

vendor/symfony/routing/Loader/Configurator/Traits/HostTrait.php

@@ -0,0 +1,49 @@
+<?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\Configurator\Traits;
+
+use Symfony\Component\Routing\RouteCollection;
+
+/**
+ * @internal
+ */
+trait HostTrait
+{
+    final protected function addHost(RouteCollection $routes, string|array $hosts)
+    {
+        if (!$hosts || !\is_array($hosts)) {
+            $routes->setHost($hosts ?: '');
+
+            return;
+        }
+
+        foreach ($routes->all() as $name => $route) {
+            if (null === $locale = $route->getDefault('_locale')) {
+                $routes->remove($name);
+                foreach ($hosts as $locale => $host) {
+                    $localizedRoute = clone $route;
+                    $localizedRoute->setDefault('_locale', $locale);
+                    $localizedRoute->setRequirement('_locale', preg_quote($locale));
+                    $localizedRoute->setDefault('_canonical_route', $name);
+                    $localizedRoute->setHost($host);
+                    $routes->add($name.'.'.$locale, $localizedRoute);
+                }
+            } elseif (!isset($hosts[$locale])) {
+                throw new \InvalidArgumentException(sprintf('Route "%s" with locale "%s" is missing a corresponding host in its parent collection.', $name, $locale));
+            } else {
+                $route->setHost($hosts[$locale]);
+                $route->setRequirement('_locale', preg_quote($locale));
+                $routes->add($name, $route);
+            }
+        }
+    }
+}

vendor/symfony/routing/Loader/Configurator/Traits/LocalizedRouteTrait.php

@@ -0,0 +1,76 @@
+<?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\Configurator\Traits;
+
+use Symfony\Component\Routing\Route;
+use Symfony\Component\Routing\RouteCollection;
+
+/**
+ * @internal
+ *
+ * @author Nicolas Grekas <p@tchwork.com>
+ * @author Jules Pietri <jules@heahprod.com>
+ */
+trait LocalizedRouteTrait
+{
+    /**
+     * Creates one or many routes.
+     *
+     * @param string|array $path the path, or the localized paths of the route
+     */
+    final protected function createLocalizedRoute(RouteCollection $collection, string $name, string|array $path, string $namePrefix = '', array $prefixes = null): RouteCollection
+    {
+        $paths = [];
+
+        $routes = new RouteCollection();
+
+        if (\is_array($path)) {
+            if (null === $prefixes) {
+                $paths = $path;
+            } elseif ($missing = array_diff_key($prefixes, $path)) {
+                throw new \LogicException(sprintf('Route "%s" is missing routes for locale(s) "%s".', $name, implode('", "', array_keys($missing))));
+            } else {
+                foreach ($path as $locale => $localePath) {
+                    if (!isset($prefixes[$locale])) {
+                        throw new \LogicException(sprintf('Route "%s" with locale "%s" is missing a corresponding prefix in its parent collection.', $name, $locale));
+                    }
+
+                    $paths[$locale] = $prefixes[$locale].$localePath;
+                }
+            }
+        } elseif (null !== $prefixes) {
+            foreach ($prefixes as $locale => $prefix) {
+                $paths[$locale] = $prefix.$path;
+            }
+        } else {
+            $routes->add($namePrefix.$name, $route = $this->createRoute($path));
+            $collection->add($namePrefix.$name, $route);
+
+            return $routes;
+        }
+
+        foreach ($paths as $locale => $path) {
+            $routes->add($name.'.'.$locale, $route = $this->createRoute($path));
+            $collection->add($namePrefix.$name.'.'.$locale, $route);
+            $route->setDefault('_locale', $locale);
+            $route->setRequirement('_locale', preg_quote($locale));
+            $route->setDefault('_canonical_route', $namePrefix.$name);
+        }
+
+        return $routes;
+    }
+
+    private function createRoute(string $path): Route
+    {
+        return new Route($path);
+    }
+}

vendor/symfony/routing/Loader/Configurator/Traits/PrefixTrait.php

@@ -0,0 +1,62 @@
+<?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\Configurator\Traits;
+
+use Symfony\Component\Routing\Route;
+use Symfony\Component\Routing\RouteCollection;
+
+/**
+ * @internal
+ *
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+trait PrefixTrait
+{
+    final protected function addPrefix(RouteCollection $routes, string|array $prefix, bool $trailingSlashOnRoot)
+    {
+        if (\is_array($prefix)) {
+            foreach ($prefix as $locale => $localePrefix) {
+                $prefix[$locale] = trim(trim($localePrefix), '/');
+            }
+            foreach ($routes->all() as $name => $route) {
+                if (null === $locale = $route->getDefault('_locale')) {
+                    $routes->remove($name);
+                    foreach ($prefix as $locale => $localePrefix) {
+                        $localizedRoute = clone $route;
+                        $localizedRoute->setDefault('_locale', $locale);
+                        $localizedRoute->setRequirement('_locale', preg_quote($locale));
+                        $localizedRoute->setDefault('_canonical_route', $name);
+                        $localizedRoute->setPath($localePrefix.(!$trailingSlashOnRoot && '/' === $route->getPath() ? '' : $route->getPath()));
+                        $routes->add($name.'.'.$locale, $localizedRoute);
+                    }
+                } elseif (!isset($prefix[$locale])) {
+                    throw new \InvalidArgumentException(sprintf('Route "%s" with locale "%s" is missing a corresponding prefix in its parent collection.', $name, $locale));
+                } else {
+                    $route->setPath($prefix[$locale].(!$trailingSlashOnRoot && '/' === $route->getPath() ? '' : $route->getPath()));
+                    $routes->add($name, $route);
+                }
+            }
+
+            return;
+        }
+
+        $routes->addPrefix($prefix);
+        if (!$trailingSlashOnRoot) {
+            $rootPath = (new Route(trim(trim($prefix), '/').'/'))->getPath();
+            foreach ($routes->all() as $route) {
+                if ($route->getPath() === $rootPath) {
+                    $route->setPath(rtrim($rootPath, '/'));
+                }
+            }
+        }
+    }
+}

vendor/symfony/routing/Loader/Configurator/Traits/RouteTrait.php

@@ -0,0 +1,175 @@
+<?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\Configurator\Traits;
+
+use Symfony\Component\Routing\Route;
+use Symfony\Component\Routing\RouteCollection;
+
+trait RouteTrait
+{
+    /**
+     * @var RouteCollection|Route
+     */
+    protected $route;
+
+    /**
+     * Adds defaults.
+     *
+     * @return $this
+     */
+    final public function defaults(array $defaults): static
+    {
+        $this->route->addDefaults($defaults);
+
+        return $this;
+    }
+
+    /**
+     * Adds requirements.
+     *
+     * @return $this
+     */
+    final public function requirements(array $requirements): static
+    {
+        $this->route->addRequirements($requirements);
+
+        return $this;
+    }
+
+    /**
+     * Adds options.
+     *
+     * @return $this
+     */
+    final public function options(array $options): static
+    {
+        $this->route->addOptions($options);
+
+        return $this;
+    }
+
+    /**
+     * Whether paths should accept utf8 encoding.
+     *
+     * @return $this
+     */
+    final public function utf8(bool $utf8 = true): static
+    {
+        $this->route->addOptions(['utf8' => $utf8]);
+
+        return $this;
+    }
+
+    /**
+     * Sets the condition.
+     *
+     * @return $this
+     */
+    final public function condition(string $condition): static
+    {
+        $this->route->setCondition($condition);
+
+        return $this;
+    }
+
+    /**
+     * Sets the pattern for the host.
+     *
+     * @return $this
+     */
+    final public function host(string $pattern): static
+    {
+        $this->route->setHost($pattern);
+
+        return $this;
+    }
+
+    /**
+     * Sets the schemes (e.g. 'https') this route is restricted to.
+     * So an empty array means that any scheme is allowed.
+     *
+     * @param string[] $schemes
+     *
+     * @return $this
+     */
+    final public function schemes(array $schemes): static
+    {
+        $this->route->setSchemes($schemes);
+
+        return $this;
+    }
+
+    /**
+     * Sets the HTTP methods (e.g. 'POST') this route is restricted to.
+     * So an empty array means that any method is allowed.
+     *
+     * @param string[] $methods
+     *
+     * @return $this
+     */
+    final public function methods(array $methods): static
+    {
+        $this->route->setMethods($methods);
+
+        return $this;
+    }
+
+    /**
+     * Adds the "_controller" entry to defaults.
+     *
+     * @param callable|string|array $controller a callable or parseable pseudo-callable
+     *
+     * @return $this
+     */
+    final public function controller(callable|string|array $controller): static
+    {
+        $this->route->addDefaults(['_controller' => $controller]);
+
+        return $this;
+    }
+
+    /**
+     * Adds the "_locale" entry to defaults.
+     *
+     * @return $this
+     */
+    final public function locale(string $locale): static
+    {
+        $this->route->addDefaults(['_locale' => $locale]);
+
+        return $this;
+    }
+
+    /**
+     * Adds the "_format" entry to defaults.
+     *
+     * @return $this
+     */
+    final public function format(string $format): static
+    {
+        $this->route->addDefaults(['_format' => $format]);
+
+        return $this;
+    }
+
+    /**
+     * Adds the "_stateless" entry to defaults.
+     *
+     * @return $this
+     */
+    final public function stateless(bool $stateless = true): static
+    {
+        $this->route->addDefaults(['_stateless' => $stateless]);
+
+        return $this;
+    }
+}

vendor/symfony/routing/Loader/ContainerLoader.php

@@ -0,0 +1,46 @@
+<?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 Psr\Container\ContainerInterface;
+
+/**
+ * A route loader that executes a service from a PSR-11 container to load the routes.
+ *
+ * @author Ryan Weaver <ryan@knpuniversity.com>
+ */
+class ContainerLoader extends ObjectLoader
+{
+    private $container;
+
+    public function __construct(ContainerInterface $container, string $env = null)
+    {
+        $this->container = $container;
+        parent::__construct($env);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function supports(mixed $resource, string $type = null): bool
+    {
+        return 'service' === $type && \is_string($resource);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function getObject(string $id): object
+    {
+        return $this->container->get($id);
+    }
+}

vendor/symfony/routing/Loader/DependencyInjection/ServiceRouterLoader.php

@@ -1,40 +0,0 @@
-<?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\DependencyInjection;
-
-use Psr\Container\ContainerInterface;
-use Symfony\Component\Routing\Loader\ObjectRouteLoader;
-
-/**
- * A route loader that executes a service to load the routes.
- *
- * This depends on the DependencyInjection component.
- *
- * @author Ryan Weaver <ryan@knpuniversity.com>
- */
-class ServiceRouterLoader extends ObjectRouteLoader
-{
-    /**
-     * @var ContainerInterface
-     */
-    private $container;
-
-    public function __construct(ContainerInterface $container)
-    {
-        $this->container = $container;
-    }
-
-    protected function getServiceObject($id)
-    {
-        return $this->container->get($id);
-    }
-}

vendor/symfony/routing/Loader/DirectoryLoader.php

@@ -12,15 +12,15 @@
 namespace Symfony\Component\Routing\Loader;
 
 use Symfony\Component\Config\Loader\FileLoader;
-use Symfony\Component\Routing\RouteCollection;
 use Symfony\Component\Config\Resource\DirectoryResource;
+use Symfony\Component\Routing\RouteCollection;
 
 class DirectoryLoader extends FileLoader
 {
     /**
      * {@inheritdoc}
      */
-    public function load($file, $type = null)
+    public function load(mixed $file, string $type = null): mixed
     {
         $path = $this->locator->locate($file);
 
@@ -49,7 +49,7 @@ class DirectoryLoader extends FileLoader
     /**
      * {@inheritdoc}
      */
-    public function supports($resource, $type = null)
+    public function supports(mixed $resource, string $type = null): bool
     {
         // only when type is forced to directory, not to conflict with AnnotationLoader
 

vendor/symfony/routing/Loader/GlobFileLoader.php

@@ -0,0 +1,47 @@
+<?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 Symfony\Component\Config\Loader\FileLoader;
+use Symfony\Component\Routing\RouteCollection;
+
+/**
+ * GlobFileLoader loads files from a glob pattern.
+ *
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+class GlobFileLoader extends FileLoader
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function load(mixed $resource, string $type = null): mixed
+    {
+        $collection = new RouteCollection();
+
+        foreach ($this->glob($resource, false, $globResource) as $path => $info) {
+            $collection->addCollection($this->import($path));
+        }
+
+        $collection->addResource($globResource);
+
+        return $collection;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function supports(mixed $resource, string $type = null): bool
+    {
+        return 'glob' === $type;
+    }
+}

vendor/symfony/routing/Loader/ObjectLoader.php

@@ -0,0 +1,77 @@
+<?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 Symfony\Component\Config\Loader\Loader;
+use Symfony\Component\Config\Resource\FileResource;
+use Symfony\Component\Routing\RouteCollection;
+
+/**
+ * A route loader that calls a method on an object to load the routes.
+ *
+ * @author Ryan Weaver <ryan@knpuniversity.com>
+ */
+abstract class ObjectLoader extends Loader
+{
+    /**
+     * Returns the object that the method will be called on to load routes.
+     *
+     * For example, if your application uses a service container,
+     * the $id may be a service id.
+     */
+    abstract protected function getObject(string $id): object;
+
+    /**
+     * Calls the object method that will load the routes.
+     */
+    public function load(mixed $resource, string $type = null): RouteCollection
+    {
+        if (!preg_match('/^[^\:]+(?:::(?:[^\:]+))?$/', $resource)) {
+            throw new \InvalidArgumentException(sprintf('Invalid resource "%s" passed to the %s route loader: use the format "object_id::method" or "object_id" if your object class has an "__invoke" method.', $resource, \is_string($type) ? '"'.$type.'"' : 'object'));
+        }
+
+        $parts = explode('::', $resource);
+        $method = $parts[1] ?? '__invoke';
+
+        $loaderObject = $this->getObject($parts[0]);
+
+        if (!\is_object($loaderObject)) {
+            throw new \TypeError(sprintf('"%s:getObject()" must return an object: "%s" returned.', static::class, get_debug_type($loaderObject)));
+        }
+
+        if (!\is_callable([$loaderObject, $method])) {
+            throw new \BadMethodCallException(sprintf('Method "%s" not found on "%s" when importing routing resource "%s".', $method, get_debug_type($loaderObject), $resource));
+        }
+
+        $routeCollection = $loaderObject->$method($this, $this->env);
+
+        if (!$routeCollection instanceof RouteCollection) {
+            $type = get_debug_type($routeCollection);
+
+            throw new \LogicException(sprintf('The "%s::%s()" method must return a RouteCollection: "%s" returned.', get_debug_type($loaderObject), $method, $type));
+        }
+
+        // make the object file tracked so that if it changes, the cache rebuilds
+        $this->addClassResource(new \ReflectionClass($loaderObject), $routeCollection);
+
+        return $routeCollection;
+    }
+
+    private function addClassResource(\ReflectionClass $class, RouteCollection $collection)
+    {
+        do {
+            if (is_file($class->getFileName())) {
+                $collection->addResource(new FileResource($class->getFileName()));
+            }
+        } while ($class = $class->getParentClass());
+    }
+}

vendor/symfony/routing/Loader/ObjectRouteLoader.php

@@ -1,95 +0,0 @@
-<?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 Symfony\Component\Config\Loader\Loader;
-use Symfony\Component\Config\Resource\FileResource;
-use Symfony\Component\Routing\RouteCollection;
-
-/**
- * A route loader that calls a method on an object to load the routes.
- *
- * @author Ryan Weaver <ryan@knpuniversity.com>
- */
-abstract class ObjectRouteLoader extends Loader
-{
-    /**
-     * Returns the object that the method will be called on to load routes.
-     *
-     * For example, if your application uses a service container,
-     * the $id may be a service id.
-     *
-     * @param string $id
-     *
-     * @return object
-     */
-    abstract protected function getServiceObject($id);
-
-    /**
-     * Calls the service that will load the routes.
-     *
-     * @param mixed       $resource Some value that will resolve to a callable
-     * @param string|null $type     The resource type
-     *
-     * @return RouteCollection
-     */
-    public function load($resource, $type = null)
-    {
-        $parts = explode(':', $resource);
-        if (count($parts) != 2) {
-            throw new \InvalidArgumentException(sprintf('Invalid resource "%s" passed to the "service" route loader: use the format "service_name:methodName"', $resource));
-        }
-
-        $serviceString = $parts[0];
-        $method = $parts[1];
-
-        $loaderObject = $this->getServiceObject($serviceString);
-
-        if (!is_object($loaderObject)) {
-            throw new \LogicException(sprintf('%s:getServiceObject() must return an object: %s returned', get_class($this), gettype($loaderObject)));
-        }
-
-        if (!method_exists($loaderObject, $method)) {
-            throw new \BadMethodCallException(sprintf('Method "%s" not found on "%s" when importing routing resource "%s"', $method, get_class($loaderObject), $resource));
-        }
-
-        $routeCollection = call_user_func(array($loaderObject, $method), $this);
-
-        if (!$routeCollection instanceof RouteCollection) {
-            $type = is_object($routeCollection) ? get_class($routeCollection) : gettype($routeCollection);
-
-            throw new \LogicException(sprintf('The %s::%s method must return a RouteCollection: %s returned', get_class($loaderObject), $method, $type));
-        }
-
-        // make the service file tracked so that if it changes, the cache rebuilds
-        $this->addClassResource(new \ReflectionClass($loaderObject), $routeCollection);
-
-        return $routeCollection;
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function supports($resource, $type = null)
-    {
-        return 'service' === $type;
-    }
-
-    private function addClassResource(\ReflectionClass $class, RouteCollection $collection)
-    {
-        do {
-            if (is_file($class->getFileName())) {
-                $collection->addResource(new FileResource($class->getFileName()));
-            }
-        } while ($class = $class->getParentClass());
-    }
-}

vendor/symfony/routing/Loader/PhpFileLoader.php

@@ -13,6 +13,7 @@ namespace Symfony\Component\Routing\Loader;
 
 use Symfony\Component\Config\Loader\FileLoader;
 use Symfony\Component\Config\Resource\FileResource;
+use Symfony\Component\Routing\Loader\Configurator\RoutingConfigurator;
 use Symfony\Component\Routing\RouteCollection;
 
 /**
@@ -21,23 +22,33 @@ use Symfony\Component\Routing\RouteCollection;
  * The file must return a RouteCollection instance.
  *
  * @author Fabien Potencier <fabien@symfony.com>
+ * @author Nicolas grekas <p@tchwork.com>
+ * @author Jules Pietri <jules@heahprod.com>
  */
 class PhpFileLoader extends FileLoader
 {
     /**
      * Loads a PHP file.
-     *
-     * @param string      $file A PHP file path
-     * @param string|null $type The resource type
-     *
-     * @return RouteCollection A RouteCollection instance
      */
-    public function load($file, $type = null)
+    public function load(mixed $file, string $type = null): RouteCollection
     {
         $path = $this->locator->locate($file);
-        $this->setCurrentDir(dirname($path));
+        $this->setCurrentDir(\dirname($path));
+
+        // the closure forbids access to the private scope in the included file
+        $loader = $this;
+        $load = \Closure::bind(static function ($file) use ($loader) {
+            return include $file;
+        }, null, ProtectedPhpFileLoader::class);
+
+        $result = $load($path);
+
+        if (\is_object($result) && \is_callable($result)) {
+            $collection = $this->callConfigurator($result, $path, $file);
+        } else {
+            $collection = $result;
+        }
 
-        $collection = self::includeFile($path, $this);
         $collection->addResource(new FileResource($path));
 
         return $collection;
@@ -46,21 +57,24 @@ class PhpFileLoader extends FileLoader
     /**
      * {@inheritdoc}
      */
-    public function supports($resource, $type = null)
+    public function supports(mixed $resource, string $type = null): bool
     {
-        return is_string($resource) && 'php' === pathinfo($resource, PATHINFO_EXTENSION) && (!$type || 'php' === $type);
+        return \is_string($resource) && 'php' === pathinfo($resource, \PATHINFO_EXTENSION) && (!$type || 'php' === $type);
     }
 
-    /**
-     * Safe include. Used for scope isolation.
-     *
-     * @param string        $file   File to include
-     * @param PhpFileLoader $loader the loader variable is exposed to the included file below
-     *
-     * @return RouteCollection
-     */
-    private static function includeFile($file, PhpFileLoader $loader)
+    protected function callConfigurator(callable $result, string $path, string $file): RouteCollection
     {
-        return include $file;
+        $collection = new RouteCollection();
+
+        $result(new RoutingConfigurator($collection, $this, $path, $file, $this->env));
+
+        return $collection;
     }
 }
+
+/**
+ * @internal
+ */
+final class ProtectedPhpFileLoader extends PhpFileLoader
+{
+}

vendor/symfony/routing/Loader/XmlFileLoader.php

@@ -11,11 +11,13 @@
 
 namespace Symfony\Component\Routing\Loader;
 
-use Symfony\Component\Routing\RouteCollection;
-use Symfony\Component\Routing\Route;
-use Symfony\Component\Config\Resource\FileResource;
 use Symfony\Component\Config\Loader\FileLoader;
+use Symfony\Component\Config\Resource\FileResource;
 use Symfony\Component\Config\Util\XmlUtils;
+use Symfony\Component\Routing\Loader\Configurator\Traits\HostTrait;
+use Symfony\Component\Routing\Loader\Configurator\Traits\LocalizedRouteTrait;
+use Symfony\Component\Routing\Loader\Configurator\Traits\PrefixTrait;
+use Symfony\Component\Routing\RouteCollection;
 
 /**
  * XmlFileLoader loads XML routing files.
@@ -25,21 +27,18 @@ use Symfony\Component\Config\Util\XmlUtils;
  */
 class XmlFileLoader extends FileLoader
 {
-    const NAMESPACE_URI = 'http://symfony.com/schema/routing';
-    const SCHEME_PATH = '/schema/routing/routing-1.0.xsd';
+    use HostTrait;
+    use LocalizedRouteTrait;
+    use PrefixTrait;
+
+    public const NAMESPACE_URI = 'http://symfony.com/schema/routing';
+    public const SCHEME_PATH = '/schema/routing/routing-1.0.xsd';
 
     /**
-     * Loads an XML file.
-     *
-     * @param string      $file An XML file path
-     * @param string|null $type The resource type
-     *
-     * @return RouteCollection A RouteCollection instance
-     *
-     * @throws \InvalidArgumentException When the file cannot be loaded or when the XML cannot be
-     *                                   parsed because it does not validate against the scheme.
+     * @throws \InvalidArgumentException when the file cannot be loaded or when the XML cannot be
+     *                                   parsed because it does not validate against the scheme
      */
-    public function load($file, $type = null)
+    public function load(mixed $file, string $type = null): RouteCollection
     {
         $path = $this->locator->locate($file);
 
@@ -63,14 +62,9 @@ class XmlFileLoader extends FileLoader
     /**
      * Parses a node from a loaded XML file.
      *
-     * @param RouteCollection $collection Collection to associate with the node
-     * @param \DOMElement     $node       Element to parse
-     * @param string          $path       Full path of the XML file being processed
-     * @param string          $file       Loaded file name
-     *
      * @throws \InvalidArgumentException When the XML is invalid
      */
-    protected function parseNode(RouteCollection $collection, \DOMElement $node, $path, $file)
+    protected function parseNode(RouteCollection $collection, \DOMElement $node, string $path, string $file)
     {
         if (self::NAMESPACE_URI !== $node->namespaceURI) {
             return;
@@ -83,6 +77,16 @@ class XmlFileLoader extends FileLoader
             case 'import':
                 $this->parseImport($collection, $node, $path, $file);
                 break;
+            case 'when':
+                if (!$this->env || $node->getAttribute('env') !== $this->env) {
+                    break;
+                }
+                foreach ($node->childNodes as $node) {
+                    if ($node instanceof \DOMElement) {
+                        $this->parseNode($collection, $node, $path, $file);
+                    }
+                }
+                break;
             default:
                 throw new \InvalidArgumentException(sprintf('Unknown tag "%s" used in file "%s". Expected "route" or "import".', $node->localName, $path));
         }
@@ -91,46 +95,64 @@ class XmlFileLoader extends FileLoader
     /**
      * {@inheritdoc}
      */
-    public function supports($resource, $type = null)
+    public function supports(mixed $resource, string $type = null): bool
     {
-        return is_string($resource) && 'xml' === pathinfo($resource, PATHINFO_EXTENSION) && (!$type || 'xml' === $type);
+        return \is_string($resource) && 'xml' === pathinfo($resource, \PATHINFO_EXTENSION) && (!$type || 'xml' === $type);
     }
 
     /**
      * Parses a route and adds it to the RouteCollection.
      *
-     * @param RouteCollection $collection RouteCollection instance
-     * @param \DOMElement     $node       Element to parse that represents a Route
-     * @param string          $path       Full path of the XML file being processed
-     *
      * @throws \InvalidArgumentException When the XML is invalid
      */
-    protected function parseRoute(RouteCollection $collection, \DOMElement $node, $path)
+    protected function parseRoute(RouteCollection $collection, \DOMElement $node, string $path)
     {
-        if ('' === ($id = $node->getAttribute('id')) || !$node->hasAttribute('path')) {
-            throw new \InvalidArgumentException(sprintf('The <route> element in file "%s" must have an "id" and a "path" attribute.', $path));
+        if ('' === $id = $node->getAttribute('id')) {
+            throw new \InvalidArgumentException(sprintf('The <route> element in file "%s" must have an "id" attribute.', $path));
         }
 
-        $schemes = preg_split('/[\s,\|]++/', $node->getAttribute('schemes'), -1, PREG_SPLIT_NO_EMPTY);
-        $methods = preg_split('/[\s,\|]++/', $node->getAttribute('methods'), -1, PREG_SPLIT_NO_EMPTY);
+        if ('' !== $alias = $node->getAttribute('alias')) {
+            $alias = $collection->addAlias($id, $alias);
 
-        list($defaults, $requirements, $options, $condition) = $this->parseConfigs($node, $path);
+            if ($deprecationInfo = $this->parseDeprecation($node, $path)) {
+                $alias->setDeprecated($deprecationInfo['package'], $deprecationInfo['version'], $deprecationInfo['message']);
+            }
 
-        $route = new Route($node->getAttribute('path'), $defaults, $requirements, $options, $node->getAttribute('host'), $schemes, $methods, $condition);
-        $collection->add($id, $route);
+            return;
+        }
+
+        $schemes = preg_split('/[\s,\|]++/', $node->getAttribute('schemes'), -1, \PREG_SPLIT_NO_EMPTY);
+        $methods = preg_split('/[\s,\|]++/', $node->getAttribute('methods'), -1, \PREG_SPLIT_NO_EMPTY);
+
+        [$defaults, $requirements, $options, $condition, $paths, /* $prefixes */, $hosts] = $this->parseConfigs($node, $path);
+
+        if (!$paths && '' === $node->getAttribute('path')) {
+            throw new \InvalidArgumentException(sprintf('The <route> element in file "%s" must have a "path" attribute or <path> child nodes.', $path));
+        }
+
+        if ($paths && '' !== $node->getAttribute('path')) {
+            throw new \InvalidArgumentException(sprintf('The <route> element in file "%s" must not have both a "path" attribute and <path> child nodes.', $path));
+        }
+
+        $routes = $this->createLocalizedRoute($collection, $id, $paths ?: $node->getAttribute('path'));
+        $routes->addDefaults($defaults);
+        $routes->addRequirements($requirements);
+        $routes->addOptions($options);
+        $routes->setSchemes($schemes);
+        $routes->setMethods($methods);
+        $routes->setCondition($condition);
+
+        if (null !== $hosts) {
+            $this->addHost($routes, $hosts);
+        }
     }
 
     /**
      * Parses an import and adds the routes in the resource to the RouteCollection.
      *
-     * @param RouteCollection $collection RouteCollection instance
-     * @param \DOMElement     $node       Element to parse that represents a Route
-     * @param string          $path       Full path of the XML file being processed
-     * @param string          $file       Loaded file name
-     *
      * @throws \InvalidArgumentException When the XML is invalid
      */
-    protected function parseImport(RouteCollection $collection, \DOMElement $node, $path, $file)
+    protected function parseImport(RouteCollection $collection, \DOMElement $node, string $path, string $file)
     {
         if ('' === $resource = $node->getAttribute('resource')) {
             throw new \InvalidArgumentException(sprintf('The <import> element in file "%s" must have a "resource" attribute.', $path));
@@ -138,48 +160,73 @@ class XmlFileLoader extends FileLoader
 
         $type = $node->getAttribute('type');
         $prefix = $node->getAttribute('prefix');
-        $host = $node->hasAttribute('host') ? $node->getAttribute('host') : null;
-        $schemes = $node->hasAttribute('schemes') ? preg_split('/[\s,\|]++/', $node->getAttribute('schemes'), -1, PREG_SPLIT_NO_EMPTY) : null;
-        $methods = $node->hasAttribute('methods') ? preg_split('/[\s,\|]++/', $node->getAttribute('methods'), -1, PREG_SPLIT_NO_EMPTY) : null;
+        $schemes = $node->hasAttribute('schemes') ? preg_split('/[\s,\|]++/', $node->getAttribute('schemes'), -1, \PREG_SPLIT_NO_EMPTY) : null;
+        $methods = $node->hasAttribute('methods') ? preg_split('/[\s,\|]++/', $node->getAttribute('methods'), -1, \PREG_SPLIT_NO_EMPTY) : null;
+        $trailingSlashOnRoot = $node->hasAttribute('trailing-slash-on-root') ? XmlUtils::phpize($node->getAttribute('trailing-slash-on-root')) : true;
+        $namePrefix = $node->getAttribute('name-prefix') ?: null;
 
-        list($defaults, $requirements, $options, $condition) = $this->parseConfigs($node, $path);
+        [$defaults, $requirements, $options, $condition, /* $paths */, $prefixes, $hosts] = $this->parseConfigs($node, $path);
 
-        $this->setCurrentDir(dirname($path));
+        if ('' !== $prefix && $prefixes) {
+            throw new \InvalidArgumentException(sprintf('The <route> element in file "%s" must not have both a "prefix" attribute and <prefix> child nodes.', $path));
+        }
 
-        $subCollection = $this->import($resource, ('' !== $type ? $type : null), false, $file);
-        /* @var $subCollection RouteCollection */
-        $subCollection->addPrefix($prefix);
-        if (null !== $host) {
-            $subCollection->setHost($host);
+        $exclude = [];
+        foreach ($node->childNodes as $child) {
+            if ($child instanceof \DOMElement && $child->localName === $exclude && self::NAMESPACE_URI === $child->namespaceURI) {
+                $exclude[] = $child->nodeValue;
+            }
         }
-        if (null !== $condition) {
-            $subCollection->setCondition($condition);
-        }
-        if (null !== $schemes) {
-            $subCollection->setSchemes($schemes);
-        }
-        if (null !== $methods) {
-            $subCollection->setMethods($methods);
-        }
-        $subCollection->addDefaults($defaults);
-        $subCollection->addRequirements($requirements);
-        $subCollection->addOptions($options);
 
-        $collection->addCollection($subCollection);
+        if ($node->hasAttribute('exclude')) {
+            if ($exclude) {
+                throw new \InvalidArgumentException('You cannot use both the attribute "exclude" and <exclude> tags at the same time.');
+            }
+            $exclude = [$node->getAttribute('exclude')];
+        }
+
+        $this->setCurrentDir(\dirname($path));
+
+        /** @var RouteCollection[] $imported */
+        $imported = $this->import($resource, '' !== $type ? $type : null, false, $file, $exclude) ?: [];
+
+        if (!\is_array($imported)) {
+            $imported = [$imported];
+        }
+
+        foreach ($imported as $subCollection) {
+            $this->addPrefix($subCollection, $prefixes ?: $prefix, $trailingSlashOnRoot);
+
+            if (null !== $hosts) {
+                $this->addHost($subCollection, $hosts);
+            }
+
+            if (null !== $condition) {
+                $subCollection->setCondition($condition);
+            }
+            if (null !== $schemes) {
+                $subCollection->setSchemes($schemes);
+            }
+            if (null !== $methods) {
+                $subCollection->setMethods($methods);
+            }
+            if (null !== $namePrefix) {
+                $subCollection->addNamePrefix($namePrefix);
+            }
+            $subCollection->addDefaults($defaults);
+            $subCollection->addRequirements($requirements);
+            $subCollection->addOptions($options);
+
+            $collection->addCollection($subCollection);
+        }
     }
 
     /**
-     * Loads an XML file.
-     *
-     * @param string $file An XML file path
-     *
-     * @return \DOMDocument
-     *
      * @throws \InvalidArgumentException When loading of XML file fails because of syntax errors
      *                                   or when the XML structure is not as expected by the scheme -
      *                                   see validate()
      */
-    protected function loadFile($file)
+    protected function loadFile(string $file): \DOMDocument
     {
         return XmlUtils::loadFile($file, __DIR__.static::SCHEME_PATH);
     }
@@ -187,26 +234,34 @@ class XmlFileLoader extends FileLoader
     /**
      * Parses the config elements (default, requirement, option).
      *
-     * @param \DOMElement $node Element to parse that contains the configs
-     * @param string      $path Full path of the XML file being processed
-     *
-     * @return array An array with the defaults as first item, requirements as second and options as third
-     *
      * @throws \InvalidArgumentException When the XML is invalid
      */
-    private function parseConfigs(\DOMElement $node, $path)
+    private function parseConfigs(\DOMElement $node, string $path): array
     {
-        $defaults = array();
-        $requirements = array();
-        $options = array();
+        $defaults = [];
+        $requirements = [];
+        $options = [];
         $condition = null;
+        $prefixes = [];
+        $paths = [];
+        $hosts = [];
 
+        /** @var \DOMElement $n */
         foreach ($node->getElementsByTagNameNS(self::NAMESPACE_URI, '*') as $n) {
             if ($node !== $n->parentNode) {
                 continue;
             }
 
             switch ($n->localName) {
+                case 'path':
+                    $paths[$n->getAttribute('locale')] = trim($n->textContent);
+                    break;
+                case 'host':
+                    $hosts[$n->getAttribute('locale')] = trim($n->textContent);
+                    break;
+                case 'prefix':
+                    $prefixes[$n->getAttribute('locale')] = trim($n->textContent);
+                    break;
                 case 'default':
                     if ($this->isElementValueNull($n)) {
                         $defaults[$n->getAttribute('key')] = null;
@@ -219,7 +274,7 @@ class XmlFileLoader extends FileLoader
                     $requirements[$n->getAttribute('key')] = trim($n->textContent);
                     break;
                 case 'option':
-                    $options[$n->getAttribute('key')] = trim($n->textContent);
+                    $options[$n->getAttribute('key')] = XmlUtils::phpize(trim($n->textContent));
                     break;
                 case 'condition':
                     $condition = trim($n->textContent);
@@ -229,21 +284,48 @@ class XmlFileLoader extends FileLoader
             }
         }
 
-        return array($defaults, $requirements, $options, $condition);
+        if ($controller = $node->getAttribute('controller')) {
+            if (isset($defaults['_controller'])) {
+                $name = $node->hasAttribute('id') ? sprintf('"%s".', $node->getAttribute('id')) : sprintf('the "%s" tag.', $node->tagName);
+
+                throw new \InvalidArgumentException(sprintf('The routing file "%s" must not specify both the "controller" attribute and the defaults key "_controller" for ', $path).$name);
+            }
+
+            $defaults['_controller'] = $controller;
+        }
+        if ($node->hasAttribute('locale')) {
+            $defaults['_locale'] = $node->getAttribute('locale');
+        }
+        if ($node->hasAttribute('format')) {
+            $defaults['_format'] = $node->getAttribute('format');
+        }
+        if ($node->hasAttribute('utf8')) {
+            $options['utf8'] = XmlUtils::phpize($node->getAttribute('utf8'));
+        }
+        if ($stateless = $node->getAttribute('stateless')) {
+            if (isset($defaults['_stateless'])) {
+                $name = $node->hasAttribute('id') ? sprintf('"%s".', $node->getAttribute('id')) : sprintf('the "%s" tag.', $node->tagName);
+
+                throw new \InvalidArgumentException(sprintf('The routing file "%s" must not specify both the "stateless" attribute and the defaults key "_stateless" for ', $path).$name);
+            }
+
+            $defaults['_stateless'] = XmlUtils::phpize($stateless);
+        }
+
+        if (!$hosts) {
+            $hosts = $node->hasAttribute('host') ? $node->getAttribute('host') : null;
+        }
+
+        return [$defaults, $requirements, $options, $condition, $paths, $prefixes, $hosts];
     }
 
     /**
      * Parses the "default" elements.
-     *
-     * @param \DOMElement $element The "default" element to parse
-     * @param string      $path    Full path of the XML file being processed
-     *
-     * @return array|bool|float|int|string|null The parsed value of the "default" element
      */
-    private function parseDefaultsConfig(\DOMElement $element, $path)
+    private function parseDefaultsConfig(\DOMElement $element, string $path): array|bool|float|int|string|null
     {
         if ($this->isElementValueNull($element)) {
-            return;
+            return null;
         }
 
         // Check for existing element nodes in the default element. There can
@@ -270,17 +352,12 @@ class XmlFileLoader extends FileLoader
     /**
      * Recursively parses the value of a "default" element.
      *
-     * @param \DOMElement $node The node value
-     * @param string      $path Full path of the XML file being processed
-     *
-     * @return array|bool|float|int|string The parsed value
-     *
      * @throws \InvalidArgumentException when the XML is invalid
      */
-    private function parseDefaultNode(\DOMElement $node, $path)
+    private function parseDefaultNode(\DOMElement $node, string $path): array|bool|float|int|string|null
     {
         if ($this->isElementValueNull($node)) {
-            return;
+            return null;
         }
 
         switch ($node->localName) {
@@ -293,7 +370,7 @@ class XmlFileLoader extends FileLoader
             case 'string':
                 return trim($node->nodeValue);
             case 'list':
-                $list = array();
+                $list = [];
 
                 foreach ($node->childNodes as $element) {
                     if (!$element instanceof \DOMElement) {
@@ -309,7 +386,7 @@ class XmlFileLoader extends FileLoader
 
                 return $list;
             case 'map':
-                $map = array();
+                $map = [];
 
                 foreach ($node->childNodes as $element) {
                     if (!$element instanceof \DOMElement) {
@@ -329,7 +406,7 @@ class XmlFileLoader extends FileLoader
         }
     }
 
-    private function isElementValueNull(\DOMElement $element)
+    private function isElementValueNull(\DOMElement $element): bool
     {
         $namespaceUri = 'http://www.w3.org/2001/XMLSchema-instance';
 
@@ -339,4 +416,41 @@ class XmlFileLoader extends FileLoader
 
         return 'true' === $element->getAttributeNS($namespaceUri, 'nil') || '1' === $element->getAttributeNS($namespaceUri, 'nil');
     }
+
+    /**
+     * Parses the deprecation elements.
+     *
+     * @throws \InvalidArgumentException When the XML is invalid
+     */
+    private function parseDeprecation(\DOMElement $node, string $path): array
+    {
+        $deprecatedNode = null;
+        foreach ($node->childNodes as $child) {
+            if (!$child instanceof \DOMElement || self::NAMESPACE_URI !== $child->namespaceURI) {
+                continue;
+            }
+            if ('deprecated' !== $child->localName) {
+                throw new \InvalidArgumentException(sprintf('Invalid child element "%s" defined for alias "%s" in "%s".', $child->localName, $node->getAttribute('id'), $path));
+            }
+
+            $deprecatedNode = $child;
+        }
+
+        if (null === $deprecatedNode) {
+            return [];
+        }
+
+        if (!$deprecatedNode->hasAttribute('package')) {
+            throw new \InvalidArgumentException(sprintf('The <deprecated> element in file "%s" must have a "package" attribute.', $path));
+        }
+        if (!$deprecatedNode->hasAttribute('version')) {
+            throw new \InvalidArgumentException(sprintf('The <deprecated> element in file "%s" must have a "version" attribute.', $path));
+        }
+
+        return [
+            'package' => $deprecatedNode->getAttribute('package'),
+            'version' => $deprecatedNode->getAttribute('version'),
+            'message' => trim($deprecatedNode->nodeValue),
+        ];
+    }
 }

vendor/symfony/routing/Loader/YamlFileLoader.php

@@ -11,12 +11,14 @@
 
 namespace Symfony\Component\Routing\Loader;
 
-use Symfony\Component\Routing\RouteCollection;
-use Symfony\Component\Routing\Route;
+use Symfony\Component\Config\Loader\FileLoader;
 use Symfony\Component\Config\Resource\FileResource;
+use Symfony\Component\Routing\Loader\Configurator\Traits\HostTrait;
+use Symfony\Component\Routing\Loader\Configurator\Traits\LocalizedRouteTrait;
+use Symfony\Component\Routing\Loader\Configurator\Traits\PrefixTrait;
+use Symfony\Component\Routing\RouteCollection;
 use Symfony\Component\Yaml\Exception\ParseException;
 use Symfony\Component\Yaml\Parser as YamlParser;
-use Symfony\Component\Config\Loader\FileLoader;
 use Symfony\Component\Yaml\Yaml;
 
 /**
@@ -27,22 +29,19 @@ use Symfony\Component\Yaml\Yaml;
  */
 class YamlFileLoader extends FileLoader
 {
-    private static $availableKeys = array(
-        'resource', 'type', 'prefix', 'path', 'host', 'schemes', 'methods', 'defaults', 'requirements', 'options', 'condition',
-    );
+    use HostTrait;
+    use LocalizedRouteTrait;
+    use PrefixTrait;
+
+    private const AVAILABLE_KEYS = [
+        'resource', 'type', 'prefix', 'path', 'host', 'schemes', 'methods', 'defaults', 'requirements', 'options', 'condition', 'controller', 'name_prefix', 'trailing_slash_on_root', 'locale', 'format', 'utf8', 'exclude', 'stateless',
+    ];
     private $yamlParser;
 
     /**
-     * Loads a Yaml file.
-     *
-     * @param string      $file A Yaml file path
-     * @param string|null $type The resource type
-     *
-     * @return RouteCollection A RouteCollection instance
-     *
      * @throws \InvalidArgumentException When a route can't be parsed because YAML is invalid
      */
-    public function load($file, $type = null)
+    public function load(mixed $file, string $type = null): RouteCollection
     {
         $path = $this->locator->locate($file);
 
@@ -54,14 +53,12 @@ class YamlFileLoader extends FileLoader
             throw new \InvalidArgumentException(sprintf('File "%s" not found.', $path));
         }
 
-        if (null === $this->yamlParser) {
-            $this->yamlParser = new YamlParser();
-        }
+        $this->yamlParser ??= new YamlParser();
 
         try {
-            $parsedConfig = $this->yamlParser->parse(file_get_contents($path), Yaml::PARSE_KEYS_AS_STRINGS);
+            $parsedConfig = $this->yamlParser->parseFile($path, Yaml::PARSE_CONSTANT);
         } catch (ParseException $e) {
-            throw new \InvalidArgumentException(sprintf('The file "%s" does not contain valid YAML.', $path), 0, $e);
+            throw new \InvalidArgumentException(sprintf('The file "%s" does not contain valid YAML: ', $path).$e->getMessage(), 0, $e);
         }
 
         $collection = new RouteCollection();
@@ -73,11 +70,29 @@ class YamlFileLoader extends FileLoader
         }
 
         // not an array
-        if (!is_array($parsedConfig)) {
+        if (!\is_array($parsedConfig)) {
             throw new \InvalidArgumentException(sprintf('The file "%s" must contain a YAML array.', $path));
         }
 
         foreach ($parsedConfig as $name => $config) {
+            if (0 === strpos($name, 'when@')) {
+                if (!$this->env || 'when@'.$this->env !== $name) {
+                    continue;
+                }
+
+                foreach ($config as $name => $config) {
+                    $this->validate($config, $name.'" when "@'.$this->env, $path);
+
+                    if (isset($config['resource'])) {
+                        $this->parseImport($collection, $config, $path, $file);
+                    } else {
+                        $this->parseRoute($collection, $name, $config, $path);
+                    }
+                }
+
+                continue;
+            }
+
             $this->validate($config, $name, $path);
 
             if (isset($config['resource'])) {
@@ -93,116 +108,192 @@ class YamlFileLoader extends FileLoader
     /**
      * {@inheritdoc}
      */
-    public function supports($resource, $type = null)
+    public function supports(mixed $resource, string $type = null): bool
     {
-        return is_string($resource) && in_array(pathinfo($resource, PATHINFO_EXTENSION), array('yml', 'yaml'), true) && (!$type || 'yaml' === $type);
+        return \is_string($resource) && \in_array(pathinfo($resource, \PATHINFO_EXTENSION), ['yml', 'yaml'], true) && (!$type || 'yaml' === $type);
     }
 
     /**
      * Parses a route and adds it to the RouteCollection.
-     *
-     * @param RouteCollection $collection A RouteCollection instance
-     * @param string          $name       Route name
-     * @param array           $config     Route definition
-     * @param string          $path       Full path of the YAML file being processed
      */
-    protected function parseRoute(RouteCollection $collection, $name, array $config, $path)
+    protected function parseRoute(RouteCollection $collection, string $name, array $config, string $path)
     {
-        $defaults = isset($config['defaults']) ? $config['defaults'] : array();
-        $requirements = isset($config['requirements']) ? $config['requirements'] : array();
-        $options = isset($config['options']) ? $config['options'] : array();
-        $host = isset($config['host']) ? $config['host'] : '';
-        $schemes = isset($config['schemes']) ? $config['schemes'] : array();
-        $methods = isset($config['methods']) ? $config['methods'] : array();
-        $condition = isset($config['condition']) ? $config['condition'] : null;
+        if (isset($config['alias'])) {
+            $alias = $collection->addAlias($name, $config['alias']);
+            $deprecation = $config['deprecated'] ?? null;
+            if (null !== $deprecation) {
+                $alias->setDeprecated(
+                    $deprecation['package'],
+                    $deprecation['version'],
+                    $deprecation['message'] ?? ''
+                );
+            }
 
-        $route = new Route($config['path'], $defaults, $requirements, $options, $host, $schemes, $methods, $condition);
+            return;
+        }
 
-        $collection->add($name, $route);
+        $defaults = $config['defaults'] ?? [];
+        $requirements = $config['requirements'] ?? [];
+        $options = $config['options'] ?? [];
+
+        foreach ($requirements as $placeholder => $requirement) {
+            if (\is_int($placeholder)) {
+                throw new \InvalidArgumentException(sprintf('A placeholder name must be a string (%d given). Did you forget to specify the placeholder key for the requirement "%s" of route "%s" in "%s"?', $placeholder, $requirement, $name, $path));
+            }
+        }
+
+        if (isset($config['controller'])) {
+            $defaults['_controller'] = $config['controller'];
+        }
+        if (isset($config['locale'])) {
+            $defaults['_locale'] = $config['locale'];
+        }
+        if (isset($config['format'])) {
+            $defaults['_format'] = $config['format'];
+        }
+        if (isset($config['utf8'])) {
+            $options['utf8'] = $config['utf8'];
+        }
+        if (isset($config['stateless'])) {
+            $defaults['_stateless'] = $config['stateless'];
+        }
+
+        $routes = $this->createLocalizedRoute($collection, $name, $config['path']);
+        $routes->addDefaults($defaults);
+        $routes->addRequirements($requirements);
+        $routes->addOptions($options);
+        $routes->setSchemes($config['schemes'] ?? []);
+        $routes->setMethods($config['methods'] ?? []);
+        $routes->setCondition($config['condition'] ?? null);
+
+        if (isset($config['host'])) {
+            $this->addHost($routes, $config['host']);
+        }
     }
 
     /**
      * Parses an import and adds the routes in the resource to the RouteCollection.
-     *
-     * @param RouteCollection $collection A RouteCollection instance
-     * @param array           $config     Route definition
-     * @param string          $path       Full path of the YAML file being processed
-     * @param string          $file       Loaded file name
      */
-    protected function parseImport(RouteCollection $collection, array $config, $path, $file)
+    protected function parseImport(RouteCollection $collection, array $config, string $path, string $file)
     {
-        $type = isset($config['type']) ? $config['type'] : null;
-        $prefix = isset($config['prefix']) ? $config['prefix'] : '';
-        $defaults = isset($config['defaults']) ? $config['defaults'] : array();
-        $requirements = isset($config['requirements']) ? $config['requirements'] : array();
-        $options = isset($config['options']) ? $config['options'] : array();
-        $host = isset($config['host']) ? $config['host'] : null;
-        $condition = isset($config['condition']) ? $config['condition'] : null;
-        $schemes = isset($config['schemes']) ? $config['schemes'] : null;
-        $methods = isset($config['methods']) ? $config['methods'] : null;
+        $type = $config['type'] ?? null;
+        $prefix = $config['prefix'] ?? '';
+        $defaults = $config['defaults'] ?? [];
+        $requirements = $config['requirements'] ?? [];
+        $options = $config['options'] ?? [];
+        $host = $config['host'] ?? null;
+        $condition = $config['condition'] ?? null;
+        $schemes = $config['schemes'] ?? null;
+        $methods = $config['methods'] ?? null;
+        $trailingSlashOnRoot = $config['trailing_slash_on_root'] ?? true;
+        $namePrefix = $config['name_prefix'] ?? null;
+        $exclude = $config['exclude'] ?? null;
 
-        $this->setCurrentDir(dirname($path));
+        if (isset($config['controller'])) {
+            $defaults['_controller'] = $config['controller'];
+        }
+        if (isset($config['locale'])) {
+            $defaults['_locale'] = $config['locale'];
+        }
+        if (isset($config['format'])) {
+            $defaults['_format'] = $config['format'];
+        }
+        if (isset($config['utf8'])) {
+            $options['utf8'] = $config['utf8'];
+        }
+        if (isset($config['stateless'])) {
+            $defaults['_stateless'] = $config['stateless'];
+        }
 
-        $subCollection = $this->import($config['resource'], $type, false, $file);
-        /* @var $subCollection RouteCollection */
-        $subCollection->addPrefix($prefix);
-        if (null !== $host) {
-            $subCollection->setHost($host);
-        }
-        if (null !== $condition) {
-            $subCollection->setCondition($condition);
-        }
-        if (null !== $schemes) {
-            $subCollection->setSchemes($schemes);
-        }
-        if (null !== $methods) {
-            $subCollection->setMethods($methods);
-        }
-        $subCollection->addDefaults($defaults);
-        $subCollection->addRequirements($requirements);
-        $subCollection->addOptions($options);
+        $this->setCurrentDir(\dirname($path));
 
-        $collection->addCollection($subCollection);
+        /** @var RouteCollection[] $imported */
+        $imported = $this->import($config['resource'], $type, false, $file, $exclude) ?: [];
+
+        if (!\is_array($imported)) {
+            $imported = [$imported];
+        }
+
+        foreach ($imported as $subCollection) {
+            $this->addPrefix($subCollection, $prefix, $trailingSlashOnRoot);
+
+            if (null !== $host) {
+                $this->addHost($subCollection, $host);
+            }
+            if (null !== $condition) {
+                $subCollection->setCondition($condition);
+            }
+            if (null !== $schemes) {
+                $subCollection->setSchemes($schemes);
+            }
+            if (null !== $methods) {
+                $subCollection->setMethods($methods);
+            }
+            if (null !== $namePrefix) {
+                $subCollection->addNamePrefix($namePrefix);
+            }
+            $subCollection->addDefaults($defaults);
+            $subCollection->addRequirements($requirements);
+            $subCollection->addOptions($options);
+
+            $collection->addCollection($subCollection);
+        }
     }
 
     /**
-     * Validates the route configuration.
-     *
-     * @param array  $config A resource config
-     * @param string $name   The config key
-     * @param string $path   The loaded file path
-     *
      * @throws \InvalidArgumentException If one of the provided config keys is not supported,
      *                                   something is missing or the combination is nonsense
      */
-    protected function validate($config, $name, $path)
+    protected function validate(mixed $config, string $name, string $path)
     {
-        if (!is_array($config)) {
+        if (!\is_array($config)) {
             throw new \InvalidArgumentException(sprintf('The definition of "%s" in "%s" must be a YAML array.', $name, $path));
         }
-        if ($extraKeys = array_diff(array_keys($config), self::$availableKeys)) {
-            throw new \InvalidArgumentException(sprintf(
-                'The routing file "%s" contains unsupported keys for "%s": "%s". Expected one of: "%s".',
-                $path, $name, implode('", "', $extraKeys), implode('", "', self::$availableKeys)
-            ));
+        if (isset($config['alias'])) {
+            $this->validateAlias($config, $name, $path);
+
+            return;
+        }
+        if ($extraKeys = array_diff(array_keys($config), self::AVAILABLE_KEYS)) {
+            throw new \InvalidArgumentException(sprintf('The routing file "%s" contains unsupported keys for "%s": "%s". Expected one of: "%s".', $path, $name, implode('", "', $extraKeys), implode('", "', self::AVAILABLE_KEYS)));
         }
         if (isset($config['resource']) && isset($config['path'])) {
-            throw new \InvalidArgumentException(sprintf(
-                'The routing file "%s" must not specify both the "resource" key and the "path" key for "%s". Choose between an import and a route definition.',
-                $path, $name
-            ));
+            throw new \InvalidArgumentException(sprintf('The routing file "%s" must not specify both the "resource" key and the "path" key for "%s". Choose between an import and a route definition.', $path, $name));
         }
         if (!isset($config['resource']) && isset($config['type'])) {
-            throw new \InvalidArgumentException(sprintf(
-                'The "type" key for the route definition "%s" in "%s" is unsupported. It is only available for imports in combination with the "resource" key.',
-                $name, $path
-            ));
+            throw new \InvalidArgumentException(sprintf('The "type" key for the route definition "%s" in "%s" is unsupported. It is only available for imports in combination with the "resource" key.', $name, $path));
         }
         if (!isset($config['resource']) && !isset($config['path'])) {
-            throw new \InvalidArgumentException(sprintf(
-                'You must define a "path" for the route "%s" in file "%s".',
-                $name, $path
-            ));
+            throw new \InvalidArgumentException(sprintf('You must define a "path" for the route "%s" in file "%s".', $name, $path));
+        }
+        if (isset($config['controller']) && isset($config['defaults']['_controller'])) {
+            throw new \InvalidArgumentException(sprintf('The routing file "%s" must not specify both the "controller" key and the defaults key "_controller" for "%s".', $path, $name));
+        }
+        if (isset($config['stateless']) && isset($config['defaults']['_stateless'])) {
+            throw new \InvalidArgumentException(sprintf('The routing file "%s" must not specify both the "stateless" key and the defaults key "_stateless" for "%s".', $path, $name));
+        }
+    }
+
+    /**
+     * @throws \InvalidArgumentException If one of the provided config keys is not supported,
+     *                                   something is missing or the combination is nonsense
+     */
+    private function validateAlias(array $config, string $name, string $path): void
+    {
+        foreach ($config as $key => $value) {
+            if (!\in_array($key, ['alias', 'deprecated'], true)) {
+                throw new \InvalidArgumentException(sprintf('The routing file "%s" must not specify other keys than "alias" and "deprecated" for "%s".', $path, $name));
+            }
+
+            if ('deprecated' === $key) {
+                if (!isset($value['package'])) {
+                    throw new \InvalidArgumentException(sprintf('The routing file "%s" must specify the attribute "package" of the "deprecated" option for "%s".', $path, $name));
+                }
+
+                if (!isset($value['version'])) {
+                    throw new \InvalidArgumentException(sprintf('The routing file "%s" must specify the attribute "version" of the "deprecated" option for "%s".', $path, $name));
+                }
+            }
         }
     }
 }

vendor/symfony/routing/Loader/schema/routing/routing-1.0.xsd

@@ -21,9 +21,26 @@
     <xsd:choice minOccurs="0" maxOccurs="unbounded">
       <xsd:element name="import" type="import" />
       <xsd:element name="route" type="route" />
+      <xsd:element name="when" type="when" />
     </xsd:choice>
   </xsd:complexType>
 
+  <xsd:complexType name="when">
+    <xsd:choice minOccurs="0" maxOccurs="unbounded">
+      <xsd:element name="import" type="import" />
+      <xsd:element name="route" type="route" />
+    </xsd:choice>
+    <xsd:attribute name="env" type="xsd:string" use="required" />
+  </xsd:complexType>
+
+  <xsd:complexType name="localized-path">
+    <xsd:simpleContent>
+      <xsd:extension base="xsd:string">
+        <xsd:attribute name="locale" type="xsd:string" use="required" />
+      </xsd:extension>
+    </xsd:simpleContent>
+  </xsd:complexType>
+
   <xsd:group name="configs">
     <xsd:choice>
       <xsd:element name="default" nillable="true" type="default" />
@@ -34,24 +51,46 @@
   </xsd:group>
 
   <xsd:complexType name="route">
-    <xsd:group ref="configs" minOccurs="0" maxOccurs="unbounded" />
-
+    <xsd:sequence>
+      <xsd:group ref="configs" minOccurs="0" maxOccurs="unbounded" />
+      <xsd:element name="path" type="localized-path" minOccurs="0" maxOccurs="unbounded" />
+      <xsd:element name="host" type="localized-path" minOccurs="0" maxOccurs="unbounded" />
+      <xsd:element name="deprecated" type="deprecated" minOccurs="0" maxOccurs="1" />
+    </xsd:sequence>
     <xsd:attribute name="id" type="xsd:string" use="required" />
-    <xsd:attribute name="path" type="xsd:string" use="required" />
+    <xsd:attribute name="path" type="xsd:string" />
     <xsd:attribute name="host" type="xsd:string" />
     <xsd:attribute name="schemes" type="xsd:string" />
     <xsd:attribute name="methods" type="xsd:string" />
+    <xsd:attribute name="controller" type="xsd:string" />
+    <xsd:attribute name="locale" type="xsd:string" />
+    <xsd:attribute name="format" type="xsd:string" />
+    <xsd:attribute name="utf8" type="xsd:boolean" />
+    <xsd:attribute name="stateless" type="xsd:boolean" />
+    <xsd:attribute name="alias" type="xsd:string" />
   </xsd:complexType>
 
   <xsd:complexType name="import">
-    <xsd:group ref="configs" minOccurs="0" maxOccurs="unbounded" />
-
+    <xsd:sequence maxOccurs="unbounded" minOccurs="0">
+      <xsd:group ref="configs" minOccurs="0" maxOccurs="unbounded" />
+      <xsd:element name="prefix" type="localized-path" minOccurs="0" maxOccurs="unbounded" />
+      <xsd:element name="exclude" type="xsd:string" minOccurs="0" maxOccurs="unbounded" />
+      <xsd:element name="host" type="localized-path" minOccurs="0" maxOccurs="unbounded" />
+    </xsd:sequence>
     <xsd:attribute name="resource" type="xsd:string" use="required" />
     <xsd:attribute name="type" type="xsd:string" />
+    <xsd:attribute name="exclude" type="xsd:string" />
     <xsd:attribute name="prefix" type="xsd:string" />
+    <xsd:attribute name="name-prefix" type="xsd:string" />
     <xsd:attribute name="host" type="xsd:string" />
     <xsd:attribute name="schemes" type="xsd:string" />
     <xsd:attribute name="methods" type="xsd:string" />
+    <xsd:attribute name="controller" type="xsd:string" />
+    <xsd:attribute name="locale" type="xsd:string" />
+    <xsd:attribute name="format" type="xsd:string" />
+    <xsd:attribute name="trailing-slash-on-root" type="xsd:boolean" />
+    <xsd:attribute name="utf8" type="xsd:boolean" />
+    <xsd:attribute name="stateless" type="xsd:boolean" />
   </xsd:complexType>
 
   <xsd:complexType name="default" mixed="true">
@@ -143,4 +182,13 @@
       </xsd:extension>
     </xsd:complexContent>
   </xsd:complexType>
+
+  <xsd:complexType name="deprecated">
+    <xsd:simpleContent>
+      <xsd:extension base="xsd:string">
+        <xsd:attribute name="package" type="xsd:string" use="required" />
+        <xsd:attribute name="version" type="xsd:string" use="required" />
+      </xsd:extension>
+    </xsd:simpleContent>
+  </xsd:complexType>
 </xsd:schema>