composer update

vendor/nikic/fast-route/.gitignore

@@ -0,0 +1,4 @@
+/vendor/
+
+# ignore lock file since we have no extra dependencies
+composer.lock

vendor/nikic/fast-route/.hhconfig

@@ -0,0 +1 @@
+assume_php=false

vendor/nikic/fast-route/FastRoute.hhi

@@ -0,0 +1,126 @@
+<?hh // decl
+
+namespace FastRoute {
+    class BadRouteException extends \LogicException {
+    }
+
+    interface RouteParser {
+        public function parse(string $route): array<array>;
+    }
+
+    class RouteCollector {
+        public function __construct(RouteParser $routeParser, DataGenerator $dataGenerator);
+        public function addRoute(mixed $httpMethod, string $route, mixed $handler): void;
+        public function getData(): array;
+    }
+
+    class Route {
+        public function __construct(string $httpMethod, mixed $handler, string $regex, array $variables);
+        public function matches(string $str): bool;
+    }
+
+    interface DataGenerator {
+        public function addRoute(string $httpMethod, array $routeData, mixed $handler);
+        public function getData(): array;
+    }
+
+    interface Dispatcher {
+        const int NOT_FOUND = 0;
+        const int FOUND = 1;
+        const int METHOD_NOT_ALLOWED = 2;
+        public function dispatch(string $httpMethod, string $uri): array;
+    }
+
+    function simpleDispatcher(
+        (function(RouteCollector): void) $routeDefinitionCallback,
+        shape(
+          'routeParser' => ?classname<RouteParser>,
+          'dataGenerator' => ?classname<DataGenerator>,
+          'dispatcher' => ?classname<Dispatcher>,
+          'routeCollector' => ?classname<RouteCollector>,
+        ) $options = shape()): Dispatcher;
+
+    function cachedDispatcher(
+        (function(RouteCollector): void) $routeDefinitionCallback,
+        shape(
+          'routeParser' => ?classname<RouteParser>,
+          'dataGenerator' => ?classname<DataGenerator>,
+          'dispatcher' => ?classname<Dispatcher>,
+          'routeCollector' => ?classname<RouteCollector>,
+          'cacheDisabled' => ?bool,
+          'cacheFile' => ?string,
+        ) $options = shape()): Dispatcher;
+}
+
+namespace FastRoute\DataGenerator {
+    abstract class RegexBasedAbstract implements \FastRoute\DataGenerator {
+        protected abstract function getApproxChunkSize();
+        protected abstract function processChunk($regexToRoutesMap);
+
+        public function addRoute(string $httpMethod, array $routeData, mixed $handler): void;
+        public function getData(): array;
+    }
+
+    class CharCountBased extends RegexBasedAbstract {
+        protected function getApproxChunkSize(): int;
+        protected function processChunk(array<string, string> $regexToRoutesMap): array<string, mixed>;
+    }
+
+    class GroupCountBased extends RegexBasedAbstract {
+        protected function getApproxChunkSize(): int;
+        protected function processChunk(array<string, string> $regexToRoutesMap): array<string, mixed>;
+    }
+
+    class GroupPosBased extends RegexBasedAbstract {
+        protected function getApproxChunkSize(): int;
+        protected function processChunk(array<string, string> $regexToRoutesMap): array<string, mixed>;
+    }
+
+    class MarkBased extends RegexBasedAbstract {
+        protected function getApproxChunkSize(): int;
+        protected function processChunk(array<string, string> $regexToRoutesMap): array<string, mixed>;
+    }
+}
+
+namespace FastRoute\Dispatcher {
+    abstract class RegexBasedAbstract implements \FastRoute\Dispatcher {
+        protected abstract function dispatchVariableRoute(array<array> $routeData, string $uri): array;
+
+        public function dispatch(string $httpMethod, string $uri): array;
+    }
+
+    class GroupPosBased extends RegexBasedAbstract {
+        public function __construct(array $data);
+        protected function dispatchVariableRoute(array<array> $routeData, string $uri): array;
+    }
+
+    class GroupCountBased extends RegexBasedAbstract {
+        public function __construct(array $data);
+        protected function dispatchVariableRoute(array<array> $routeData, string $uri): array;
+    }
+
+    class CharCountBased extends RegexBasedAbstract {
+        public function __construct(array $data);
+        protected function dispatchVariableRoute(array<array> $routeData, string $uri): array;
+    }
+
+    class MarkBased extends RegexBasedAbstract {
+        public function __construct(array $data);
+        protected function dispatchVariableRoute(array<array> $routeData, string $uri): array;
+    }
+}
+
+namespace FastRoute\RouteParser {
+    class Std implements \FastRoute\RouteParser {
+        const string VARIABLE_REGEX = <<<'REGEX'
+\{
+    \s* ([a-zA-Z][a-zA-Z0-9_]*) \s*
+    (?:
+        : \s* ([^{}]*(?:\{(?-1)\}[^{}]*)*)
+    )?
+\}
+REGEX;
+        const string DEFAULT_DISPATCH_REGEX = '[^/]+';
+        public function parse(string $route): array<array>;
+    }
+}

vendor/nikic/fast-route/README.md

@@ -4,6 +4,17 @@ FastRoute - Fast request router for PHP
 This library provides a fast implementation of a regular expression based router. [Blog post explaining how the
 implementation works and why it is fast.][blog_post]
 
+Install
+-------
+
+To install with composer:
+
+```sh
+composer require nikic/fast-route
+```
+
+Requires PHP 5.4 or newer.
+
 Usage
 -----
 
@@ -12,15 +23,26 @@ Here's a basic usage example:
 ```php
 <?php
 
-require '/path/to/FastRoute/src/bootstrap.php';
+require '/path/to/vendor/autoload.php';
 
 $dispatcher = FastRoute\simpleDispatcher(function(FastRoute\RouteCollector $r) {
-    $r->addRoute('GET', '/user/{id:\d+}', 'handler1');
-    $r->addRoute('GET', '/user/{id:\d+}/{name}', 'handler2');
-    // Or alternatively
-    $r->addRoute('GET', '/user/{id:\d+}[/{name}]', 'common_handler');
+    $r->addRoute('GET', '/users', 'get_all_users_handler');
+    // {id} must be a number (\d+)
+    $r->addRoute('GET', '/user/{id:\d+}', 'get_user_handler');
+    // The /{title} suffix is optional
+    $r->addRoute('GET', '/articles/{id:\d+}[/{title}]', 'get_article_handler');
 });
 
+// Fetch method and URI from somewhere
+$httpMethod = $_SERVER['REQUEST_METHOD'];
+$uri = $_SERVER['REQUEST_URI'];
+
+// Strip query string (?foo=bar) and decode URI
+if (false !== $pos = strpos($uri, '?')) {
+    $uri = substr($uri, 0, $pos);
+}
+$uri = rawurldecode($uri);
+
 $routeInfo = $dispatcher->dispatch($httpMethod, $uri);
 switch ($routeInfo[0]) {
     case FastRoute\Dispatcher::NOT_FOUND:
@@ -40,25 +62,67 @@ switch ($routeInfo[0]) {
 
 ### Defining routes
 
-The routes are defined by calling the `FastRoute\simpleDispatcher` function, which accepts
+The routes are defined by calling the `FastRoute\simpleDispatcher()` function, which accepts
 a callable taking a `FastRoute\RouteCollector` instance. The routes are added by calling
-`addRoute()` on the collector instance.
+`addRoute()` on the collector instance:
 
-This method accepts the HTTP method the route must match, the route pattern and an associated
-handler. The handler does not necessarily have to be a callback (it could also be a controller
-class name or any other kind of data you wish to associate with the route).
+```php
+$r->addRoute($method, $routePattern, $handler);
+```
 
-By default a route pattern syntax is used where `{foo}` specified a placeholder with name `foo`
-and matching the string `[^/]+`. To adjust the pattern the placeholder matches, you can specify
-a custom pattern by writing `{bar:[0-9]+}`.
+The `$method` is an uppercase HTTP method string for which a certain route should match. It
+is possible to specify multiple valid methods using an array:
+
+```php
+// These two calls
+$r->addRoute('GET', '/test', 'handler');
+$r->addRoute('POST', '/test', 'handler');
+// Are equivalent to this one call
+$r->addRoute(['GET', 'POST'], '/test', 'handler');
+```
+
+By default the `$routePattern` uses a syntax where `{foo}` specifies a placeholder with name `foo`
+and matching the regex `[^/]+`. To adjust the pattern the placeholder matches, you can specify
+a custom pattern by writing `{bar:[0-9]+}`. Some examples:
+
+```php
+// Matches /user/42, but not /user/xyz
+$r->addRoute('GET', '/user/{id:\d+}', 'handler');
+
+// Matches /user/foobar, but not /user/foo/bar
+$r->addRoute('GET', '/user/{name}', 'handler');
+
+// Matches /user/foo/bar as well
+$r->addRoute('GET', '/user/{name:.+}', 'handler');
+```
+
+Custom patterns for route placeholders cannot use capturing groups. For example `{lang:(en|de)}`
+is not a valid placeholder, because `()` is a capturing group. Instead you can use either
+`{lang:en|de}` or `{lang:(?:en|de)}`.
 
 Furthermore parts of the route enclosed in `[...]` are considered optional, so that `/foo[bar]`
 will match both `/foo` and `/foobar`. Optional parts are only supported in a trailing position,
 not in the middle of a route.
 
-A custom pattern for a route placeholder must not use capturing groups. For example `{lang:(en|de)}`
-is not a valid placeholder, because `()` is a capturing group. Instead you can use either
-`{lang:en|de}` or `{lang:(?:en|de)}`.
+```php
+// This route
+$r->addRoute('GET', '/user/{id:\d+}[/{name}]', 'handler');
+// Is equivalent to these two routes
+$r->addRoute('GET', '/user/{id:\d+}', 'handler');
+$r->addRoute('GET', '/user/{id:\d+}/{name}', 'handler');
+
+// Multiple nested optional parts are possible as well
+$r->addRoute('GET', '/user[/{id:\d+}[/{name}]]', 'handler');
+
+// This route is NOT valid, because optional parts can only occur at the end
+$r->addRoute('GET', '/user[/{id:\d+}]/{name}', 'handler');
+```
+
+The `$handler` parameter does not necessarily have to be a callback, it could also be a controller
+class name or any other kind of data you wish to associate with the route. FastRoute only tells you
+which handler corresponds to your URI, how you interpret it is up to you.
+
+### Caching
 
 The reason `simpleDispatcher` accepts a callback for defining the routes is to allow seamless
 caching. By using `cachedDispatcher` instead of `simpleDispatcher` you can cache the generated
@@ -137,13 +201,13 @@ each route info is again an array of it's parts. The structure is best understoo
     [
         [
             '/user/',
-            ['name', '[^/]+'],
+            ['id', '\d+'],
         ],
         [
             '/user/',
-            ['name', '[^/]+'],
+            ['id', '\d+'],
             '/',
-            ['id', '[0-9]+'],
+            ['name', '[^/]+'],
         ],
     ]
 
@@ -189,7 +253,7 @@ To avoid forcing users to manually register HEAD routes for each resource we fal
 available GET route for a given resource. The PHP web SAPI transparently removes the entity body
 from HEAD responses so this behavior has no effect on the vast majority of users.
 
-However, implementors using FastRoute outside the web SAPI environment (e.g. a custom server) MUST
+However, implementers using FastRoute outside the web SAPI environment (e.g. a custom server) MUST
 NOT send entity bodies generated in response to HEAD requests. If you are a non-SAPI user this is
 *your responsibility*; FastRoute has no purview to prevent you from breaking HTTP in such cases.
 

vendor/nikic/fast-route/src/DataGenerator/RegexBasedAbstract.php

@@ -45,7 +45,7 @@ abstract class RegexBasedAbstract implements DataGenerator {
     }
 
     private function isStaticRoute($routeData) {
-        return count($routeData) == 1 && is_string($routeData[0]);
+        return count($routeData) === 1 && is_string($routeData[0]);
     }
 
     private function addStaticRoute($httpMethod, $routeData, $handler) {

vendor/nikic/fast-route/src/Dispatcher/RegexBasedAbstract.php

@@ -14,9 +14,6 @@ abstract class RegexBasedAbstract implements Dispatcher {
         if (isset($this->staticRouteMap[$httpMethod][$uri])) {
             $handler = $this->staticRouteMap[$httpMethod][$uri];
             return [self::FOUND, $handler, []];
-        } else if ($httpMethod === 'HEAD' && isset($this->staticRouteMap['GET'][$uri])) {
-            $handler = $this->staticRouteMap['GET'][$uri];
-            return [self::FOUND, $handler, []];
         }
 
         $varRouteData = $this->variableRouteData;
@@ -25,8 +22,29 @@ abstract class RegexBasedAbstract implements Dispatcher {
             if ($result[0] === self::FOUND) {
                 return $result;
             }
-        } else if ($httpMethod === 'HEAD' && isset($varRouteData['GET'])) {
-            $result = $this->dispatchVariableRoute($varRouteData['GET'], $uri);
+        }
+
+        // For HEAD requests, attempt fallback to GET
+        if ($httpMethod === 'HEAD') {
+            if (isset($this->staticRouteMap['GET'][$uri])) {
+                $handler = $this->staticRouteMap['GET'][$uri];
+                return [self::FOUND, $handler, []];
+            }
+            if (isset($varRouteData['GET'])) {
+                $result = $this->dispatchVariableRoute($varRouteData['GET'], $uri);
+                if ($result[0] === self::FOUND) {
+                    return $result;
+                }
+            }
+        }
+
+        // If nothing else matches, try fallback routes
+        if (isset($this->staticRouteMap['*'][$uri])) {
+            $handler = $this->staticRouteMap['*'][$uri];
+            return [self::FOUND, $handler, []];
+        }
+        if (isset($varRouteData['*'])) {
+            $result = $this->dispatchVariableRoute($varRouteData['*'], $uri);
             if ($result[0] === self::FOUND) {
                 return $result;
             }

vendor/nikic/fast-route/src/RouteCollector.php

@@ -34,6 +34,78 @@ class RouteCollector {
             }
         }
     }
+    
+    /**
+     * Adds a GET route to the collection
+     * 
+     * This is simply an alias of $this->addRoute('GET', $route, $handler)
+     *
+     * @param string $route
+     * @param mixed  $handler
+     */
+    public function get($route, $handler) {
+        $this->addRoute('GET', $route, $handler);
+    }
+    
+    /**
+     * Adds a POST route to the collection
+     * 
+     * This is simply an alias of $this->addRoute('POST', $route, $handler)
+     *
+     * @param string $route
+     * @param mixed  $handler
+     */
+    public function post($route, $handler) {
+        $this->addRoute('POST', $route, $handler);
+    }
+    
+    /**
+     * Adds a PUT route to the collection
+     * 
+     * This is simply an alias of $this->addRoute('PUT', $route, $handler)
+     *
+     * @param string $route
+     * @param mixed  $handler
+     */
+    public function put($route, $handler) {
+        $this->addRoute('PUT', $route, $handler);
+    }
+    
+    /**
+     * Adds a DELETE route to the collection
+     * 
+     * This is simply an alias of $this->addRoute('DELETE', $route, $handler)
+     *
+     * @param string $route
+     * @param mixed  $handler
+     */
+    public function delete($route, $handler) {
+        $this->addRoute('DELETE', $route, $handler);
+    }
+    
+    /**
+     * Adds a PATCH route to the collection
+     * 
+     * This is simply an alias of $this->addRoute('PATCH', $route, $handler)
+     *
+     * @param string $route
+     * @param mixed  $handler
+     */
+    public function patch($route, $handler) {
+        $this->addRoute('PATCH', $route, $handler);
+    }
+
+    /**
+     * Adds a HEAD route to the collection
+     *
+     * This is simply an alias of $this->addRoute('HEAD', $route, $handler)
+     *
+     * @param string $route
+     * @param mixed  $handler
+     */
+    public function head($route, $handler) {
+        $this->addRoute('HEAD', $route, $handler);
+    }
 
     /**
      * Returns the collected route data, as provided by the data generator.

vendor/nikic/fast-route/src/RouteParser/Std.php

@@ -13,7 +13,7 @@ use FastRoute\RouteParser;
 class Std implements RouteParser {
     const VARIABLE_REGEX = <<<'REGEX'
 \{
-    \s* ([a-zA-Z][a-zA-Z0-9_]*) \s*
+    \s* ([a-zA-Z_][a-zA-Z0-9_-]*) \s*
     (?:
         : \s* ([^{}]*(?:\{(?-1)\}[^{}]*)*)
     )?
@@ -28,13 +28,17 @@ REGEX;
         // Split on [ while skipping placeholders
         $segments = preg_split('~' . self::VARIABLE_REGEX . '(*SKIP)(*F) | \[~x', $routeWithoutClosingOptionals);
         if ($numOptionals !== count($segments) - 1) {
+            // If there are any ] in the middle of the route, throw a more specific error message
+            if (preg_match('~' . self::VARIABLE_REGEX . '(*SKIP)(*F) | \]~x', $routeWithoutClosingOptionals)) {
+                throw new BadRouteException("Optional segments can only occur at the end of a route");
+            }
             throw new BadRouteException("Number of opening '[' and closing ']' does not match");
         }
 
         $currentRoute = '';
         $routeDatas = [];
-        foreach ($segments as $segment) {
-            if ($segment === '') {
+        foreach ($segments as $n => $segment) {
+            if ($segment === '' && $n !== 0) {
                 throw new BadRouteException("Empty optional part");
             }
 

vendor/nikic/fast-route/src/functions.php

@@ -60,10 +60,12 @@ if (!function_exists('FastRoute\simpleDispatcher')) {
 
         /** @var RouteCollector $routeCollector */
         $dispatchData = $routeCollector->getData();
-        file_put_contents(
-            $options['cacheFile'],
-            '<?php return ' . var_export($dispatchData, true) . ';'
-        );
+        if (!$options['cacheDisabled']) {
+            file_put_contents(
+                $options['cacheFile'],
+                '<?php return ' . var_export($dispatchData, true) . ';'
+            );
+        }
 
         return new $options['dispatcher']($dispatchData);
     }

vendor/nikic/fast-route/test/Dispatcher/DispatcherTest.php

@@ -327,6 +327,72 @@ abstract class DispatcherTest extends \PHPUnit_Framework_TestCase {
 
         $cases[] = ['GET', '/user.json', $callback, 'handler1', ['entity' => 'user']];
 
+        // 16 ----
+
+        $callback = function(RouteCollector $r) {
+            $r->addRoute('GET', '', 'handler0');
+        };
+
+        $cases[] = ['GET', '', $callback, 'handler0', []];
+
+        // 17 ----
+
+        $callback = function(RouteCollector $r) {
+            $r->addRoute('HEAD', '/a/{foo}', 'handler0');
+            $r->addRoute('GET', '/b/{foo}', 'handler1');
+        };
+
+        $cases[] = ['HEAD', '/b/bar', $callback, 'handler1', ['foo' => 'bar']];
+
+        // 18 ----
+
+        $callback = function(RouteCollector $r) {
+            $r->addRoute('HEAD', '/a', 'handler0');
+            $r->addRoute('GET', '/b', 'handler1');
+        };
+
+        $cases[] = ['HEAD', '/b', $callback, 'handler1', []];
+
+        // 19 ----
+
+        $callback = function(RouteCollector $r) {
+            $r->addRoute('GET', '/foo', 'handler0');
+            $r->addRoute('HEAD', '/{bar}', 'handler1');
+        };
+
+        $cases[] = ['HEAD', '/foo', $callback, 'handler1', ['bar' => 'foo']];
+
+        // 20 ----
+
+        $callback = function(RouteCollector $r) {
+            $r->addRoute('*', '/user', 'handler0');
+            $r->addRoute('*', '/{user}', 'handler1');
+            $r->addRoute('GET', '/user', 'handler2');
+        };
+
+        $cases[] = ['GET', '/user', $callback, 'handler2', []];
+
+        // 21 ----
+
+        $callback = function(RouteCollector $r) {
+            $r->addRoute('*', '/user', 'handler0');
+            $r->addRoute('GET', '/user', 'handler1');
+        };
+
+        $cases[] = ['POST', '/user', $callback, 'handler0', []];
+
+        // 22 ----
+
+        $cases[] = ['HEAD', '/user', $callback, 'handler1', []];
+
+        // 23 ----
+
+        $callback = function(RouteCollector $r) {
+            $r->addRoute('GET', '/{bar}', 'handler0');
+            $r->addRoute('*', '/foo', 'handler1');
+        };
+
+        $cases[] = ['GET', '/foo', $callback, 'handler0', ['bar' => 'foo']];
 
         // x -------------------------------------------------------------------------------------->
 
@@ -430,6 +496,7 @@ abstract class DispatcherTest extends \PHPUnit_Framework_TestCase {
             $r->addRoute('GET', '/resource/123/456', 'handler0');
             $r->addRoute('POST', '/resource/123/456', 'handler1');
             $r->addRoute('PUT', '/resource/123/456', 'handler2');
+            $r->addRoute('*', '/', 'handler3');
         };
 
         $method = 'DELETE';

vendor/nikic/fast-route/test/HackTypechecker/HackTypecheckerTest.php

@@ -0,0 +1,39 @@
+<?php
+
+namespace FastRoute;
+
+class HackTypecheckerTest extends \PhpUnit_Framework_TestCase {
+    const SERVER_ALREADY_RUNNING_CODE = 77;
+    public function testTypechecks($recurse = true) {
+        if (!defined('HHVM_VERSION')) {
+            $this->markTestSkipped("HHVM only");
+        }
+        if (!version_compare(HHVM_VERSION, '3.9.0', '>=')) {
+          $this->markTestSkipped('classname<T> requires HHVM 3.9+');
+        }
+
+        // The typechecker recurses the whole tree, so it makes sure
+        // that everything in fixtures/ is valid when this runs.
+
+        $output = array();
+        $exit_code = null;
+        exec(
+            'hh_server --check '.escapeshellarg(__DIR__.'/../../').' 2>&1',
+            $output,
+            $exit_code
+        );
+        if ($exit_code === self::SERVER_ALREADY_RUNNING_CODE) {
+            $this->assertTrue(
+              $recurse,
+              "Typechecker still running after running hh_client stop"
+            );
+            // Server already running - 3.10 => 3.11 regression:
+            // https://github.com/facebook/hhvm/issues/6646
+            exec('hh_client stop 2>/dev/null');
+            $this->testTypechecks(/* recurse = */ false);
+            return;
+
+        }
+        $this->assertSame(0, $exit_code, implode("\n", $output));
+    }
+}

vendor/nikic/fast-route/test/HackTypechecker/fixtures/all_options.php

@@ -0,0 +1,29 @@
+<?hh
+
+namespace FastRoute\TestFixtures;
+
+function all_options_simple(): \FastRoute\Dispatcher {
+    return \FastRoute\simpleDispatcher(
+      $collector ==> {},
+      shape(
+        'routeParser' => \FastRoute\RouteParser\Std::class,
+        'dataGenerator' => \FastRoute\DataGenerator\GroupCountBased::class,
+        'dispatcher' => \FastRoute\Dispatcher\GroupCountBased::class,
+        'routeCollector' => \FastRoute\RouteCollector::class,
+      ),
+    );
+}
+
+function all_options_cached(): \FastRoute\Dispatcher {
+    return \FastRoute\cachedDispatcher(
+      $collector ==> {},
+      shape(
+        'routeParser' => \FastRoute\RouteParser\Std::class,
+        'dataGenerator' => \FastRoute\DataGenerator\GroupCountBased::class,
+        'dispatcher' => \FastRoute\Dispatcher\GroupCountBased::class,
+        'routeCollector' => \FastRoute\RouteCollector::class,
+        'cacheFile' => '/dev/null',
+        'cacheDisabled' => false,
+      ),
+    );
+}

vendor/nikic/fast-route/test/HackTypechecker/fixtures/empty_options.php

@@ -0,0 +1,11 @@
+<?hh
+
+namespace FastRoute\TestFixtures;
+
+function empty_options_simple(): \FastRoute\Dispatcher {
+    return \FastRoute\simpleDispatcher($collector ==> {}, shape());
+}
+
+function empty_options_cached(): \FastRoute\Dispatcher {
+    return \FastRoute\cachedDispatcher($collector ==> {}, shape());
+}

vendor/nikic/fast-route/test/HackTypechecker/fixtures/no_options.php

@@ -0,0 +1,11 @@
+<?hh
+
+namespace FastRoute\TestFixtures;
+
+function no_options_simple(): \FastRoute\Dispatcher {
+    return \FastRoute\simpleDispatcher($collector ==> {});
+}
+
+function no_options_cached(): \FastRoute\Dispatcher {
+    return \FastRoute\cachedDispatcher($collector ==> {});
+}

vendor/nikic/fast-route/test/RouteCollectorTest.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace FastRoute;
+
+class RouteCollectorTest extends \PHPUnit_Framework_TestCase {
+    public function testShortcuts() {
+        $r = new DummyRouteCollector();
+
+        $r->delete('/delete', 'delete');
+        $r->get('/get', 'get');
+        $r->head('/head', 'head');
+        $r->patch('/patch', 'patch');
+        $r->post('/post', 'post');
+        $r->put('/put', 'put');
+
+        $expected = [
+            ['DELETE', '/delete', 'delete'],
+            ['GET', '/get', 'get'],
+            ['HEAD', '/head', 'head'],
+            ['PATCH', '/patch', 'patch'],
+            ['POST', '/post', 'post'],
+            ['PUT', '/put', 'put'],
+        ];
+
+        $this->assertSame($expected, $r->routes);
+    }
+}
+
+class DummyRouteCollector extends RouteCollector {
+    public $routes = [];
+    public function __construct() {}
+    public function addRoute($method, $route, $handler) {
+        $this->routes[] = [$method, $route, $handler];
+    }
+}

vendor/nikic/fast-route/test/RouteParser/StdTest.php

@@ -84,6 +84,31 @@ class StdTest extends \PhpUnit_Framework_TestCase {
                     ['/test/', ['name', '[^/]+'], '/', ['id', '[0-9]+']],
                 ]
             ],
+            [
+                '',
+                [
+                    [''],
+                ]
+            ],
+            [
+                '[test]',
+                [
+                    [''],
+                    ['test'],
+                ]
+            ],
+            [
+                '/{foo-bar}',
+                [
+                    ['/', ['foo-bar', '[^/]+']]
+                ]
+            ],
+            [
+                '/{_foo:.*}',
+                [
+                    ['/', ['_foo', '.*']]
+                ]
+            ],
         ];
     }
 
@@ -109,6 +134,14 @@ class StdTest extends \PhpUnit_Framework_TestCase {
                 '/test[[opt]]',
                 "Empty optional part"
             ],
+            [
+                '[[test]]',
+                "Empty optional part"
+            ],
+            [
+                '/test[/opt]/required',
+                "Optional segments can only occur at the end of a route"
+            ],
         ];
     }
 }