Update Composer, update everything

vendor/symfony/routing/Matcher/Dumper/DumperCollection.php

@@ -0,0 +1,159 @@
+<?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\Matcher\Dumper;
+
+/**
+ * Collection of routes.
+ *
+ * @author Arnaud Le Blanc <arnaud.lb@gmail.com>
+ *
+ * @internal
+ */
+class DumperCollection implements \IteratorAggregate
+{
+    /**
+     * @var DumperCollection|null
+     */
+    private $parent;
+
+    /**
+     * @var DumperCollection[]|DumperRoute[]
+     */
+    private $children = array();
+
+    /**
+     * @var array
+     */
+    private $attributes = array();
+
+    /**
+     * Returns the children routes and collections.
+     *
+     * @return self[]|DumperRoute[]
+     */
+    public function all()
+    {
+        return $this->children;
+    }
+
+    /**
+     * Adds a route or collection.
+     *
+     * @param DumperRoute|DumperCollection The route or collection
+     */
+    public function add($child)
+    {
+        if ($child instanceof self) {
+            $child->setParent($this);
+        }
+        $this->children[] = $child;
+    }
+
+    /**
+     * Sets children.
+     *
+     * @param array $children The children
+     */
+    public function setAll(array $children)
+    {
+        foreach ($children as $child) {
+            if ($child instanceof self) {
+                $child->setParent($this);
+            }
+        }
+        $this->children = $children;
+    }
+
+    /**
+     * Returns an iterator over the children.
+     *
+     * @return \Iterator|DumperCollection[]|DumperRoute[] The iterator
+     */
+    public function getIterator()
+    {
+        return new \ArrayIterator($this->children);
+    }
+
+    /**
+     * Returns the root of the collection.
+     *
+     * @return self The root collection
+     */
+    public function getRoot()
+    {
+        return (null !== $this->parent) ? $this->parent->getRoot() : $this;
+    }
+
+    /**
+     * Returns the parent collection.
+     *
+     * @return self|null The parent collection or null if the collection has no parent
+     */
+    protected function getParent()
+    {
+        return $this->parent;
+    }
+
+    /**
+     * Sets the parent collection.
+     */
+    protected function setParent(self $parent)
+    {
+        $this->parent = $parent;
+    }
+
+    /**
+     * Returns true if the attribute is defined.
+     *
+     * @param string $name The attribute name
+     *
+     * @return bool true if the attribute is defined, false otherwise
+     */
+    public function hasAttribute($name)
+    {
+        return array_key_exists($name, $this->attributes);
+    }
+
+    /**
+     * Returns an attribute by name.
+     *
+     * @param string $name    The attribute name
+     * @param mixed  $default Default value is the attribute doesn't exist
+     *
+     * @return mixed The attribute value
+     */
+    public function getAttribute($name, $default = null)
+    {
+        return $this->hasAttribute($name) ? $this->attributes[$name] : $default;
+    }
+
+    /**
+     * Sets an attribute by name.
+     *
+     * @param string $name  The attribute name
+     * @param mixed  $value The attribute value
+     */
+    public function setAttribute($name, $value)
+    {
+        $this->attributes[$name] = $value;
+    }
+
+    /**
+     * Sets multiple attributes.
+     *
+     * @param array $attributes The attributes
+     */
+    public function setAttributes($attributes)
+    {
+        $this->attributes = $attributes;
+    }
+}

vendor/symfony/routing/Matcher/Dumper/DumperRoute.php

@@ -0,0 +1,57 @@
+<?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\Matcher\Dumper;
+
+use Symfony\Component\Routing\Route;
+
+/**
+ * Container for a Route.
+ *
+ * @author Arnaud Le Blanc <arnaud.lb@gmail.com>
+ *
+ * @internal
+ */
+class DumperRoute
+{
+    private $name;
+    private $route;
+
+    /**
+     * @param string $name  The route name
+     * @param Route  $route The route
+     */
+    public function __construct($name, Route $route)
+    {
+        $this->name = $name;
+        $this->route = $route;
+    }
+
+    /**
+     * Returns the route name.
+     *
+     * @return string The route name
+     */
+    public function getName()
+    {
+        return $this->name;
+    }
+
+    /**
+     * Returns the route.
+     *
+     * @return Route The route
+     */
+    public function getRoute()
+    {
+        return $this->route;
+    }
+}

vendor/symfony/routing/Matcher/Dumper/MatcherDumper.php

@@ -0,0 +1,37 @@
+<?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\Matcher\Dumper;
+
+use Symfony\Component\Routing\RouteCollection;
+
+/**
+ * MatcherDumper is the abstract class for all built-in matcher dumpers.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+abstract class MatcherDumper implements MatcherDumperInterface
+{
+    private $routes;
+
+    public function __construct(RouteCollection $routes)
+    {
+        $this->routes = $routes;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getRoutes()
+    {
+        return $this->routes;
+    }
+}

vendor/symfony/routing/Matcher/Dumper/MatcherDumperInterface.php

@@ -0,0 +1,39 @@
+<?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\Matcher\Dumper;
+
+use Symfony\Component\Routing\RouteCollection;
+
+/**
+ * MatcherDumperInterface is the interface that all matcher dumper classes must implement.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+interface MatcherDumperInterface
+{
+    /**
+     * Dumps a set of routes to a string representation of executable code
+     * that can then be used to match a request against these routes.
+     *
+     * @param array $options An array of options
+     *
+     * @return string Executable code
+     */
+    public function dump(array $options = array());
+
+    /**
+     * Gets the routes to dump.
+     *
+     * @return RouteCollection A RouteCollection instance
+     */
+    public function getRoutes();
+}

vendor/symfony/routing/Matcher/Dumper/PhpMatcherDumper.php

@@ -0,0 +1,429 @@
+<?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\Matcher\Dumper;
+
+use Symfony\Component\ExpressionLanguage\ExpressionFunctionProviderInterface;
+use Symfony\Component\ExpressionLanguage\ExpressionLanguage;
+use Symfony\Component\Routing\Route;
+use Symfony\Component\Routing\RouteCollection;
+
+/**
+ * PhpMatcherDumper creates a PHP class able to match URLs for a given set of routes.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ * @author Tobias Schultze <http://tobion.de>
+ * @author Arnaud Le Blanc <arnaud.lb@gmail.com>
+ */
+class PhpMatcherDumper extends MatcherDumper
+{
+    private $expressionLanguage;
+
+    /**
+     * @var ExpressionFunctionProviderInterface[]
+     */
+    private $expressionLanguageProviders = array();
+
+    /**
+     * Dumps a set of routes to a PHP class.
+     *
+     * Available options:
+     *
+     *  * class:      The class name
+     *  * base_class: The base class name
+     *
+     * @param array $options An array of options
+     *
+     * @return string A PHP class representing the matcher class
+     */
+    public function dump(array $options = array())
+    {
+        $options = array_replace(array(
+            'class' => 'ProjectUrlMatcher',
+            'base_class' => 'Symfony\\Component\\Routing\\Matcher\\UrlMatcher',
+        ), $options);
+
+        // trailing slash support is only enabled if we know how to redirect the user
+        $interfaces = class_implements($options['base_class']);
+        $supportsRedirections = isset($interfaces['Symfony\\Component\\Routing\\Matcher\\RedirectableUrlMatcherInterface']);
+
+        return <<<EOF
+<?php
+
+use Symfony\Component\Routing\Exception\MethodNotAllowedException;
+use Symfony\Component\Routing\Exception\ResourceNotFoundException;
+use Symfony\Component\Routing\RequestContext;
+
+/**
+ * This class has been auto-generated
+ * by the Symfony Routing Component.
+ */
+class {$options['class']} extends {$options['base_class']}
+{
+    public function __construct(RequestContext \$context)
+    {
+        \$this->context = \$context;
+    }
+
+{$this->generateMatchMethod($supportsRedirections)}
+}
+
+EOF;
+    }
+
+    public function addExpressionLanguageProvider(ExpressionFunctionProviderInterface $provider)
+    {
+        $this->expressionLanguageProviders[] = $provider;
+    }
+
+    /**
+     * Generates the code for the match method implementing UrlMatcherInterface.
+     *
+     * @param bool $supportsRedirections Whether redirections are supported by the base class
+     *
+     * @return string Match method as PHP code
+     */
+    private function generateMatchMethod($supportsRedirections)
+    {
+        $code = rtrim($this->compileRoutes($this->getRoutes(), $supportsRedirections), "\n");
+
+        return <<<EOF
+    public function match(\$rawPathinfo)
+    {
+        \$allow = array();
+        \$pathinfo = rawurldecode(\$rawPathinfo);
+        \$trimmedPathinfo = rtrim(\$pathinfo, '/');
+        \$context = \$this->context;
+        \$request = \$this->request ?: \$this->createRequest(\$pathinfo);
+        \$requestMethod = \$canonicalMethod = \$context->getMethod();
+
+        if ('HEAD' === \$requestMethod) {
+            \$canonicalMethod = 'GET';
+        }
+
+$code
+
+        throw 0 < count(\$allow) ? new MethodNotAllowedException(array_unique(\$allow)) : new ResourceNotFoundException();
+    }
+EOF;
+    }
+
+    /**
+     * Generates PHP code to match a RouteCollection with all its routes.
+     *
+     * @param RouteCollection $routes               A RouteCollection instance
+     * @param bool            $supportsRedirections Whether redirections are supported by the base class
+     *
+     * @return string PHP code
+     */
+    private function compileRoutes(RouteCollection $routes, $supportsRedirections)
+    {
+        $fetchedHost = false;
+        $groups = $this->groupRoutesByHostRegex($routes);
+        $code = '';
+
+        foreach ($groups as $collection) {
+            if (null !== $regex = $collection->getAttribute('host_regex')) {
+                if (!$fetchedHost) {
+                    $code .= "        \$host = \$context->getHost();\n\n";
+                    $fetchedHost = true;
+                }
+
+                $code .= sprintf("        if (preg_match(%s, \$host, \$hostMatches)) {\n", var_export($regex, true));
+            }
+
+            $tree = $this->buildStaticPrefixCollection($collection);
+            $groupCode = $this->compileStaticPrefixRoutes($tree, $supportsRedirections);
+
+            if (null !== $regex) {
+                // apply extra indention at each line (except empty ones)
+                $groupCode = preg_replace('/^.{2,}$/m', '    $0', $groupCode);
+                $code .= $groupCode;
+                $code .= "        }\n\n";
+            } else {
+                $code .= $groupCode;
+            }
+        }
+
+        // used to display the Welcome Page in apps that don't define a homepage
+        $code .= "        if ('/' === \$pathinfo && !\$allow) {\n";
+        $code .= "            throw new Symfony\Component\Routing\Exception\NoConfigurationException();\n";
+        $code .= "        }\n";
+
+        return $code;
+    }
+
+    private function buildStaticPrefixCollection(DumperCollection $collection)
+    {
+        $prefixCollection = new StaticPrefixCollection();
+
+        foreach ($collection as $dumperRoute) {
+            $prefix = $dumperRoute->getRoute()->compile()->getStaticPrefix();
+            $prefixCollection->addRoute($prefix, $dumperRoute);
+        }
+
+        $prefixCollection->optimizeGroups();
+
+        return $prefixCollection;
+    }
+
+    /**
+     * Generates PHP code to match a tree of routes.
+     *
+     * @param StaticPrefixCollection $collection           A StaticPrefixCollection instance
+     * @param bool                   $supportsRedirections Whether redirections are supported by the base class
+     * @param string                 $ifOrElseIf           either "if" or "elseif" to influence chaining
+     *
+     * @return string PHP code
+     */
+    private function compileStaticPrefixRoutes(StaticPrefixCollection $collection, $supportsRedirections, $ifOrElseIf = 'if')
+    {
+        $code = '';
+        $prefix = $collection->getPrefix();
+
+        if (!empty($prefix) && '/' !== $prefix) {
+            $code .= sprintf("    %s (0 === strpos(\$pathinfo, %s)) {\n", $ifOrElseIf, var_export($prefix, true));
+        }
+
+        $ifOrElseIf = 'if';
+
+        foreach ($collection->getItems() as $route) {
+            if ($route instanceof StaticPrefixCollection) {
+                $code .= $this->compileStaticPrefixRoutes($route, $supportsRedirections, $ifOrElseIf);
+                $ifOrElseIf = 'elseif';
+            } else {
+                $code .= $this->compileRoute($route[1]->getRoute(), $route[1]->getName(), $supportsRedirections, $prefix)."\n";
+                $ifOrElseIf = 'if';
+            }
+        }
+
+        if (!empty($prefix) && '/' !== $prefix) {
+            $code .= "    }\n\n";
+            // apply extra indention at each line (except empty ones)
+            $code = preg_replace('/^.{2,}$/m', '    $0', $code);
+        }
+
+        return $code;
+    }
+
+    /**
+     * Compiles a single Route to PHP code used to match it against the path info.
+     *
+     * @param Route       $route                A Route instance
+     * @param string      $name                 The name of the Route
+     * @param bool        $supportsRedirections Whether redirections are supported by the base class
+     * @param string|null $parentPrefix         The prefix of the parent collection used to optimize the code
+     *
+     * @return string PHP code
+     *
+     * @throws \LogicException
+     */
+    private function compileRoute(Route $route, $name, $supportsRedirections, $parentPrefix = null)
+    {
+        $code = '';
+        $compiledRoute = $route->compile();
+        $conditions = array();
+        $hasTrailingSlash = false;
+        $matches = false;
+        $hostMatches = false;
+        $methods = $route->getMethods();
+
+        $supportsTrailingSlash = $supportsRedirections && (!$methods || \in_array('GET', $methods));
+        $regex = $compiledRoute->getRegex();
+
+        if (!\count($compiledRoute->getPathVariables()) && false !== preg_match('#^(.)\^(?P<url>.*?)\$\1#'.('u' === substr($regex, -1) ? 'u' : ''), $regex, $m)) {
+            if ($supportsTrailingSlash && '/' === substr($m['url'], -1)) {
+                $conditions[] = sprintf('%s === $trimmedPathinfo', var_export(rtrim(str_replace('\\', '', $m['url']), '/'), true));
+                $hasTrailingSlash = true;
+            } else {
+                $conditions[] = sprintf('%s === $pathinfo', var_export(str_replace('\\', '', $m['url']), true));
+            }
+        } else {
+            if ($compiledRoute->getStaticPrefix() && $compiledRoute->getStaticPrefix() !== $parentPrefix) {
+                $conditions[] = sprintf('0 === strpos($pathinfo, %s)', var_export($compiledRoute->getStaticPrefix(), true));
+            }
+
+            if ($supportsTrailingSlash && $pos = strpos($regex, '/$')) {
+                $regex = substr($regex, 0, $pos).'/?$'.substr($regex, $pos + 2);
+                $hasTrailingSlash = true;
+            }
+            $conditions[] = sprintf('preg_match(%s, $pathinfo, $matches)', var_export($regex, true));
+
+            $matches = true;
+        }
+
+        if ($compiledRoute->getHostVariables()) {
+            $hostMatches = true;
+        }
+
+        if ($route->getCondition()) {
+            $conditions[] = $this->getExpressionLanguage()->compile($route->getCondition(), array('context', 'request'));
+        }
+
+        $conditions = implode(' && ', $conditions);
+
+        $code .= <<<EOF
+        // $name
+        if ($conditions) {
+
+EOF;
+
+        $gotoname = 'not_'.preg_replace('/[^A-Za-z0-9_]/', '', $name);
+
+        // the offset where the return value is appended below, with indendation
+        $retOffset = 12 + \strlen($code);
+
+        // optimize parameters array
+        if ($matches || $hostMatches) {
+            $vars = array();
+            if ($hostMatches) {
+                $vars[] = '$hostMatches';
+            }
+            if ($matches) {
+                $vars[] = '$matches';
+            }
+            $vars[] = "array('_route' => '$name')";
+
+            $code .= sprintf(
+                "            \$ret = \$this->mergeDefaults(array_replace(%s), %s);\n",
+                implode(', ', $vars),
+                str_replace("\n", '', var_export($route->getDefaults(), true))
+            );
+        } elseif ($route->getDefaults()) {
+            $code .= sprintf("            \$ret = %s;\n", str_replace("\n", '', var_export(array_replace($route->getDefaults(), array('_route' => $name)), true)));
+        } else {
+            $code .= sprintf("            \$ret = array('_route' => '%s');\n", $name);
+        }
+
+        if ($hasTrailingSlash) {
+            $code .= <<<EOF
+            if ('/' === substr(\$pathinfo, -1)) {
+                // no-op
+            } elseif ('GET' !== \$canonicalMethod) {
+                goto $gotoname;
+            } else {
+                return array_replace(\$ret, \$this->redirect(\$rawPathinfo.'/', '$name'));
+            }
+
+
+EOF;
+        }
+
+        if ($methods) {
+            $methodVariable = \in_array('GET', $methods) ? '$canonicalMethod' : '$requestMethod';
+            $methods = implode("', '", $methods);
+        }
+
+        if ($schemes = $route->getSchemes()) {
+            if (!$supportsRedirections) {
+                throw new \LogicException('The "schemes" requirement is only supported for URL matchers that implement RedirectableUrlMatcherInterface.');
+            }
+            $schemes = str_replace("\n", '', var_export(array_flip($schemes), true));
+            if ($methods) {
+                $code .= <<<EOF
+            \$requiredSchemes = $schemes;
+            \$hasRequiredScheme = isset(\$requiredSchemes[\$context->getScheme()]);
+            if (!in_array($methodVariable, array('$methods'))) {
+                if (\$hasRequiredScheme) {
+                    \$allow = array_merge(\$allow, array('$methods'));
+                }
+                goto $gotoname;
+            }
+            if (!\$hasRequiredScheme) {
+                if ('GET' !== \$canonicalMethod) {
+                    goto $gotoname;
+                }
+
+                return array_replace(\$ret, \$this->redirect(\$rawPathinfo, '$name', key(\$requiredSchemes)));
+            }
+
+
+EOF;
+            } else {
+                $code .= <<<EOF
+            \$requiredSchemes = $schemes;
+            if (!isset(\$requiredSchemes[\$context->getScheme()])) {
+                if ('GET' !== \$canonicalMethod) {
+                    goto $gotoname;
+                }
+
+                return array_replace(\$ret, \$this->redirect(\$rawPathinfo, '$name', key(\$requiredSchemes)));
+            }
+
+
+EOF;
+            }
+        } elseif ($methods) {
+            $code .= <<<EOF
+            if (!in_array($methodVariable, array('$methods'))) {
+                \$allow = array_merge(\$allow, array('$methods'));
+                goto $gotoname;
+            }
+
+
+EOF;
+        }
+
+        if ($hasTrailingSlash || $schemes || $methods) {
+            $code .= "            return \$ret;\n";
+        } else {
+            $code = substr_replace($code, 'return', $retOffset, 6);
+        }
+        $code .= "        }\n";
+
+        if ($hasTrailingSlash || $schemes || $methods) {
+            $code .= "        $gotoname:\n";
+        }
+
+        return $code;
+    }
+
+    /**
+     * Groups consecutive routes having the same host regex.
+     *
+     * The result is a collection of collections of routes having the same host regex.
+     *
+     * @param RouteCollection $routes A flat RouteCollection
+     *
+     * @return DumperCollection A collection with routes grouped by host regex in sub-collections
+     */
+    private function groupRoutesByHostRegex(RouteCollection $routes)
+    {
+        $groups = new DumperCollection();
+        $currentGroup = new DumperCollection();
+        $currentGroup->setAttribute('host_regex', null);
+        $groups->add($currentGroup);
+
+        foreach ($routes as $name => $route) {
+            $hostRegex = $route->compile()->getHostRegex();
+            if ($currentGroup->getAttribute('host_regex') !== $hostRegex) {
+                $currentGroup = new DumperCollection();
+                $currentGroup->setAttribute('host_regex', $hostRegex);
+                $groups->add($currentGroup);
+            }
+            $currentGroup->add(new DumperRoute($name, $route));
+        }
+
+        return $groups;
+    }
+
+    private function getExpressionLanguage()
+    {
+        if (null === $this->expressionLanguage) {
+            if (!class_exists('Symfony\Component\ExpressionLanguage\ExpressionLanguage')) {
+                throw new \RuntimeException('Unable to use expressions as the Symfony ExpressionLanguage component is not installed.');
+            }
+            $this->expressionLanguage = new ExpressionLanguage(null, $this->expressionLanguageProviders);
+        }
+
+        return $this->expressionLanguage;
+    }
+}

vendor/symfony/routing/Matcher/Dumper/StaticPrefixCollection.php

@@ -0,0 +1,238 @@
+<?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\Matcher\Dumper;
+
+/**
+ * Prefix tree of routes preserving routes order.
+ *
+ * @author Frank de Jonge <info@frankdejonge.nl>
+ *
+ * @internal
+ */
+class StaticPrefixCollection
+{
+    /**
+     * @var string
+     */
+    private $prefix;
+
+    /**
+     * @var array[]|StaticPrefixCollection[]
+     */
+    private $items = array();
+
+    /**
+     * @var int
+     */
+    private $matchStart = 0;
+
+    public function __construct($prefix = '')
+    {
+        $this->prefix = $prefix;
+    }
+
+    public function getPrefix()
+    {
+        return $this->prefix;
+    }
+
+    /**
+     * @return mixed[]|StaticPrefixCollection[]
+     */
+    public function getItems()
+    {
+        return $this->items;
+    }
+
+    /**
+     * Adds a route to a group.
+     *
+     * @param string $prefix
+     * @param mixed  $route
+     */
+    public function addRoute($prefix, $route)
+    {
+        $prefix = '/' === $prefix ? $prefix : rtrim($prefix, '/');
+        $this->guardAgainstAddingNotAcceptedRoutes($prefix);
+
+        if ($this->prefix === $prefix) {
+            // When a prefix is exactly the same as the base we move up the match start position.
+            // This is needed because otherwise routes that come afterwards have higher precedence
+            // than a possible regular expression, which goes against the input order sorting.
+            $this->items[] = array($prefix, $route);
+            $this->matchStart = \count($this->items);
+
+            return;
+        }
+
+        foreach ($this->items as $i => $item) {
+            if ($i < $this->matchStart) {
+                continue;
+            }
+
+            if ($item instanceof self && $item->accepts($prefix)) {
+                $item->addRoute($prefix, $route);
+
+                return;
+            }
+
+            $group = $this->groupWithItem($item, $prefix, $route);
+
+            if ($group instanceof self) {
+                $this->items[$i] = $group;
+
+                return;
+            }
+        }
+
+        // No optimised case was found, in this case we simple add the route for possible
+        // grouping when new routes are added.
+        $this->items[] = array($prefix, $route);
+    }
+
+    /**
+     * Tries to combine a route with another route or group.
+     *
+     * @param StaticPrefixCollection|array $item
+     * @param string                       $prefix
+     * @param mixed                        $route
+     *
+     * @return StaticPrefixCollection|null
+     */
+    private function groupWithItem($item, $prefix, $route)
+    {
+        $itemPrefix = $item instanceof self ? $item->prefix : $item[0];
+        $commonPrefix = $this->detectCommonPrefix($prefix, $itemPrefix);
+
+        if (!$commonPrefix) {
+            return;
+        }
+
+        $child = new self($commonPrefix);
+
+        if ($item instanceof self) {
+            $child->items = array($item);
+        } else {
+            $child->addRoute($item[0], $item[1]);
+        }
+
+        $child->addRoute($prefix, $route);
+
+        return $child;
+    }
+
+    /**
+     * Checks whether a prefix can be contained within the group.
+     *
+     * @param string $prefix
+     *
+     * @return bool Whether a prefix could belong in a given group
+     */
+    private function accepts($prefix)
+    {
+        return '' === $this->prefix || 0 === strpos($prefix, $this->prefix);
+    }
+
+    /**
+     * Detects whether there's a common prefix relative to the group prefix and returns it.
+     *
+     * @param string $prefix
+     * @param string $anotherPrefix
+     *
+     * @return false|string A common prefix, longer than the base/group prefix, or false when none available
+     */
+    private function detectCommonPrefix($prefix, $anotherPrefix)
+    {
+        $baseLength = \strlen($this->prefix);
+        $commonLength = $baseLength;
+        $end = min(\strlen($prefix), \strlen($anotherPrefix));
+
+        for ($i = $baseLength; $i <= $end; ++$i) {
+            if (substr($prefix, 0, $i) !== substr($anotherPrefix, 0, $i)) {
+                break;
+            }
+
+            $commonLength = $i;
+        }
+
+        $commonPrefix = rtrim(substr($prefix, 0, $commonLength), '/');
+
+        if (\strlen($commonPrefix) > $baseLength) {
+            return $commonPrefix;
+        }
+
+        return false;
+    }
+
+    /**
+     * Optimizes the tree by inlining items from groups with less than 3 items.
+     */
+    public function optimizeGroups()
+    {
+        $index = -1;
+
+        while (isset($this->items[++$index])) {
+            $item = $this->items[$index];
+
+            if ($item instanceof self) {
+                $item->optimizeGroups();
+
+                // When a group contains only two items there's no reason to optimize because at minimum
+                // the amount of prefix check is 2. In this case inline the group.
+                if ($item->shouldBeInlined()) {
+                    array_splice($this->items, $index, 1, $item->items);
+
+                    // Lower index to pass through the same index again after optimizing.
+                    // The first item of the replacements might be a group needing optimization.
+                    --$index;
+                }
+            }
+        }
+    }
+
+    private function shouldBeInlined()
+    {
+        if (\count($this->items) >= 3) {
+            return false;
+        }
+
+        foreach ($this->items as $item) {
+            if ($item instanceof self) {
+                return true;
+            }
+        }
+
+        foreach ($this->items as $item) {
+            if (\is_array($item) && $item[0] === $this->prefix) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Guards against adding incompatible prefixes in a group.
+     *
+     * @param string $prefix
+     *
+     * @throws \LogicException when a prefix does not belong in a group
+     */
+    private function guardAgainstAddingNotAcceptedRoutes($prefix)
+    {
+        if (!$this->accepts($prefix)) {
+            $message = sprintf('Could not add route with prefix %s to collection with prefix %s', $prefix, $this->prefix);
+
+            throw new \LogicException($message);
+        }
+    }
+}