<form method="POST">
    <h3>Editing: RouteCollectionBuilder.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php

/*
 * This file is part of the Symfony package.
 *
 * (c) Fabien Potencier &lt;fabien@symfony.com&gt;
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Symfony\Component\Routing;

use Symfony\Component\Config\Exception\LoaderLoadException;
use Symfony\Component\Config\Loader\LoaderInterface;
use Symfony\Component\Config\Resource\ResourceInterface;
use Symfony\Component\Routing\Loader\Configurator\RoutingConfigurator;

trigger_deprecation('symfony/routing', '5.1', 'The &quot;%s&quot; class is deprecated, use &quot;%s&quot; instead.', RouteCollectionBuilder::class, RoutingConfigurator::class);

/**
 * Helps add and import routes into a RouteCollection.
 *
 * @author Ryan Weaver &lt;ryan@knpuniversity.com&gt;
 *
 * @deprecated since Symfony 5.1, use RoutingConfigurator instead
 */
class RouteCollectionBuilder
{
    /**
     * @var Route[]|RouteCollectionBuilder[]
     */
    private $routes = [];

    private $loader;
    private $defaults = [];
    private $prefix;
    private $host;
    private $condition;
    private $requirements = [];
    private $options = [];
    private $schemes;
    private $methods;
    private $resources = [];

    public function __construct(?LoaderInterface $loader = null)
    {
        $this-&gt;loader = $loader;
    }

    /**
     * Import an external routing resource and returns the RouteCollectionBuilder.
     *
     *     $routes-&gt;import('blog.yml', '/blog');
     *
     * @param mixed $resource
     *
     * @return self
     *
     * @throws LoaderLoadException
     */
    public function import($resource, string $prefix = '/', ?string $type = null)
    {
        /** @var RouteCollection[] $collections */
        $collections = $this-&gt;load($resource, $type);

        // create a builder from the RouteCollection
        $builder = $this-&gt;createBuilder();

        foreach ($collections as $collection) {
            if (null === $collection) {
                continue;
            }

            foreach ($collection-&gt;all() as $name =&gt; $route) {
                $builder-&gt;addRoute($route, $name);
            }

            foreach ($collection-&gt;getResources() as $resource) {
                $builder-&gt;addResource($resource);
            }
        }

        // mount into this builder
        $this-&gt;mount($prefix, $builder);

        return $builder;
    }

    /**
     * Adds a route and returns it for future modification.
     *
     * @return Route
     */
    public function add(string $path, string $controller, ?string $name = null)
    {
        $route = new Route($path);
        $route-&gt;setDefault('_controller', $controller);
        $this-&gt;addRoute($route, $name);

        return $route;
    }

    /**
     * Returns a RouteCollectionBuilder that can be configured and then added with mount().
     *
     * @return self
     */
    public function createBuilder()
    {
        return new self($this-&gt;loader);
    }

    /**
     * Add a RouteCollectionBuilder.
     */
    public function mount(string $prefix, self $builder)
    {
        $builder-&gt;prefix = trim(trim($prefix), '/');
        $this-&gt;routes[] = $builder;
    }

    /**
     * Adds a Route object to the builder.
     *
     * @return $this
     */
    public function addRoute(Route $route, ?string $name = null)
    {
        if (null === $name) {
            // used as a flag to know which routes will need a name later
            $name = '_unnamed_route_'.spl_object_hash($route);
        }

        $this-&gt;routes[$name] = $route;

        return $this;
    }

    /**
     * Sets the host on all embedded routes (unless already set).
     *
     * @return $this
     */
    public function setHost(?string $pattern)
    {
        $this-&gt;host = $pattern;

        return $this;
    }

    /**
     * Sets a condition on all embedded routes (unless already set).
     *
     * @return $this
     */
    public function setCondition(?string $condition)
    {
        $this-&gt;condition = $condition;

        return $this;
    }

    /**
     * Sets a default value that will be added to all embedded routes (unless that
     * default value is already set).
     *
     * @param mixed $value
     *
     * @return $this
     */
    public function setDefault(string $key, $value)
    {
        $this-&gt;defaults[$key] = $value;

        return $this;
    }

    /**
     * Sets a requirement that will be added to all embedded routes (unless that
     * requirement is already set).
     *
     * @param mixed $regex
     *
     * @return $this
     */
    public function setRequirement(string $key, $regex)
    {
        $this-&gt;requirements[$key] = $regex;

        return $this;
    }

    /**
     * Sets an option that will be added to all embedded routes (unless that
     * option is already set).
     *
     * @param mixed $value
     *
     * @return $this
     */
    public function setOption(string $key, $value)
    {
        $this-&gt;options[$key] = $value;

        return $this;
    }

    /**
     * Sets the schemes on all embedded routes (unless already set).
     *
     * @param array|string $schemes
     *
     * @return $this
     */
    public function setSchemes($schemes)
    {
        $this-&gt;schemes = $schemes;

        return $this;
    }

    /**
     * Sets the methods on all embedded routes (unless already set).
     *
     * @param array|string $methods
     *
     * @return $this
     */
    public function setMethods($methods)
    {
        $this-&gt;methods = $methods;

        return $this;
    }

    /**
     * Adds a resource for this collection.
     *
     * @return $this
     */
    private function addResource(ResourceInterface $resource): self
    {
        $this-&gt;resources[] = $resource;

        return $this;
    }

    /**
     * Creates the final RouteCollection and returns it.
     *
     * @return RouteCollection
     */
    public function build()
    {
        $routeCollection = new RouteCollection();

        foreach ($this-&gt;routes as $name =&gt; $route) {
            if ($route instanceof Route) {
                $route-&gt;setDefaults(array_merge($this-&gt;defaults, $route-&gt;getDefaults()));
                $route-&gt;setOptions(array_merge($this-&gt;options, $route-&gt;getOptions()));

                foreach ($this-&gt;requirements as $key =&gt; $val) {
                    if (!$route-&gt;hasRequirement($key)) {
                        $route-&gt;setRequirement($key, $val);
                    }
                }

                if (null !== $this-&gt;prefix) {
                    $route-&gt;setPath('/'.$this-&gt;prefix.$route-&gt;getPath());
                }

                if (!$route-&gt;getHost()) {
                    $route-&gt;setHost($this-&gt;host);
                }

                if (!$route-&gt;getCondition()) {
                    $route-&gt;setCondition($this-&gt;condition);
                }

                if (!$route-&gt;getSchemes()) {
                    $route-&gt;setSchemes($this-&gt;schemes);
                }

                if (!$route-&gt;getMethods()) {
                    $route-&gt;setMethods($this-&gt;methods);
                }

                // auto-generate the route name if it's been marked
                if ('_unnamed_route_' === substr($name, 0, 15)) {
                    $name = $this-&gt;generateRouteName($route);
                }

                $routeCollection-&gt;add($name, $route);
            } else {
                /* @var self $route */
                $subCollection = $route-&gt;build();
                if (null !== $this-&gt;prefix) {
                    $subCollection-&gt;addPrefix($this-&gt;prefix);
                }

                $routeCollection-&gt;addCollection($subCollection);
            }
        }

        foreach ($this-&gt;resources as $resource) {
            $routeCollection-&gt;addResource($resource);
        }

        return $routeCollection;
    }

    /**
     * Generates a route name based on details of this route.
     */
    private function generateRouteName(Route $route): string
    {
        $methods = implode('_', $route-&gt;getMethods()).'_';

        $routeName = $methods.$route-&gt;getPath();
        $routeName = str_replace(['/', ':', '|', '-'], '_', $routeName);
        $routeName = preg_replace('/[^a-z0-9A-Z_.]+/', '', $routeName);

        // Collapse consecutive underscores down into a single underscore.
        $routeName = preg_replace('/_+/', '_', $routeName);

        return $routeName;
    }

    /**
     * Finds a loader able to load an imported resource and loads it.
     *
     * @param mixed       $resource A resource
     * @param string|null $type     The resource type or null if unknown
     *
     * @return RouteCollection[]
     *
     * @throws LoaderLoadException If no loader is found
     */
    private function load($resource, ?string $type = null): array
    {
        if (null === $this-&gt;loader) {
            throw new \BadMethodCallException('Cannot import other routing resources: you must pass a LoaderInterface when constructing RouteCollectionBuilder.');
        }

        if ($this-&gt;loader-&gt;supports($resource, $type)) {
            $collections = $this-&gt;loader-&gt;load($resource, $type);

            return \is_array($collections) ? $collections : [$collections];
        }

        if (null === $resolver = $this-&gt;loader-&gt;getResolver()) {
            throw new LoaderLoadException($resource, null, 0, null, $type);
        }

        if (false === $loader = $resolver-&gt;resolve($resource, $type)) {
            throw new LoaderLoadException($resource, null, 0, null, $type);
        }

        $collections = $loader-&gt;load($resource, $type);

        return \is_array($collections) ? $collections : [$collections];
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>