├── LICENSE
├── README.md
├── composer.json
└── src
    ├── BadRouteException.php
    ├── Cache.php
    ├── Cache
        ├── FileCache.php
        └── Psr16Cache.php
    ├── ConfigureRoutes.php
    ├── DataGenerator.php
    ├── DataGenerator
        ├── CharCountBased.php
        ├── GroupCountBased.php
        ├── GroupPosBased.php
        ├── MarkBased.php
        └── RegexBasedAbstract.php
    ├── Dispatcher.php
    ├── Dispatcher
        ├── CharCountBased.php
        ├── GroupCountBased.php
        ├── GroupPosBased.php
        ├── MarkBased.php
        ├── RegexBasedAbstract.php
        └── Result
        │   ├── Matched.php
        │   ├── MethodNotAllowed.php
        │   └── NotMatched.php
    ├── Exception.php
    ├── FastRoute.php
    ├── GenerateUri.php
    ├── GenerateUri
        ├── FromProcessedConfiguration.php
        └── UriCouldNotBeGenerated.php
    ├── Route.php
    ├── RouteCollector.php
    ├── RouteParser.php
    ├── RouteParser
        └── Std.php
    └── functions.php


/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2013 by Nikita Popov.
 2 | 
 3 | Some rights reserved.
 4 | 
 5 | Redistribution and use in source and binary forms, with or without
 6 | modification, are permitted provided that the following conditions are
 7 | met:
 8 | 
 9 |     * Redistributions of source code must retain the above copyright
10 |       notice, this list of conditions and the following disclaimer.
11 | 
12 |     * Redistributions in binary form must reproduce the above
13 |       copyright notice, this list of conditions and the following
14 |       disclaimer in the documentation and/or other materials provided
15 |       with the distribution.
16 | 
17 |     * The names of the contributors may not be used to endorse or
18 |       promote products derived from this software without specific
19 |       prior written permission.
20 | 
21 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25 | OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27 | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | FastRoute - Fast request router for PHP
  2 | =======================================
  3 | 
  4 | [![Build Status](https://img.shields.io/github/actions/workflow/status/nikic/FastRoute/phpunit.yml?branch=master&style=flat-square)](https://github.com/nikic/FastRoute/actions?query=workflow%3A%22PHPUnit%20Tests%22+branch%3Amaster)
  5 | 
  6 | This library provides a fast implementation of a regular expression based router. [Blog post explaining how the
  7 | implementation works and why it is fast.][blog_post]
  8 | 
  9 | Install
 10 | -------
 11 | 
 12 | To install with composer:
 13 | 
 14 | ```sh
 15 | composer require nikic/fast-route
 16 | ```
 17 | 
 18 | Requires PHP 8.1 or newer.
 19 | 
 20 | Usage
 21 | -----
 22 | 
 23 | Here's a basic usage example:
 24 | 
 25 | ```php
 26 | <?php
 27 | 
 28 | require '/path/to/vendor/autoload.php';
 29 | 
 30 | $dispatcher = FastRoute\simpleDispatcher(function(FastRoute\ConfigureRoutes $r) {
 31 |     $r->addRoute('GET', '/users', 'get_all_users_handler');
 32 |     // {id} must be a number (\d+)
 33 |     $r->addRoute('GET', '/user/{id:\d+}', 'get_user_handler');
 34 |     // The /{title} suffix is optional
 35 |     $r->addRoute('GET', '/articles/{id:\d+}[/{title}]', 'get_article_handler');
 36 | });
 37 | 
 38 | // Fetch method and URI from somewhere
 39 | $httpMethod = $_SERVER['REQUEST_METHOD'];
 40 | $uri = $_SERVER['REQUEST_URI'];
 41 | 
 42 | // Strip query string (?foo=bar) and decode URI
 43 | if (false !== $pos = strpos($uri, '?')) {
 44 |     $uri = substr($uri, 0, $pos);
 45 | }
 46 | $uri = rawurldecode($uri);
 47 | 
 48 | $routeInfo = $dispatcher->dispatch($httpMethod, $uri);
 49 | switch ($routeInfo[0]) {
 50 |     case FastRoute\Dispatcher::NOT_FOUND:
 51 |         // ... 404 Not Found
 52 |         break;
 53 |     case FastRoute\Dispatcher::METHOD_NOT_ALLOWED:
 54 |         $allowedMethods = $routeInfo[1];
 55 |         // ... 405 Method Not Allowed
 56 |         break;
 57 |     case FastRoute\Dispatcher::FOUND:
 58 |         $handler = $routeInfo[1];
 59 |         $vars = $routeInfo[2];
 60 |         // ... call $handler with $vars
 61 |         break;
 62 | }
 63 | ```
 64 | 
 65 | ### Defining routes
 66 | 
 67 | The routes are defined by calling the `FastRoute\simpleDispatcher()` function, which accepts
 68 | a callable taking a `FastRoute\ConfigureRoutes` instance. The routes are added by calling
 69 | `addRoute()` on the collector instance:
 70 | 
 71 | ```php
 72 | $r->addRoute($method, $routePattern, $handler);
 73 | ```
 74 | 
 75 | The `$method` is an uppercase HTTP method string for which a certain route should match. It
 76 | is possible to specify multiple valid methods using an array:
 77 | 
 78 | ```php
 79 | // These two calls
 80 | $r->addRoute('GET', '/test', 'handler');
 81 | $r->addRoute('POST', '/test', 'handler');
 82 | // Are equivalent to this one call
 83 | $r->addRoute(['GET', 'POST'], '/test', 'handler');
 84 | ```
 85 | 
 86 | By default, the `$routePattern` uses a syntax where `{foo}` specifies a placeholder with name `foo`
 87 | and matching the regex `[^/]+`. To adjust the pattern the placeholder matches, you can specify
 88 | a custom pattern by writing `{bar:[0-9]+}`. Some examples:
 89 | 
 90 | ```php
 91 | // Matches /user/42, but not /user/xyz
 92 | $r->addRoute('GET', '/user/{id:\d+}', 'handler');
 93 | 
 94 | // Matches /user/foobar, but not /user/foo/bar
 95 | $r->addRoute('GET', '/user/{name}', 'handler');
 96 | 
 97 | // Matches /user/foo/bar as well
 98 | $r->addRoute('GET', '/user/{name:.+}', 'handler');
 99 | ```
100 | 
101 | Custom patterns for route placeholders cannot use capturing groups. For example `{lang:(en|de)}`
102 | is not a valid placeholder, because `()` is a capturing group. Instead you can use either
103 | `{lang:en|de}` or `{lang:(?:en|de)}`.
104 | 
105 | Furthermore, parts of the route enclosed in `[...]` are considered optional, so that `/foo[bar]`
106 | will match both `/foo` and `/foobar`. Optional parts are only supported in a trailing position,
107 | not in the middle of a route.
108 | 
109 | ```php
110 | // This route
111 | $r->addRoute('GET', '/user/{id:\d+}[/{name}]', 'handler');
112 | // Is equivalent to these two routes
113 | $r->addRoute('GET', '/user/{id:\d+}', 'handler');
114 | $r->addRoute('GET', '/user/{id:\d+}/{name}', 'handler');
115 | 
116 | // Multiple nested optional parts are possible as well
117 | $r->addRoute('GET', '/user[/{id:\d+}[/{name}]]', 'handler');
118 | 
119 | // This route is NOT valid, because optional parts can only occur at the end
120 | $r->addRoute('GET', '/user[/{id:\d+}]/{name}', 'handler');
121 | ```
122 | 
123 | The `$handler` parameter does not necessarily have to be a callback, it could also be a controller
124 | class name or any other kind of data you wish to associate with the route. FastRoute only tells you
125 | which handler corresponds to your URI, how you interpret it is up to you.
126 | 
127 | #### Shortcut methods for common request methods
128 | 
129 | For the `GET`, `POST`, `PUT`, `PATCH`, `DELETE` and `HEAD` request methods shortcut methods are available. For example:
130 | 
131 | ```php
132 | $r->get('/get-route', 'get_handler');
133 | $r->post('/post-route', 'post_handler');
134 | ```
135 | 
136 | Is equivalent to:
137 | 
138 | ```php
139 | $r->addRoute('GET', '/get-route', 'get_handler');
140 | $r->addRoute('POST', '/post-route', 'post_handler');
141 | ```
142 | 
143 | #### Route Groups
144 | 
145 | Additionally, you can specify routes inside a group. All routes defined inside a group will have a common prefix.
146 | 
147 | For example, defining your routes as:
148 | 
149 | ```php
150 | $r->addGroup('/admin', function (FastRoute\ConfigureRoutes $r) {
151 |     $r->addRoute('GET', '/do-something', 'handler');
152 |     $r->addRoute('GET', '/do-another-thing', 'handler');
153 |     $r->addRoute('GET', '/do-something-else', 'handler');
154 | });
155 | ```
156 | 
157 | Will have the same result as:
158 | 
159 |  ```php
160 | $r->addRoute('GET', '/admin/do-something', 'handler');
161 | $r->addRoute('GET', '/admin/do-another-thing', 'handler');
162 | $r->addRoute('GET', '/admin/do-something-else', 'handler');
163 |  ```
164 | 
165 | Nested groups are also supported, in which case the prefixes of all the nested groups are combined.
166 | 
167 | ### Caching
168 | 
169 | The reason `simpleDispatcher` accepts a callback for defining the routes is to allow seamless
170 | caching. By using `cachedDispatcher` instead of `simpleDispatcher` you can cache the generated
171 | routing data and construct the dispatcher from the cached information:
172 | 
173 | ```php
174 | <?php
175 | 
176 | $dispatcher = FastRoute\cachedDispatcher(function(FastRoute\ConfigureRoutes $r) {
177 |     $r->addRoute('GET', '/user/{name}/{id:[0-9]+}', 'handler0');
178 |     $r->addRoute('GET', '/user/{id:[0-9]+}', 'handler1');
179 |     $r->addRoute('GET', '/user/{name}', 'handler2');
180 | }, [
181 |     'cacheKey' => __DIR__ . '/route.cache', /* required */
182 |     // 'cacheFile' => __DIR__ . '/route.cache', /* will still work for v1 compatibility */
183 |     'cacheDisabled' => IS_DEBUG_ENABLED,     /* optional, enabled by default */
184 |     'cacheDriver' => FastRoute\Cache\FileCache::class, /* optional, class name or instance of the cache driver - defaults to file cache */
185 | ]);
186 | ```
187 | 
188 | The second parameter to the function is an options array, which can be used to specify the cache
189 | key (e.g. file location when using files for caching), caching driver, among other things.
190 | 
191 | ### Dispatching a URI
192 | 
193 | A URI is dispatched by calling the `dispatch()` method of the created dispatcher. This method
194 | accepts the HTTP method and a URI. Getting those two bits of information (and normalizing them
195 | appropriately) is your job - this library is not bound to the PHP web SAPIs.
196 | 
197 | The `dispatch()` method returns an array whose first element contains a status code. It is one
198 | of `Dispatcher::NOT_FOUND`, `Dispatcher::METHOD_NOT_ALLOWED` and `Dispatcher::FOUND`. For the
199 | method not allowed status the second array element contains a list of HTTP methods allowed for
200 | the supplied URI. For example:
201 | 
202 |     [FastRoute\Dispatcher::METHOD_NOT_ALLOWED, ['GET', 'POST']]
203 | 
204 | > **NOTE:** The HTTP specification requires that a `405 Method Not Allowed` response include the
205 | `Allow:` header to detail available methods for the requested resource. Applications using FastRoute
206 | should use the second array element to add this header when relaying a 405 response.
207 | 
208 | For the found status the second array element is the handler that was associated with the route
209 | and the third array element is a dictionary of placeholder names to their values. For example:
210 | 
211 |     /* Routing against GET /user/nikic/42 */
212 | 
213 |     [FastRoute\Dispatcher::FOUND, 'handler0', ['name' => 'nikic', 'id' => '42']]
214 | 
215 | ### Overriding the route parser and dispatcher
216 | 
217 | The routing process makes use of three components: A route parser, a data generator and a
218 | dispatcher. The three components adhere to the following interfaces:
219 | 
220 | ```php
221 | <?php
222 | 
223 | namespace FastRoute;
224 | 
225 | interface RouteParser {
226 |     public function parse($route);
227 | }
228 | 
229 | interface DataGenerator {
230 |     public function addRoute($httpMethod, $routeData, $handler);
231 |     public function getData();
232 | }
233 | 
234 | interface Dispatcher {
235 |     const NOT_FOUND = 0, FOUND = 1, METHOD_NOT_ALLOWED = 2;
236 | 
237 |     public function dispatch($httpMethod, $uri);
238 | }
239 | ```
240 | 
241 | The route parser takes a route pattern string and converts it into an array of route infos, where
242 | each route info is again an array of its parts. The structure is best understood using an example:
243 | 
244 |     /* The route /user/{id:\d+}[/{name}] converts to the following array: */
245 |     [
246 |         [
247 |             '/user/',
248 |             ['id', '\d+'],
249 |         ],
250 |         [
251 |             '/user/',
252 |             ['id', '\d+'],
253 |             '/',
254 |             ['name', '[^/]+'],
255 |         ],
256 |     ]
257 | 
258 | This array can then be passed to the `addRoute()` method of a data generator. After all routes have
259 | been added the `getData()` of the generator is invoked, which returns all the routing data required
260 | by the dispatcher. The format of this data is not further specified - it is tightly coupled to
261 | the corresponding dispatcher.
262 | 
263 | The dispatcher accepts the routing data via a constructor and provides a `dispatch()` method, which
264 | you're already familiar with.
265 | 
266 | The route parser can be overwritten individually (to make use of some different pattern syntax),
267 | however the data generator and dispatcher should always be changed as a pair, as the output from
268 | the former is tightly coupled to the input of the latter. The reason the generator and the
269 | dispatcher are separate is that only the latter is needed when using caching (as the output of
270 | the former is what is being cached.)
271 | 
272 | When using the `simpleDispatcher` / `cachedDispatcher` functions from above the override happens
273 | through the options array:
274 | 
275 | ```php
276 | <?php
277 | 
278 | $dispatcher = FastRoute\simpleDispatcher(function(FastRoute\ConfigureRoutes $r) {
279 |     /* ... */
280 | }, [
281 |     'routeParser' => 'FastRoute\\RouteParser\\Std',
282 |     'dataGenerator' => 'FastRoute\\DataGenerator\\MarkBased',
283 |     'dispatcher' => 'FastRoute\\Dispatcher\\MarkBased',
284 | ]);
285 | ```
286 | 
287 | The above options array corresponds to the defaults. By replacing `MarkBased` with
288 | `GroupCountBased` you could switch to a different dispatching strategy.
289 | 
290 | ### A Note on HEAD Requests
291 | 
292 | The HTTP spec requires servers to [support both GET and HEAD methods][2616-511]:
293 | 
294 | > The methods GET and HEAD MUST be supported by all general-purpose servers
295 | 
296 | To avoid forcing users to manually register HEAD routes for each resource we fallback to matching an
297 | available GET route for a given resource. The PHP web SAPI transparently removes the entity body
298 | from HEAD responses so this behavior has no effect on the vast majority of users.
299 | 
300 | However, implementers using FastRoute outside the web SAPI environment (e.g. a custom server) MUST
301 | NOT send entity bodies generated in response to HEAD requests. If you are a non-SAPI user this is
302 | *your responsibility*; FastRoute has no purview to prevent you from breaking HTTP in such cases.
303 | 
304 | Finally, note that applications MAY always specify their own HEAD method route for a given
305 | resource to bypass this behavior entirely.
306 | 
307 | ### Credits
308 | 
309 | This library is based on a router that [Levi Morrison][levi] implemented for the Aerys server.
310 | 
311 | A large number of tests, as well as HTTP compliance considerations, were provided by [Daniel Lowrey][rdlowrey].
312 | 
313 | 
314 | [2616-511]: http://www.w3.org/Protocols/rfc2616/rfc2616-sec5.html#sec5.1.1 "RFC 2616 Section 5.1.1"
315 | [blog_post]: http://nikic.github.io/2014/02/18/Fast-request-routing-using-regular-expressions.html
316 | [levi]: https://github.com/morrisonlevi
317 | [rdlowrey]: https://github.com/rdlowrey
318 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "nikic/fast-route",
 3 |     "description": "Fast request router for PHP",
 4 |     "license": "BSD-3-Clause",
 5 |     "keywords": [
 6 |         "routing",
 7 |         "router"
 8 |     ],
 9 |     "authors": [
10 |         {
11 |             "name": "Nikita Popov",
12 |             "email": "nikic@php.net"
13 |         }
14 |     ],
15 |     "require": {
16 |         "php": ">=8.1.0",
17 |         "psr/simple-cache": "^2.0 || ^3.0"
18 |     },
19 |     "require-dev": {
20 |         "lcobucci/coding-standard": "^11.0",
21 |         "phpbench/phpbench": "^1.2",
22 |         "phpstan/extension-installer": "^1.1",
23 |         "phpstan/phpstan": "^1.10",
24 |         "phpstan/phpstan-deprecation-rules": "^1.1",
25 |         "phpstan/phpstan-phpunit": "^1.3",
26 |         "phpstan/phpstan-strict-rules": "^1.5",
27 |         "phpunit/phpunit": "^10.3"
28 |     },
29 |     "autoload": {
30 |         "psr-4": {
31 |             "FastRoute\\": "src/"
32 |         },
33 |         "files": [
34 |             "src/functions.php"
35 |         ]
36 |     },
37 |     "autoload-dev": {
38 |         "psr-4": {
39 |             "FastRoute\\Benchmark\\": "benchmark/",
40 |             "FastRoute\\Test\\": "test/"
41 |         }
42 |     },
43 |     "config": {
44 |         "allow-plugins": {
45 |             "dealerdirect/phpcodesniffer-composer-installer": true,
46 |             "phpstan/extension-installer": true
47 |         },
48 |         "preferred-install": "dist",
49 |         "sort-packages": true
50 |     },
51 |     "extra": {
52 |         "branch-alias": {
53 |             "dev-master": "2.0-dev"
54 |         }
55 |     }
56 | }
57 | 


--------------------------------------------------------------------------------
/src/BadRouteException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace FastRoute;
 5 | 
 6 | use LogicException;
 7 | 
 8 | use function sprintf;
 9 | use function var_export;
10 | 
11 | /** @final */
12 | class BadRouteException extends LogicException implements Exception
13 | {
14 |     public static function alreadyRegistered(string $route, string $method): self
15 |     {
16 |         return new self(sprintf('Cannot register two routes matching "%s" for method "%s"', $route, $method));
17 |     }
18 | 
19 |     public static function namedRouteAlreadyDefined(string $name): self
20 |     {
21 |         return new self(sprintf('Cannot register two routes under the name "%s"', $name));
22 |     }
23 | 
24 |     public static function invalidRouteName(mixed $name): self
25 |     {
26 |         return new self(sprintf('Route name must be a non-empty string, "%s" given', var_export($name, true)));
27 |     }
28 | 
29 |     public static function shadowedByVariableRoute(string $route, string $shadowedRegex, string $method): self
30 |     {
31 |         return new self(
32 |             sprintf(
33 |                 'Static route "%s" is shadowed by previously defined variable route "%s" for method "%s"',
34 |                 $route,
35 |                 $shadowedRegex,
36 |                 $method,
37 |             ),
38 |         );
39 |     }
40 | 
41 |     public static function placeholderAlreadyDefined(string $name): self
42 |     {
43 |         return new self(sprintf('Cannot use the same placeholder "%s" twice', $name));
44 |     }
45 | 
46 |     public static function variableWithCaptureGroup(string $regexPart, string $name): self
47 |     {
48 |         return new self(sprintf('Regex "%s" for parameter "%s" contains a capturing group', $regexPart, $name));
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/src/Cache.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace FastRoute;
 5 | 
 6 | /** @phpstan-import-type ProcessedData from ConfigureRoutes */
 7 | interface Cache
 8 | {
 9 |     /**
10 |      * @param callable():ProcessedData $loader
11 |      *
12 |      * @return ProcessedData
13 |      */
14 |     public function get(string $key, callable $loader): array;
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Cache/FileCache.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | declare(strict_types=1);
  3 | 
  4 | namespace FastRoute\Cache;
  5 | 
  6 | use Closure;
  7 | use FastRoute\Cache;
  8 | use FastRoute\ConfigureRoutes;
  9 | use RuntimeException;
 10 | 
 11 | use function chmod;
 12 | use function dirname;
 13 | use function file_put_contents;
 14 | use function is_array;
 15 | use function is_dir;
 16 | use function is_writable;
 17 | use function mkdir;
 18 | use function rename;
 19 | use function restore_error_handler;
 20 | use function set_error_handler;
 21 | use function unlink;
 22 | use function var_export;
 23 | 
 24 | use const LOCK_EX;
 25 | 
 26 | /** @phpstan-import-type ProcessedData from ConfigureRoutes */
 27 | final class FileCache implements Cache
 28 | {
 29 |     private const DIRECTORY_PERMISSIONS = 0775;
 30 |     private const FILE_PERMISSIONS = 0664;
 31 | 
 32 |     /**
 33 |      * This is cached in a local static variable to avoid instantiating a closure each time we need an empty handler
 34 |      */
 35 |     private static Closure $emptyErrorHandler;
 36 | 
 37 |     public function __construct()
 38 |     {
 39 |         self::$emptyErrorHandler ??= static function (): void {
 40 |         };
 41 |     }
 42 | 
 43 |     /** @inheritdoc */
 44 |     public function get(string $key, callable $loader): array
 45 |     {
 46 |         $result = self::readFileContents($key);
 47 | 
 48 |         if ($result !== null) {
 49 |             return $result;
 50 |         }
 51 | 
 52 |         $data = $loader();
 53 |         self::writeToFile($key, '<?php return ' . var_export($data, true) . ';');
 54 | 
 55 |         return $data;
 56 |     }
 57 | 
 58 |     /** @return ProcessedData|null */
 59 |     private static function readFileContents(string $path): ?array
 60 |     {
 61 |         // error suppression is faster than calling `file_exists()` + `is_file()` + `is_readable()`, especially because there's no need to error here
 62 |         set_error_handler(self::$emptyErrorHandler);
 63 |         $value = include $path;
 64 |         restore_error_handler();
 65 | 
 66 |         if (! is_array($value)) {
 67 |             return null;
 68 |         }
 69 | 
 70 |         // @phpstan-ignore-next-line because we won´t be able to validate the array shape in a performant way
 71 |         return $value;
 72 |     }
 73 | 
 74 |     private static function writeToFile(string $path, string $content): void
 75 |     {
 76 |         $directory = dirname($path);
 77 | 
 78 |         if (! self::createDirectoryIfNeeded($directory) || ! is_writable($directory)) {
 79 |             throw new RuntimeException('The cache directory is not writable "' . $directory . '"');
 80 |         }
 81 | 
 82 |         set_error_handler(self::$emptyErrorHandler);
 83 | 
 84 |         $tmpFile = $path . '.tmp';
 85 | 
 86 |         if (file_put_contents($tmpFile, $content, LOCK_EX) === false) {
 87 |             restore_error_handler();
 88 | 
 89 |             return;
 90 |         }
 91 | 
 92 |         chmod($tmpFile, self::FILE_PERMISSIONS);
 93 | 
 94 |         if (! rename($tmpFile, $path)) {
 95 |             unlink($tmpFile);
 96 |         }
 97 | 
 98 |         restore_error_handler();
 99 |     }
100 | 
101 |     private static function createDirectoryIfNeeded(string $directory): bool
102 |     {
103 |         if (is_dir($directory)) {
104 |             return true;
105 |         }
106 | 
107 |         set_error_handler(self::$emptyErrorHandler);
108 |         $created = mkdir($directory, self::DIRECTORY_PERMISSIONS, true);
109 |         restore_error_handler();
110 | 
111 |         return $created !== false || is_dir($directory);
112 |     }
113 | }
114 | 


--------------------------------------------------------------------------------
/src/Cache/Psr16Cache.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace FastRoute\Cache;
 5 | 
 6 | use FastRoute\Cache;
 7 | use Psr\SimpleCache\CacheInterface;
 8 | 
 9 | use function is_array;
10 | 
11 | final class Psr16Cache implements Cache
12 | {
13 |     public function __construct(private readonly CacheInterface $cache)
14 |     {
15 |     }
16 | 
17 |     /** @inheritDoc */
18 |     public function get(string $key, callable $loader): array
19 |     {
20 |         $result = $this->cache->get($key);
21 | 
22 |         if (is_array($result)) {
23 |             // @phpstan-ignore-next-line because we won´t be able to validate the array shape in a performant way
24 |             return $result;
25 |         }
26 | 
27 |         $data = $loader();
28 |         $this->cache->set($key, $data);
29 | 
30 |         return $data;
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/ConfigureRoutes.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | declare(strict_types=1);
  3 | 
  4 | namespace FastRoute;
  5 | 
  6 | /**
  7 |  * @phpstan-import-type StaticRoutes from DataGenerator
  8 |  * @phpstan-import-type DynamicRoutes from DataGenerator
  9 |  * @phpstan-import-type ExtraParameters from DataGenerator
 10 |  * @phpstan-import-type RoutesForUriGeneration from GenerateUri
 11 |  * @phpstan-type ProcessedData array{StaticRoutes, DynamicRoutes, RoutesForUriGeneration}
 12 |  */
 13 | interface ConfigureRoutes
 14 | {
 15 |     public const ROUTE_NAME = '_name';
 16 |     public const ROUTE_REGEX = '_route';
 17 | 
 18 |     /**
 19 |      * Registers a new route.
 20 |      *
 21 |      * The syntax used in the $route string depends on the used route parser.
 22 |      *
 23 |      * @param string|string[] $httpMethod
 24 |      * @param ExtraParameters $extraParameters
 25 |      */
 26 |     public function addRoute(string|array $httpMethod, string $route, mixed $handler, array $extraParameters = []): void;
 27 | 
 28 |     /**
 29 |      * Create a route group with a common prefix.
 30 |      *
 31 |      * All routes created by the passed callback will have the given group prefix prepended.
 32 |      */
 33 |     public function addGroup(string $prefix, callable $callback): void;
 34 | 
 35 |     /**
 36 |      * Adds a fallback route to the collection
 37 |      *
 38 |      * This is simply an alias of $this->addRoute('*', $route, $handler)
 39 |      *
 40 |      * @param ExtraParameters $extraParameters
 41 |      */
 42 |     public function any(string $route, mixed $handler, array $extraParameters = []): void;
 43 | 
 44 |     /**
 45 |      * Adds a GET route to the collection
 46 |      *
 47 |      * This is simply an alias of $this->addRoute('GET', $route, $handler)
 48 |      *
 49 |      * @param ExtraParameters $extraParameters
 50 |      */
 51 |     public function get(string $route, mixed $handler, array $extraParameters = []): void;
 52 | 
 53 |     /**
 54 |      * Adds a POST route to the collection
 55 |      *
 56 |      * This is simply an alias of $this->addRoute('POST', $route, $handler)
 57 |      *
 58 |      * @param ExtraParameters $extraParameters
 59 |      */
 60 |     public function post(string $route, mixed $handler, array $extraParameters = []): void;
 61 | 
 62 |     /**
 63 |      * Adds a PUT route to the collection
 64 |      *
 65 |      * This is simply an alias of $this->addRoute('PUT', $route, $handler)
 66 |      *
 67 |      * @param ExtraParameters $extraParameters
 68 |      */
 69 |     public function put(string $route, mixed $handler, array $extraParameters = []): void;
 70 | 
 71 |     /**
 72 |      * Adds a DELETE route to the collection
 73 |      *
 74 |      * This is simply an alias of $this->addRoute('DELETE', $route, $handler)
 75 |      *
 76 |      * @param ExtraParameters $extraParameters
 77 |      */
 78 |     public function delete(string $route, mixed $handler, array $extraParameters = []): void;
 79 | 
 80 |     /**
 81 |      * Adds a PATCH route to the collection
 82 |      *
 83 |      * This is simply an alias of $this->addRoute('PATCH', $route, $handler)
 84 |      *
 85 |      * @param ExtraParameters $extraParameters
 86 |      */
 87 |     public function patch(string $route, mixed $handler, array $extraParameters = []): void;
 88 | 
 89 |     /**
 90 |      * Adds a HEAD route to the collection
 91 |      *
 92 |      * This is simply an alias of $this->addRoute('HEAD', $route, $handler)
 93 |      *
 94 |      * @param ExtraParameters $extraParameters
 95 |      */
 96 |     public function head(string $route, mixed $handler, array $extraParameters = []): void;
 97 | 
 98 |     /**
 99 |      * Adds an OPTIONS route to the collection
100 |      *
101 |      * This is simply an alias of $this->addRoute('OPTIONS', $route, $handler)
102 |      *
103 |      * @param ExtraParameters $extraParameters
104 |      */
105 |     public function options(string $route, mixed $handler, array $extraParameters = []): void;
106 | 
107 |     /**
108 |      * Returns the processed aggregated route data.
109 |      *
110 |      * @return ProcessedData
111 |      */
112 |     public function processedRoutes(): array;
113 | }
114 | 


--------------------------------------------------------------------------------
/src/DataGenerator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace FastRoute;
 5 | 
 6 | /**
 7 |  * @phpstan-import-type ParsedRoute from RouteParser
 8 |  * @phpstan-type ExtraParameters array<string, string|int|bool|float>
 9 |  * @phpstan-type StaticRoutes array<string, array<string, array{mixed, ExtraParameters}>>
10 |  * @phpstan-type DynamicRouteChunk array{regex: string, suffix?: string, routeMap: array<int|string, array{mixed, array<string, string>, ExtraParameters}>}
11 |  * @phpstan-type DynamicRouteChunks list<DynamicRouteChunk>
12 |  * @phpstan-type DynamicRoutes array<string, DynamicRouteChunks>
13 |  * @phpstan-type RouteData array{StaticRoutes, DynamicRoutes}
14 |  */
15 | interface DataGenerator
16 | {
17 |     /**
18 |      * Adds a route to the data generator. The route data uses the
19 |      * same format that is returned by RouterParser::parser().
20 |      *
21 |      * The handler doesn't necessarily need to be a callable, it
22 |      * can be arbitrary data that will be returned when the route
23 |      * matches.
24 |      *
25 |      * @param ParsedRoute     $routeData
26 |      * @param ExtraParameters $extraParameters
27 |      */
28 |     public function addRoute(string $httpMethod, array $routeData, mixed $handler, array $extraParameters = []): void;
29 | 
30 |     /**
31 |      * Returns dispatcher data in some unspecified format, which
32 |      * depends on the used method of dispatch.
33 |      *
34 |      * @return RouteData
35 |      */
36 |     public function getData(): array;
37 | }
38 | 


--------------------------------------------------------------------------------
/src/DataGenerator/CharCountBased.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace FastRoute\DataGenerator;
 5 | 
 6 | use function count;
 7 | use function implode;
 8 | 
 9 | /** @final */
10 | class CharCountBased extends RegexBasedAbstract
11 | {
12 |     protected function getApproxChunkSize(): int
13 |     {
14 |         return 30;
15 |     }
16 | 
17 |     /** @inheritDoc */
18 |     protected function processChunk(array $regexToRoutesMap): array
19 |     {
20 |         $routeMap = [];
21 |         $regexes = [];
22 | 
23 |         $suffixLen = 0;
24 |         $suffix = '';
25 |         $count = count($regexToRoutesMap);
26 |         foreach ($regexToRoutesMap as $regex => $route) {
27 |             $suffixLen++;
28 |             $suffix .= "\t";
29 | 
30 |             $regexes[] = '(?:' . $regex . '/(\t{' . $suffixLen . '})\t{' . ($count - $suffixLen) . '})';
31 |             $routeMap[$suffix] = [$route->handler, $route->variables, $route->extraParameters];
32 |         }
33 | 
34 |         $regex = '~^(?|' . implode('|', $regexes) . ')$~';
35 | 
36 |         return ['regex' => $regex, 'suffix' => '/' . $suffix, 'routeMap' => $routeMap];
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/DataGenerator/GroupCountBased.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace FastRoute\DataGenerator;
 5 | 
 6 | use function count;
 7 | use function implode;
 8 | use function max;
 9 | use function str_repeat;
10 | 
11 | /** @final */
12 | class GroupCountBased extends RegexBasedAbstract
13 | {
14 |     protected function getApproxChunkSize(): int
15 |     {
16 |         return 10;
17 |     }
18 | 
19 |     /** @inheritDoc */
20 |     protected function processChunk(array $regexToRoutesMap): array
21 |     {
22 |         $routeMap = [];
23 |         $regexes = [];
24 |         $numGroups = 0;
25 |         foreach ($regexToRoutesMap as $regex => $route) {
26 |             $numVariables = count($route->variables);
27 |             $numGroups = max($numGroups, $numVariables);
28 | 
29 |             $regexes[] = $regex . str_repeat('()', $numGroups - $numVariables);
30 |             $routeMap[$numGroups + 1] = [$route->handler, $route->variables, $route->extraParameters];
31 | 
32 |             ++$numGroups;
33 |         }
34 | 
35 |         $regex = '~^(?|' . implode('|', $regexes) . ')$~';
36 | 
37 |         return ['regex' => $regex, 'routeMap' => $routeMap];
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/DataGenerator/GroupPosBased.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace FastRoute\DataGenerator;
 5 | 
 6 | use function count;
 7 | use function implode;
 8 | 
 9 | /** @final */
10 | class GroupPosBased extends RegexBasedAbstract
11 | {
12 |     protected function getApproxChunkSize(): int
13 |     {
14 |         return 10;
15 |     }
16 | 
17 |     /** @inheritDoc */
18 |     protected function processChunk(array $regexToRoutesMap): array
19 |     {
20 |         $routeMap = [];
21 |         $regexes = [];
22 |         $offset = 1;
23 |         foreach ($regexToRoutesMap as $regex => $route) {
24 |             $regexes[] = $regex;
25 |             $routeMap[$offset] = [$route->handler, $route->variables, $route->extraParameters];
26 | 
27 |             $offset += count($route->variables);
28 |         }
29 | 
30 |         $regex = '~^(?:' . implode('|', $regexes) . ')$~';
31 | 
32 |         return ['regex' => $regex, 'routeMap' => $routeMap];
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/DataGenerator/MarkBased.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace FastRoute\DataGenerator;
 5 | 
 6 | use function implode;
 7 | 
 8 | /** @final */
 9 | class MarkBased extends RegexBasedAbstract
10 | {
11 |     protected function getApproxChunkSize(): int
12 |     {
13 |         return 30;
14 |     }
15 | 
16 |     /** @inheritDoc */
17 |     protected function processChunk(array $regexToRoutesMap): array
18 |     {
19 |         $routeMap = [];
20 |         $regexes = [];
21 |         $markName = 'a';
22 | 
23 |         foreach ($regexToRoutesMap as $regex => $route) {
24 |             $regexes[] = $regex . '(*MARK:' . $markName . ')';
25 |             $routeMap[$markName] = [$route->handler, $route->variables, $route->extraParameters];
26 | 
27 |             ++$markName;
28 |         }
29 | 
30 |         $regex = '~^(?|' . implode('|', $regexes) . ')$~';
31 | 
32 |         return ['regex' => $regex, 'routeMap' => $routeMap];
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/DataGenerator/RegexBasedAbstract.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | declare(strict_types=1);
  3 | 
  4 | namespace FastRoute\DataGenerator;
  5 | 
  6 | use FastRoute\BadRouteException;
  7 | use FastRoute\DataGenerator;
  8 | use FastRoute\Route;
  9 | use FastRoute\RouteParser;
 10 | 
 11 | use function array_chunk;
 12 | use function array_map;
 13 | use function assert;
 14 | use function ceil;
 15 | use function count;
 16 | use function is_string;
 17 | use function max;
 18 | use function round;
 19 | 
 20 | /**
 21 |  * @internal
 22 |  *
 23 |  * @phpstan-import-type StaticRoutes from DataGenerator
 24 |  * @phpstan-import-type DynamicRouteChunk from DataGenerator
 25 |  * @phpstan-import-type DynamicRoutes from DataGenerator
 26 |  * @phpstan-import-type RouteData from DataGenerator
 27 |  * @phpstan-import-type ExtraParameters from DataGenerator
 28 |  * @phpstan-import-type ParsedRoute from RouteParser
 29 |  */
 30 | abstract class RegexBasedAbstract implements DataGenerator
 31 | {
 32 |     /** @var StaticRoutes */
 33 |     protected array $staticRoutes = [];
 34 | 
 35 |     /** @var array<string, array<string, Route>> */
 36 |     protected array $methodToRegexToRoutesMap = [];
 37 | 
 38 |     abstract protected function getApproxChunkSize(): int;
 39 | 
 40 |     /**
 41 |      * @param array<string, Route> $regexToRoutesMap
 42 |      *
 43 |      * @return DynamicRouteChunk
 44 |      */
 45 |     abstract protected function processChunk(array $regexToRoutesMap): array;
 46 | 
 47 |     /** @inheritDoc */
 48 |     public function addRoute(string $httpMethod, array $routeData, mixed $handler, array $extraParameters = []): void
 49 |     {
 50 |         if ($this->isStaticRoute($routeData)) {
 51 |             $this->addStaticRoute($httpMethod, $routeData, $handler, $extraParameters);
 52 |         } else {
 53 |             $this->addVariableRoute($httpMethod, $routeData, $handler, $extraParameters);
 54 |         }
 55 |     }
 56 | 
 57 |     /** @inheritDoc */
 58 |     public function getData(): array
 59 |     {
 60 |         if ($this->methodToRegexToRoutesMap === []) {
 61 |             return [$this->staticRoutes, []];
 62 |         }
 63 | 
 64 |         return [$this->staticRoutes, $this->generateVariableRouteData()];
 65 |     }
 66 | 
 67 |     /** @return DynamicRoutes */
 68 |     private function generateVariableRouteData(): array
 69 |     {
 70 |         $data = [];
 71 |         foreach ($this->methodToRegexToRoutesMap as $method => $regexToRoutesMap) {
 72 |             $chunkSize = $this->computeChunkSize(count($regexToRoutesMap));
 73 |             $chunks = array_chunk($regexToRoutesMap, $chunkSize, true);
 74 |             $data[$method] = array_map([$this, 'processChunk'], $chunks);
 75 |         }
 76 | 
 77 |         return $data;
 78 |     }
 79 | 
 80 |     /** @return positive-int */
 81 |     private function computeChunkSize(int $count): int
 82 |     {
 83 |         $numParts = max(1, round($count / $this->getApproxChunkSize()));
 84 |         $size = (int) ceil($count / $numParts);
 85 |         assert($size > 0);
 86 | 
 87 |         return $size;
 88 |     }
 89 | 
 90 |     /** @param ParsedRoute $routeData */
 91 |     private function isStaticRoute(array $routeData): bool
 92 |     {
 93 |         return count($routeData) === 1 && is_string($routeData[0]);
 94 |     }
 95 | 
 96 |     /**
 97 |      * @param ParsedRoute     $routeData
 98 |      * @param ExtraParameters $extraParameters
 99 |      */
100 |     private function addStaticRoute(string $httpMethod, array $routeData, mixed $handler, array $extraParameters): void
101 |     {
102 |         $routeStr = $routeData[0];
103 |         assert(is_string($routeStr));
104 | 
105 |         if (isset($this->staticRoutes[$httpMethod][$routeStr])) {
106 |             throw BadRouteException::alreadyRegistered($routeStr, $httpMethod);
107 |         }
108 | 
109 |         if (isset($this->methodToRegexToRoutesMap[$httpMethod])) {
110 |             foreach ($this->methodToRegexToRoutesMap[$httpMethod] as $route) {
111 |                 if ($route->matches($routeStr)) {
112 |                     throw BadRouteException::shadowedByVariableRoute($routeStr, $route->regex, $httpMethod);
113 |                 }
114 |             }
115 |         }
116 | 
117 |         $this->staticRoutes[$httpMethod][$routeStr] = [$handler, $extraParameters];
118 |     }
119 | 
120 |     /**
121 |      * @param ParsedRoute     $routeData
122 |      * @param ExtraParameters $extraParameters
123 |      */
124 |     private function addVariableRoute(string $httpMethod, array $routeData, mixed $handler, array $extraParameters): void
125 |     {
126 |         $route = new Route($httpMethod, $routeData, $handler, $extraParameters);
127 |         $regex = $route->regex;
128 | 
129 |         if (isset($this->methodToRegexToRoutesMap[$httpMethod][$regex])) {
130 |             throw BadRouteException::alreadyRegistered($regex, $httpMethod);
131 |         }
132 | 
133 |         $this->methodToRegexToRoutesMap[$httpMethod][$regex] = $route;
134 |     }
135 | }
136 | 


--------------------------------------------------------------------------------
/src/Dispatcher.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace FastRoute;
 5 | 
 6 | use FastRoute\Dispatcher\Result\Matched;
 7 | use FastRoute\Dispatcher\Result\MethodNotAllowed;
 8 | use FastRoute\Dispatcher\Result\NotMatched;
 9 | 
10 | interface Dispatcher
11 | {
12 |     public const NOT_FOUND = 0;
13 |     public const FOUND = 1;
14 |     public const METHOD_NOT_ALLOWED = 2;
15 | 
16 |     /**
17 |      * Dispatches against the provided HTTP method verb and URI.
18 |      *
19 |      * Returns an object that also has an array shape with one of the following formats:
20 |      *
21 |      *     [self::NOT_FOUND]
22 |      *     [self::METHOD_NOT_ALLOWED, ['GET', 'OTHER_ALLOWED_METHODS']]
23 |      *     [self::FOUND, $handler, ['varName' => 'value', ...]]
24 |      */
25 |     public function dispatch(string $httpMethod, string $uri): Matched|NotMatched|MethodNotAllowed;
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Dispatcher/CharCountBased.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace FastRoute\Dispatcher;
 5 | 
 6 | use FastRoute\Dispatcher\Result\Matched;
 7 | 
 8 | use function assert;
 9 | use function end;
10 | use function preg_match;
11 | 
12 | /** @final */
13 | class CharCountBased extends RegexBasedAbstract
14 | {
15 |     /** @inheritDoc */
16 |     protected function dispatchVariableRoute(array $routeData, string $uri): ?Matched
17 |     {
18 |         foreach ($routeData as $data) {
19 |             assert(isset($data['suffix']));
20 | 
21 |             if (preg_match($data['regex'], $uri . $data['suffix'], $matches) !== 1) {
22 |                 continue;
23 |             }
24 | 
25 |             [$handler, $varNames, $extraParameters] = $data['routeMap'][end($matches)];
26 | 
27 |             $vars = [];
28 |             $i = 0;
29 |             foreach ($varNames as $varName) {
30 |                 $vars[$varName] = $matches[++$i];
31 |             }
32 | 
33 |             $result = new Matched();
34 |             $result->handler = $handler;
35 |             $result->variables = $vars;
36 |             $result->extraParameters = $extraParameters;
37 | 
38 |             return $result;
39 |         }
40 | 
41 |         return null;
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/src/Dispatcher/GroupCountBased.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace FastRoute\Dispatcher;
 5 | 
 6 | use FastRoute\Dispatcher\Result\Matched;
 7 | 
 8 | use function count;
 9 | use function preg_match;
10 | 
11 | /** @final */
12 | class GroupCountBased extends RegexBasedAbstract
13 | {
14 |     /** @inheritDoc */
15 |     protected function dispatchVariableRoute(array $routeData, string $uri): ?Matched
16 |     {
17 |         foreach ($routeData as $data) {
18 |             if (preg_match($data['regex'], $uri, $matches) !== 1) {
19 |                 continue;
20 |             }
21 | 
22 |             [$handler, $varNames, $extraParameters] = $data['routeMap'][count($matches)];
23 | 
24 |             $vars = [];
25 |             $i = 0;
26 |             foreach ($varNames as $varName) {
27 |                 $vars[$varName] = $matches[++$i];
28 |             }
29 | 
30 |             $result = new Matched();
31 |             $result->handler = $handler;
32 |             $result->variables = $vars;
33 |             $result->extraParameters = $extraParameters;
34 | 
35 |             return $result;
36 |         }
37 | 
38 |         return null;
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Dispatcher/GroupPosBased.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace FastRoute\Dispatcher;
 5 | 
 6 | use FastRoute\Dispatcher\Result\Matched;
 7 | 
 8 | use function assert;
 9 | use function preg_match;
10 | 
11 | /** @final */
12 | class GroupPosBased extends RegexBasedAbstract
13 | {
14 |     /** @inheritDoc */
15 |     protected function dispatchVariableRoute(array $routeData, string $uri): ?Matched
16 |     {
17 |         foreach ($routeData as $data) {
18 |             if (preg_match($data['regex'], $uri, $matches) !== 1) {
19 |                 continue;
20 |             }
21 | 
22 |             // find first non-empty match
23 |             // phpcs:ignore Generic.CodeAnalysis.EmptyStatement.DetectedFor
24 |             for ($i = 1; $matches[$i] === ''; ++$i) {
25 |             }
26 | 
27 |             assert(isset($i));
28 | 
29 |             [$handler, $varNames, $extraParameters] = $data['routeMap'][$i];
30 | 
31 |             $vars = [];
32 |             foreach ($varNames as $varName) {
33 |                 $vars[$varName] = $matches[$i++];
34 |             }
35 | 
36 |             $result = new Matched();
37 |             $result->handler = $handler;
38 |             $result->variables = $vars;
39 |             $result->extraParameters = $extraParameters;
40 | 
41 |             return $result;
42 |         }
43 | 
44 |         return null;
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/src/Dispatcher/MarkBased.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace FastRoute\Dispatcher;
 5 | 
 6 | use FastRoute\Dispatcher\Result\Matched;
 7 | 
 8 | use function preg_match;
 9 | 
10 | /** @final */
11 | class MarkBased extends RegexBasedAbstract
12 | {
13 |     /** @inheritDoc */
14 |     protected function dispatchVariableRoute(array $routeData, string $uri): ?Matched
15 |     {
16 |         foreach ($routeData as $data) {
17 |             if (preg_match($data['regex'], $uri, $matches) !== 1) {
18 |                 continue;
19 |             }
20 | 
21 |             [$handler, $varNames, $extraParameters] = $data['routeMap'][$matches['MARK']];
22 | 
23 |             $vars = [];
24 |             $i = 0;
25 |             foreach ($varNames as $varName) {
26 |                 $vars[$varName] = $matches[++$i];
27 |             }
28 | 
29 |             $result = new Matched();
30 |             $result->handler = $handler;
31 |             $result->variables = $vars;
32 |             $result->extraParameters = $extraParameters;
33 | 
34 |             return $result;
35 |         }
36 | 
37 |         return null;
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/Dispatcher/RegexBasedAbstract.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | declare(strict_types=1);
  3 | 
  4 | namespace FastRoute\Dispatcher;
  5 | 
  6 | use FastRoute\DataGenerator;
  7 | use FastRoute\Dispatcher;
  8 | use FastRoute\Dispatcher\Result\Matched;
  9 | use FastRoute\Dispatcher\Result\MethodNotAllowed;
 10 | use FastRoute\Dispatcher\Result\NotMatched;
 11 | 
 12 | /**
 13 |  * @internal
 14 |  *
 15 |  * @phpstan-import-type StaticRoutes from DataGenerator
 16 |  * @phpstan-import-type DynamicRouteChunk from DataGenerator
 17 |  * @phpstan-import-type DynamicRouteChunks from DataGenerator
 18 |  * @phpstan-import-type DynamicRoutes from DataGenerator
 19 |  * @phpstan-import-type RouteData from DataGenerator
 20 |  */
 21 | abstract class RegexBasedAbstract implements Dispatcher
 22 | {
 23 |     /** @var StaticRoutes */
 24 |     protected array $staticRouteMap = [];
 25 | 
 26 |     /** @var DynamicRoutes */
 27 |     protected array $variableRouteData = [];
 28 | 
 29 |     /** @param RouteData $data */
 30 |     public function __construct(array $data)
 31 |     {
 32 |         [$this->staticRouteMap, $this->variableRouteData] = $data;
 33 |     }
 34 | 
 35 |     /** @param DynamicRouteChunks $routeData */
 36 |     abstract protected function dispatchVariableRoute(array $routeData, string $uri): ?Matched;
 37 | 
 38 |     public function dispatch(string $httpMethod, string $uri): Matched|NotMatched|MethodNotAllowed
 39 |     {
 40 |         if (isset($this->staticRouteMap[$httpMethod][$uri])) {
 41 |             $result = new Matched();
 42 |             $result->handler = $this->staticRouteMap[$httpMethod][$uri][0];
 43 |             $result->extraParameters = $this->staticRouteMap[$httpMethod][$uri][1];
 44 | 
 45 |             return $result;
 46 |         }
 47 | 
 48 |         if (isset($this->variableRouteData[$httpMethod])) {
 49 |             $result = $this->dispatchVariableRoute($this->variableRouteData[$httpMethod], $uri);
 50 |             if ($result !== null) {
 51 |                 return $result;
 52 |             }
 53 |         }
 54 | 
 55 |         // For HEAD requests, attempt fallback to GET
 56 |         if ($httpMethod === 'HEAD') {
 57 |             if (isset($this->staticRouteMap['GET'][$uri])) {
 58 |                 $result = new Matched();
 59 |                 $result->handler = $this->staticRouteMap['GET'][$uri][0];
 60 |                 $result->extraParameters = $this->staticRouteMap['GET'][$uri][1];
 61 | 
 62 |                 return $result;
 63 |             }
 64 | 
 65 |             if (isset($this->variableRouteData['GET'])) {
 66 |                 $result = $this->dispatchVariableRoute($this->variableRouteData['GET'], $uri);
 67 |                 if ($result !== null) {
 68 |                     return $result;
 69 |                 }
 70 |             }
 71 |         }
 72 | 
 73 |         // If nothing else matches, try fallback routes
 74 |         if (isset($this->staticRouteMap['*'][$uri])) {
 75 |             $result = new Matched();
 76 |             $result->handler = $this->staticRouteMap['*'][$uri][0];
 77 |             $result->extraParameters = $this->staticRouteMap['*'][$uri][1];
 78 | 
 79 |             return $result;
 80 |         }
 81 | 
 82 |         if (isset($this->variableRouteData['*'])) {
 83 |             $result = $this->dispatchVariableRoute($this->variableRouteData['*'], $uri);
 84 |             if ($result !== null) {
 85 |                 return $result;
 86 |             }
 87 |         }
 88 | 
 89 |         // Find allowed methods for this URI by matching against all other HTTP methods as well
 90 |         $allowedMethods = [];
 91 | 
 92 |         foreach ($this->staticRouteMap as $method => $uriMap) {
 93 |             if ($method === $httpMethod || ! isset($uriMap[$uri])) {
 94 |                 continue;
 95 |             }
 96 | 
 97 |             $allowedMethods[] = $method;
 98 |         }
 99 | 
100 |         foreach ($this->variableRouteData as $method => $routeData) {
101 |             if ($method === $httpMethod) {
102 |                 continue;
103 |             }
104 | 
105 |             $result = $this->dispatchVariableRoute($routeData, $uri);
106 |             if ($result === null) {
107 |                 continue;
108 |             }
109 | 
110 |             $allowedMethods[] = $method;
111 |         }
112 | 
113 |         // If there are no allowed methods the route simply does not exist
114 |         if ($allowedMethods !== []) {
115 |             $result = new MethodNotAllowed();
116 |             $result->allowedMethods = $allowedMethods;
117 | 
118 |             return $result;
119 |         }
120 | 
121 |         return new NotMatched();
122 |     }
123 | }
124 | 


--------------------------------------------------------------------------------
/src/Dispatcher/Result/Matched.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace FastRoute\Dispatcher\Result;
 5 | 
 6 | use ArrayAccess;
 7 | use FastRoute\DataGenerator;
 8 | use FastRoute\Dispatcher;
 9 | use OutOfBoundsException;
10 | use RuntimeException;
11 | 
12 | /**
13 |  * @phpstan-import-type ExtraParameters from DataGenerator
14 |  * @implements ArrayAccess<int, Dispatcher::FOUND|mixed|array<string, string>>
15 |  */
16 | final class Matched implements ArrayAccess
17 | {
18 |     /** @readonly */
19 |     public mixed $handler;
20 | 
21 |     /**
22 |      * @readonly
23 |      * @var array<string, string> $variables
24 |      */
25 |     public array $variables = [];
26 | 
27 |     /**
28 |      * @readonly
29 |      * @var ExtraParameters
30 |      */
31 |     public array $extraParameters = [];
32 | 
33 |     public function offsetExists(mixed $offset): bool
34 |     {
35 |         return $offset >= 0 && $offset <= 2;
36 |     }
37 | 
38 |     public function offsetGet(mixed $offset): mixed
39 |     {
40 |         return match ($offset) {
41 |             0 => Dispatcher::FOUND,
42 |             1 => $this->handler,
43 |             2 => $this->variables,
44 |             default => throw new OutOfBoundsException()
45 |         };
46 |     }
47 | 
48 |     public function offsetSet(mixed $offset, mixed $value): void
49 |     {
50 |         throw new RuntimeException('Result cannot be changed');
51 |     }
52 | 
53 |     public function offsetUnset(mixed $offset): void
54 |     {
55 |         throw new RuntimeException('Result cannot be changed');
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/src/Dispatcher/Result/MethodNotAllowed.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace FastRoute\Dispatcher\Result;
 5 | 
 6 | use ArrayAccess;
 7 | use FastRoute\Dispatcher;
 8 | use OutOfBoundsException;
 9 | use RuntimeException;
10 | 
11 | /** @implements ArrayAccess<int, Dispatcher::METHOD_NOT_ALLOWED|non-empty-list<string>> */
12 | final class MethodNotAllowed implements ArrayAccess
13 | {
14 |     /**
15 |      * @readonly
16 |      * @var non-empty-list<string> $allowedMethods
17 |      */
18 |     public array $allowedMethods;
19 | 
20 |     public function offsetExists(mixed $offset): bool
21 |     {
22 |         return $offset === 0 || $offset === 1;
23 |     }
24 | 
25 |     public function offsetGet(mixed $offset): mixed
26 |     {
27 |         return match ($offset) {
28 |             0 => Dispatcher::METHOD_NOT_ALLOWED,
29 |             1 => $this->allowedMethods,
30 |             default => throw new OutOfBoundsException(),
31 |         };
32 |     }
33 | 
34 |     public function offsetSet(mixed $offset, mixed $value): void
35 |     {
36 |         throw new RuntimeException('Result cannot be changed');
37 |     }
38 | 
39 |     public function offsetUnset(mixed $offset): void
40 |     {
41 |         throw new RuntimeException('Result cannot be changed');
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/src/Dispatcher/Result/NotMatched.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace FastRoute\Dispatcher\Result;
 5 | 
 6 | use ArrayAccess;
 7 | use FastRoute\Dispatcher;
 8 | use OutOfBoundsException;
 9 | use RuntimeException;
10 | 
11 | /** @implements ArrayAccess<int, Dispatcher::NOT_FOUND> */
12 | final class NotMatched implements ArrayAccess
13 | {
14 |     public function offsetExists(mixed $offset): bool
15 |     {
16 |         return $offset === 0;
17 |     }
18 | 
19 |     public function offsetGet(mixed $offset): mixed
20 |     {
21 |         return match ($offset) {
22 |             0 => Dispatcher::NOT_FOUND,
23 |             default => throw new OutOfBoundsException(),
24 |         };
25 |     }
26 | 
27 |     public function offsetSet(mixed $offset, mixed $value): void
28 |     {
29 |         throw new RuntimeException('Result cannot be changed');
30 |     }
31 | 
32 |     public function offsetUnset(mixed $offset): void
33 |     {
34 |         throw new RuntimeException('Result cannot be changed');
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/src/Exception.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace FastRoute;
 5 | 
 6 | use Throwable;
 7 | 
 8 | interface Exception extends Throwable
 9 | {
10 | }
11 | 


--------------------------------------------------------------------------------
/src/FastRoute.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | declare(strict_types=1);
  3 | 
  4 | namespace FastRoute;
  5 | 
  6 | use Closure;
  7 | use FastRoute\Cache\FileCache;
  8 | 
  9 | use function assert;
 10 | use function is_string;
 11 | 
 12 | /** @phpstan-import-type ProcessedData from ConfigureRoutes */
 13 | final class FastRoute
 14 | {
 15 |     /** @var ProcessedData|null */
 16 |     private ?array $processedConfiguration = null;
 17 | 
 18 |     /**
 19 |      * @param Closure(ConfigureRoutes):void  $routeDefinitionCallback
 20 |      * @param class-string<RouteParser>      $routeParser
 21 |      * @param class-string<DataGenerator>    $dataGenerator
 22 |      * @param class-string<Dispatcher>       $dispatcher
 23 |      * @param class-string<ConfigureRoutes>  $routesConfiguration
 24 |      * @param class-string<GenerateUri>      $uriGenerator
 25 |      * @param Cache|class-string<Cache>|null $cacheDriver
 26 |      * @param non-empty-string|null          $cacheKey
 27 |      */
 28 |     private function __construct(
 29 |         private readonly Closure $routeDefinitionCallback,
 30 |         private readonly string $routeParser,
 31 |         private readonly string $dataGenerator,
 32 |         private readonly string $dispatcher,
 33 |         private readonly string $routesConfiguration,
 34 |         private readonly string $uriGenerator,
 35 |         private readonly Cache|string|null $cacheDriver,
 36 |         private readonly ?string $cacheKey,
 37 |     ) {
 38 |     }
 39 | 
 40 |     /**
 41 |      * @param Closure(ConfigureRoutes):void $routeDefinitionCallback
 42 |      * @param non-empty-string              $cacheKey
 43 |      */
 44 |     public static function recommendedSettings(Closure $routeDefinitionCallback, string $cacheKey): self
 45 |     {
 46 |         return new self(
 47 |             $routeDefinitionCallback,
 48 |             RouteParser\Std::class,
 49 |             DataGenerator\MarkBased::class,
 50 |             Dispatcher\MarkBased::class,
 51 |             RouteCollector::class,
 52 |             GenerateUri\FromProcessedConfiguration::class,
 53 |             FileCache::class,
 54 |             $cacheKey,
 55 |         );
 56 |     }
 57 | 
 58 |     public function disableCache(): self
 59 |     {
 60 |         return new self(
 61 |             $this->routeDefinitionCallback,
 62 |             $this->routeParser,
 63 |             $this->dataGenerator,
 64 |             $this->dispatcher,
 65 |             $this->routesConfiguration,
 66 |             $this->uriGenerator,
 67 |             null,
 68 |             null,
 69 |         );
 70 |     }
 71 | 
 72 |     /**
 73 |      * @param Cache|class-string<Cache> $driver
 74 |      * @param non-empty-string          $cacheKey
 75 |      */
 76 |     public function withCache(Cache|string $driver, string $cacheKey): self
 77 |     {
 78 |         return new self(
 79 |             $this->routeDefinitionCallback,
 80 |             $this->routeParser,
 81 |             $this->dataGenerator,
 82 |             $this->dispatcher,
 83 |             $this->routesConfiguration,
 84 |             $this->uriGenerator,
 85 |             $driver,
 86 |             $cacheKey,
 87 |         );
 88 |     }
 89 | 
 90 |     public function useCharCountDispatcher(): self
 91 |     {
 92 |         return $this->useCustomDispatcher(DataGenerator\CharCountBased::class, Dispatcher\CharCountBased::class);
 93 |     }
 94 | 
 95 |     public function useGroupCountDispatcher(): self
 96 |     {
 97 |         return $this->useCustomDispatcher(DataGenerator\GroupCountBased::class, Dispatcher\GroupCountBased::class);
 98 |     }
 99 | 
100 |     public function useGroupPosDispatcher(): self
101 |     {
102 |         return $this->useCustomDispatcher(DataGenerator\GroupPosBased::class, Dispatcher\GroupPosBased::class);
103 |     }
104 | 
105 |     public function useMarkDispatcher(): self
106 |     {
107 |         return $this->useCustomDispatcher(DataGenerator\MarkBased::class, Dispatcher\MarkBased::class);
108 |     }
109 | 
110 |     /**
111 |      * @param class-string<DataGenerator> $dataGenerator
112 |      * @param class-string<Dispatcher>    $dispatcher
113 |      */
114 |     public function useCustomDispatcher(string $dataGenerator, string $dispatcher): self
115 |     {
116 |         return new self(
117 |             $this->routeDefinitionCallback,
118 |             $this->routeParser,
119 |             $dataGenerator,
120 |             $dispatcher,
121 |             $this->routesConfiguration,
122 |             $this->uriGenerator,
123 |             $this->cacheDriver,
124 |             $this->cacheKey,
125 |         );
126 |     }
127 | 
128 |     /** @param class-string<GenerateUri> $uriGenerator */
129 |     public function withUriGenerator(string $uriGenerator): self
130 |     {
131 |         return new self(
132 |             $this->routeDefinitionCallback,
133 |             $this->routeParser,
134 |             $this->dataGenerator,
135 |             $this->dispatcher,
136 |             $this->routesConfiguration,
137 |             $uriGenerator,
138 |             $this->cacheDriver,
139 |             $this->cacheKey,
140 |         );
141 |     }
142 | 
143 |     /** @return ProcessedData */
144 |     private function buildConfiguration(): array
145 |     {
146 |         if ($this->processedConfiguration !== null) {
147 |             return $this->processedConfiguration;
148 |         }
149 | 
150 |         $loader = function (): array {
151 |             $configuredRoutes = new $this->routesConfiguration(
152 |                 new $this->routeParser(),
153 |                 new $this->dataGenerator(),
154 |             );
155 | 
156 |             ($this->routeDefinitionCallback)($configuredRoutes);
157 | 
158 |             return $configuredRoutes->processedRoutes();
159 |         };
160 | 
161 |         if ($this->cacheDriver === null) {
162 |             return $this->processedConfiguration = $loader();
163 |         }
164 | 
165 |         assert(is_string($this->cacheKey));
166 | 
167 |         $cache = is_string($this->cacheDriver)
168 |             ? new $this->cacheDriver()
169 |             : $this->cacheDriver;
170 | 
171 |         return $this->processedConfiguration = $cache->get($this->cacheKey, $loader);
172 |     }
173 | 
174 |     public function dispatcher(): Dispatcher
175 |     {
176 |         return new $this->dispatcher($this->buildConfiguration());
177 |     }
178 | 
179 |     public function uriGenerator(): GenerateUri
180 |     {
181 |         return new $this->uriGenerator($this->buildConfiguration()[2]);
182 |     }
183 | }
184 | 


--------------------------------------------------------------------------------
/src/GenerateUri.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace FastRoute;
 5 | 
 6 | use FastRoute\GenerateUri\UriCouldNotBeGenerated;
 7 | 
 8 | /**
 9 |  * @phpstan-import-type ParsedRoutes from RouteParser
10 |  * @phpstan-type RoutesForUriGeneration array<non-empty-string, ParsedRoutes>
11 |  * @phpstan-type UriSubstitutions array<non-empty-string, non-empty-string>
12 |  */
13 | interface GenerateUri
14 | {
15 |     /**
16 |      * @param UriSubstitutions $substitutions
17 |      *
18 |      * @throws UriCouldNotBeGenerated
19 |      */
20 |     public function forRoute(string $name, array $substitutions = []): string;
21 | }
22 | 


--------------------------------------------------------------------------------
/src/GenerateUri/FromProcessedConfiguration.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | declare(strict_types=1);
  3 | 
  4 | namespace FastRoute\GenerateUri;
  5 | 
  6 | use FastRoute\GenerateUri;
  7 | use FastRoute\RouteParser;
  8 | 
  9 | use function array_key_exists;
 10 | use function array_keys;
 11 | use function assert;
 12 | use function count;
 13 | use function is_string;
 14 | use function preg_match;
 15 | 
 16 | /**
 17 |  * @phpstan-import-type RoutesForUriGeneration from GenerateUri
 18 |  * @phpstan-import-type UriSubstitutions from GenerateUri
 19 |  * @phpstan-import-type ParsedRoute from RouteParser
 20 |  */
 21 | final class FromProcessedConfiguration implements GenerateUri
 22 | {
 23 |     /** @param RoutesForUriGeneration $processedConfiguration */
 24 |     public function __construct(private readonly array $processedConfiguration)
 25 |     {
 26 |     }
 27 | 
 28 |     /** @inheritDoc */
 29 |     public function forRoute(string $name, array $substitutions = []): string
 30 |     {
 31 |         if (! array_key_exists($name, $this->processedConfiguration)) {
 32 |             throw UriCouldNotBeGenerated::routeIsUndefined($name);
 33 |         }
 34 | 
 35 |         $missingParameters = [];
 36 | 
 37 |         foreach ($this->processedConfiguration[$name] as $parsedRoute) {
 38 |             $missingParameters = $this->missingParameters($parsedRoute, $substitutions);
 39 | 
 40 |             // Only attempt to generate the path if we have the necessary info
 41 |             if (count($missingParameters) === 0) {
 42 |                 return $this->generatePath($name, $parsedRoute, $substitutions);
 43 |             }
 44 |         }
 45 | 
 46 |         assert(count($missingParameters) > 0);
 47 | 
 48 |         throw UriCouldNotBeGenerated::insufficientParameters(
 49 |             $name,
 50 |             $missingParameters,
 51 |             array_keys($substitutions),
 52 |         );
 53 |     }
 54 | 
 55 |     /**
 56 |      * Returns the expected parameters that were not passed as substitutions
 57 |      *
 58 |      * @param ParsedRoute      $parts
 59 |      * @param UriSubstitutions $substitutions
 60 |      *
 61 |      * @return list<string>
 62 |      */
 63 |     private function missingParameters(array $parts, array $substitutions): array
 64 |     {
 65 |         $missingParameters = [];
 66 | 
 67 |         foreach ($parts as $part) {
 68 |             if (is_string($part) || array_key_exists($part[0], $substitutions)) {
 69 |                 continue;
 70 |             }
 71 | 
 72 |             $missingParameters[] = $part[0];
 73 |         }
 74 | 
 75 |         return $missingParameters;
 76 |     }
 77 | 
 78 |     /**
 79 |      * @param ParsedRoute      $parsedRoute
 80 |      * @param UriSubstitutions $substitutions
 81 |      */
 82 |     private function generatePath(string $route, array $parsedRoute, array $substitutions): string
 83 |     {
 84 |         $path = '';
 85 | 
 86 |         foreach ($parsedRoute as $part) {
 87 |             if (is_string($part)) {
 88 |                 $path .= $part;
 89 | 
 90 |                 continue;
 91 |             }
 92 | 
 93 |             [$parameterName, $regex] = $part;
 94 | 
 95 |             if (preg_match('~^' . $regex . '$~u', $substitutions[$parameterName]) !== 1) {
 96 |                 throw UriCouldNotBeGenerated::parameterDoesNotMatchThePattern($route, $parameterName, $regex);
 97 |             }
 98 | 
 99 |             $path .= $substitutions[$parameterName];
100 |         }
101 | 
102 |         return $path;
103 |     }
104 | }
105 | 


--------------------------------------------------------------------------------
/src/GenerateUri/UriCouldNotBeGenerated.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace FastRoute\GenerateUri;
 5 | 
 6 | use FastRoute\Exception;
 7 | use LogicException;
 8 | 
 9 | use function count;
10 | use function implode;
11 | use function sprintf;
12 | 
13 | final class UriCouldNotBeGenerated extends LogicException implements Exception
14 | {
15 |     public static function routeIsUndefined(string $name): self
16 |     {
17 |         return new self('There is no route with name "' . $name . '" defined');
18 |     }
19 | 
20 |     public static function parameterDoesNotMatchThePattern(
21 |         string $route,
22 |         string $parameter,
23 |         string $expectedPattern,
24 |     ): self {
25 |         return new self(
26 |             sprintf(
27 |                 'Route "%s" expects the parameter [%s] to match the regex `%s`',
28 |                 $route,
29 |                 $parameter,
30 |                 $expectedPattern,
31 |             ),
32 |         );
33 |     }
34 | 
35 |     /**
36 |      * @param non-empty-list<string> $missingParameters
37 |      * @param list<string>           $givenParameters
38 |      */
39 |     public static function insufficientParameters(
40 |         string $route,
41 |         array $missingParameters,
42 |         array $givenParameters,
43 |     ): self {
44 |         return new self(
45 |             sprintf(
46 |                 'Route "%s" expects at least parameter values for [%s], but received %s',
47 |                 $route,
48 |                 implode(',', $missingParameters),
49 |                 count($givenParameters) === 0 ? 'none' : '[' . implode(',', $givenParameters) . ']',
50 |             ),
51 |         );
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/src/Route.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace FastRoute;
 5 | 
 6 | use function is_string;
 7 | use function preg_match;
 8 | use function preg_quote;
 9 | 
10 | /**
11 |  * @internal
12 |  *
13 |  * @phpstan-import-type ExtraParameters from DataGenerator
14 |  * @phpstan-import-type ParsedRoute from RouteParser
15 |  */
16 | class Route
17 | {
18 |     public readonly string $regex;
19 | 
20 |     /** @var array<string, string> $variables */
21 |     public readonly array $variables;
22 | 
23 |     /**
24 |      * @param ParsedRoute     $routeData
25 |      * @param ExtraParameters $extraParameters
26 |      */
27 |     public function __construct(
28 |         public readonly string $httpMethod,
29 |         array $routeData,
30 |         public readonly mixed $handler,
31 |         public readonly array $extraParameters,
32 |     ) {
33 |         [$this->regex, $this->variables] = self::extractRegex($routeData);
34 |     }
35 | 
36 |     /**
37 |      * @param ParsedRoute $routeData
38 |      *
39 |      * @return array{string, array<string, string>}
40 |      */
41 |     private static function extractRegex(array $routeData): array
42 |     {
43 |         $regex = '';
44 |         $variables = [];
45 | 
46 |         foreach ($routeData as $part) {
47 |             if (is_string($part)) {
48 |                 $regex .= preg_quote($part, '~');
49 |                 continue;
50 |             }
51 | 
52 |             [$varName, $regexPart] = $part;
53 | 
54 |             $variables[$varName] = $varName;
55 |             $regex .= '(' . $regexPart . ')';
56 |         }
57 | 
58 |         return [$regex, $variables];
59 |     }
60 | 
61 |     /**
62 |      * Tests whether this route matches the given string.
63 |      */
64 |     public function matches(string $str): bool
65 |     {
66 |         $regex = '~^' . $this->regex . '$~';
67 | 
68 |         return (bool) preg_match($regex, $str);
69 |     }
70 | }
71 | 


--------------------------------------------------------------------------------
/src/RouteCollector.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | declare(strict_types=1);
  3 | 
  4 | namespace FastRoute;
  5 | 
  6 | use function array_key_exists;
  7 | use function array_reverse;
  8 | use function is_string;
  9 | 
 10 | /**
 11 |  * @phpstan-import-type ProcessedData from ConfigureRoutes
 12 |  * @phpstan-import-type ExtraParameters from DataGenerator
 13 |  * @phpstan-import-type RoutesForUriGeneration from GenerateUri
 14 |  * @phpstan-import-type ParsedRoutes from RouteParser
 15 |  * @final
 16 |  */
 17 | class RouteCollector implements ConfigureRoutes
 18 | {
 19 |     protected string $currentGroupPrefix = '';
 20 | 
 21 |     /** @var RoutesForUriGeneration */
 22 |     private array $namedRoutes = [];
 23 | 
 24 |     public function __construct(
 25 |         protected readonly RouteParser $routeParser,
 26 |         protected readonly DataGenerator $dataGenerator,
 27 |     ) {
 28 |     }
 29 | 
 30 |     /** @inheritDoc */
 31 |     public function addRoute(string|array $httpMethod, string $route, mixed $handler, array $extraParameters = []): void
 32 |     {
 33 |         $route = $this->currentGroupPrefix . $route;
 34 |         $parsedRoutes = $this->routeParser->parse($route);
 35 | 
 36 |         $extraParameters = [self::ROUTE_REGEX => $route] + $extraParameters;
 37 | 
 38 |         foreach ((array) $httpMethod as $method) {
 39 |             foreach ($parsedRoutes as $parsedRoute) {
 40 |                 $this->dataGenerator->addRoute($method, $parsedRoute, $handler, $extraParameters);
 41 |             }
 42 |         }
 43 | 
 44 |         if (array_key_exists(self::ROUTE_NAME, $extraParameters)) {
 45 |             $this->registerNamedRoute($extraParameters[self::ROUTE_NAME], $parsedRoutes);
 46 |         }
 47 |     }
 48 | 
 49 |     /** @param ParsedRoutes $parsedRoutes */
 50 |     private function registerNamedRoute(mixed $name, array $parsedRoutes): void
 51 |     {
 52 |         if (! is_string($name) || $name === '') {
 53 |             throw BadRouteException::invalidRouteName($name);
 54 |         }
 55 | 
 56 |         if (array_key_exists($name, $this->namedRoutes)) {
 57 |             throw BadRouteException::namedRouteAlreadyDefined($name);
 58 |         }
 59 | 
 60 |         $this->namedRoutes[$name] = array_reverse($parsedRoutes);
 61 |     }
 62 | 
 63 |     public function addGroup(string $prefix, callable $callback): void
 64 |     {
 65 |         $previousGroupPrefix = $this->currentGroupPrefix;
 66 |         $this->currentGroupPrefix = $previousGroupPrefix . $prefix;
 67 |         $callback($this);
 68 |         $this->currentGroupPrefix = $previousGroupPrefix;
 69 |     }
 70 | 
 71 |     /** @inheritDoc */
 72 |     public function any(string $route, mixed $handler, array $extraParameters = []): void
 73 |     {
 74 |         $this->addRoute('*', $route, $handler, $extraParameters);
 75 |     }
 76 | 
 77 |     /** @inheritDoc */
 78 |     public function get(string $route, mixed $handler, array $extraParameters = []): void
 79 |     {
 80 |         $this->addRoute('GET', $route, $handler, $extraParameters);
 81 |     }
 82 | 
 83 |     /** @inheritDoc */
 84 |     public function post(string $route, mixed $handler, array $extraParameters = []): void
 85 |     {
 86 |         $this->addRoute('POST', $route, $handler, $extraParameters);
 87 |     }
 88 | 
 89 |     /** @inheritDoc */
 90 |     public function put(string $route, mixed $handler, array $extraParameters = []): void
 91 |     {
 92 |         $this->addRoute('PUT', $route, $handler, $extraParameters);
 93 |     }
 94 | 
 95 |     /** @inheritDoc */
 96 |     public function delete(string $route, mixed $handler, array $extraParameters = []): void
 97 |     {
 98 |         $this->addRoute('DELETE', $route, $handler, $extraParameters);
 99 |     }
100 | 
101 |     /** @inheritDoc */
102 |     public function patch(string $route, mixed $handler, array $extraParameters = []): void
103 |     {
104 |         $this->addRoute('PATCH', $route, $handler, $extraParameters);
105 |     }
106 | 
107 |     /** @inheritDoc */
108 |     public function head(string $route, mixed $handler, array $extraParameters = []): void
109 |     {
110 |         $this->addRoute('HEAD', $route, $handler, $extraParameters);
111 |     }
112 | 
113 |     /** @inheritDoc */
114 |     public function options(string $route, mixed $handler, array $extraParameters = []): void
115 |     {
116 |         $this->addRoute('OPTIONS', $route, $handler, $extraParameters);
117 |     }
118 | 
119 |     /** @inheritDoc */
120 |     public function processedRoutes(): array
121 |     {
122 |         $data =  $this->dataGenerator->getData();
123 |         $data[] = $this->namedRoutes;
124 | 
125 |         return $data;
126 |     }
127 | 
128 |     /**
129 |      * @deprecated
130 |      *
131 |      * @see ConfigureRoutes::processedRoutes()
132 |      *
133 |      * @return ProcessedData
134 |      */
135 |     public function getData(): array
136 |     {
137 |         return $this->processedRoutes();
138 |     }
139 | }
140 | 


--------------------------------------------------------------------------------
/src/RouteParser.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace FastRoute;
 5 | 
 6 | /**
 7 |  * @phpstan-type ParsedRoute array<string|array{string, string}>
 8 |  * @phpstan-type ParsedRoutes list<ParsedRoute>
 9 |  */
10 | interface RouteParser
11 | {
12 |     /**
13 |      * Parses a route string into multiple route data arrays.
14 |      *
15 |      * The expected output is defined using an example:
16 |      *
17 |      * For the route string "/fixedRoutePart/{varName}[/moreFixed/{varName2:\d+}]", if {varName} is interpreted as
18 |      * a placeholder and [...] is interpreted as an optional route part, the expected result is:
19 |      *
20 |      * [
21 |      *     // first route: without optional part
22 |      *     [
23 |      *         "/fixedRoutePart/",
24 |      *         ["varName", "[^/]+"],
25 |      *     ],
26 |      *     // second route: with optional part
27 |      *     [
28 |      *         "/fixedRoutePart/",
29 |      *         ["varName", "[^/]+"],
30 |      *         "/moreFixed/",
31 |      *         ["varName2", [0-9]+"],
32 |      *     ],
33 |      * ]
34 |      *
35 |      * Here one route string was converted into two route data arrays.
36 |      *
37 |      * @param string $route Route string to parse
38 |      *
39 |      * @return ParsedRoutes Array of route data arrays
40 |      */
41 |     public function parse(string $route): array;
42 | }
43 | 


--------------------------------------------------------------------------------
/src/RouteParser/Std.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | declare(strict_types=1);
  3 | 
  4 | namespace FastRoute\RouteParser;
  5 | 
  6 | use FastRoute\BadRouteException;
  7 | use FastRoute\RouteParser;
  8 | 
  9 | use function assert;
 10 | use function count;
 11 | use function in_array;
 12 | use function is_array;
 13 | use function preg_match;
 14 | use function preg_match_all;
 15 | use function preg_split;
 16 | use function rtrim;
 17 | use function str_contains;
 18 | use function strlen;
 19 | use function substr;
 20 | use function trim;
 21 | 
 22 | use const PREG_OFFSET_CAPTURE;
 23 | use const PREG_SET_ORDER;
 24 | 
 25 | /**
 26 |  * Parses route strings of the following form:
 27 |  *
 28 |  * "/user/{name}[/{id:[0-9]+}]"
 29 |  *
 30 |  * @phpstan-import-type ParsedRoute from RouteParser
 31 |  * @final
 32 |  */
 33 | class Std implements RouteParser
 34 | {
 35 |     public const VARIABLE_REGEX = <<<'REGEX'
 36 | \{
 37 |     \s* ([a-zA-Z_][a-zA-Z0-9_-]*) \s*
 38 |     (?:
 39 |         : \s* ([^{}]*(?:\{(?-1)\}[^{}]*)*)
 40 |     )?
 41 | \}
 42 | REGEX;
 43 | 
 44 |     public const DEFAULT_DISPATCH_REGEX = '[^/]+';
 45 |     private const CAPTURING_GROUPS_REGEX = '~
 46 |                 (?:
 47 |                     \(\?\(
 48 |                   | \[ [^\]\\\\]* (?: \\\\ . [^\]\\\\]* )* \]
 49 |                   | \\\\ .
 50 |                 ) (*SKIP)(*FAIL) |
 51 |                 \(
 52 |                 (?!
 53 |                     \? (?! <(?![!=]) | P< | \' )
 54 |                   | \*
 55 |                 )
 56 |             ~x';
 57 | 
 58 |     /** @inheritDoc */
 59 |     public function parse(string $route): array
 60 |     {
 61 |         $routeWithoutClosingOptionals = rtrim($route, ']');
 62 |         $numOptionals = strlen($route) - strlen($routeWithoutClosingOptionals);
 63 | 
 64 |         // Split on [ while skipping placeholders
 65 |         $segments = preg_split('~' . self::VARIABLE_REGEX . '(*SKIP)(*F) | \[~x', $routeWithoutClosingOptionals);
 66 |         assert(is_array($segments));
 67 | 
 68 |         if ($numOptionals !== count($segments) - 1) {
 69 |             // If there are any ] in the middle of the route, throw a more specific error message
 70 |             if (preg_match('~' . self::VARIABLE_REGEX . '(*SKIP)(*F) | \]~x', $routeWithoutClosingOptionals) === 1) {
 71 |                 throw new BadRouteException('Optional segments can only occur at the end of a route');
 72 |             }
 73 | 
 74 |             throw new BadRouteException("Number of opening '[' and closing ']' does not match");
 75 |         }
 76 | 
 77 |         $currentRoute = '';
 78 |         $parsedRoutes = [];
 79 | 
 80 |         foreach ($segments as $n => $segment) {
 81 |             if ($segment === '' && $n !== 0) {
 82 |                 throw new BadRouteException('Empty optional part');
 83 |             }
 84 | 
 85 |             $currentRoute .= $segment;
 86 |             $parsedRoutes[] = $this->parsePlaceholders($currentRoute);
 87 |         }
 88 | 
 89 |         return $parsedRoutes;
 90 |     }
 91 | 
 92 |     /**
 93 |      * Parses a route string that does not contain optional segments.
 94 |      *
 95 |      * @return ParsedRoute
 96 |      */
 97 |     private function parsePlaceholders(string $route): array
 98 |     {
 99 |         if ((int) preg_match_all('~' . self::VARIABLE_REGEX . '~x', $route, $matches, PREG_OFFSET_CAPTURE | PREG_SET_ORDER) === 0) {
100 |             return [$route];
101 |         }
102 | 
103 |         $offset = 0;
104 |         $routeData = [];
105 | 
106 |         $parsedVariableNames = [];
107 | 
108 |         foreach ($matches as $set) {
109 |             if ($set[0][1] > $offset) {
110 |                 $routeData[] = substr($route, $offset, $set[0][1] - $offset);
111 |             }
112 | 
113 |             if (in_array($set[1][0], $parsedVariableNames, true)) {
114 |                 throw BadRouteException::placeholderAlreadyDefined($set[1][0]);
115 |             }
116 | 
117 |             if (isset($set[2])) {
118 |                 $this->guardAgainstCapturingGroupUsage(trim($set[2][0]), $set[1][0]);
119 |             }
120 | 
121 |             $parsedVariableNames[] = $set[1][0];
122 | 
123 |             $routeData[] = [
124 |                 $set[1][0],
125 |                 isset($set[2]) ? trim($set[2][0]) : self::DEFAULT_DISPATCH_REGEX,
126 |             ];
127 | 
128 |             $offset = $set[0][1] + strlen($set[0][0]);
129 |         }
130 | 
131 |         if ($offset !== strlen($route)) {
132 |             $routeData[] = substr($route, $offset);
133 |         }
134 | 
135 |         return $routeData;
136 |     }
137 | 
138 |     private function guardAgainstCapturingGroupUsage(string $regex, string $variableName): void
139 |     {
140 |         // Needs to have at least a ( to contain a capturing group
141 |         if (! str_contains($regex, '(')) {
142 |             return;
143 |         }
144 | 
145 |         // Semi-accurate detection for capturing groups
146 |         if (preg_match(self::CAPTURING_GROUPS_REGEX, $regex) !== 1) {
147 |             return;
148 |         }
149 | 
150 |         throw BadRouteException::variableWithCaptureGroup($regex, $variableName);
151 |     }
152 | }
153 | 


--------------------------------------------------------------------------------
/src/functions.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace FastRoute;
 5 | 
 6 | use FastRoute\Cache\FileCache;
 7 | use LogicException;
 8 | 
 9 | use function function_exists;
10 | use function is_string;
11 | 
12 | if (! function_exists('FastRoute\simpleDispatcher')) {
13 |     /**
14 |      * @deprecated since v2.0 and will be removed in v3.0
15 |      *
16 |      * @see FastRoute::recommendedSettings()
17 |      * @see FastRoute::disableCache()
18 |      *
19 |      * @param callable(ConfigureRoutes):void                                                                                                                                                                                                                                                           $routeDefinitionCallback
20 |      * @param array{routeParser?: class-string<RouteParser>, dataGenerator?: class-string<DataGenerator>, dispatcher?: class-string<Dispatcher>, routeCollector?: class-string<ConfigureRoutes>, cacheDisabled?: bool, cacheKey?: string, cacheFile?: string, cacheDriver?: class-string<Cache>|Cache} $options
21 |      */
22 |     function simpleDispatcher(callable $routeDefinitionCallback, array $options = []): Dispatcher
23 |     {
24 |         return \FastRoute\cachedDispatcher(
25 |             $routeDefinitionCallback,
26 |             ['cacheDisabled' => true] + $options,
27 |         );
28 |     }
29 | 
30 |     /**
31 |      * @deprecated since v2.0 and will be removed in v3.0
32 |      *
33 |      * @see FastRoute::recommendedSettings()
34 |      *
35 |      * @param callable(ConfigureRoutes):void                                                                                                                                                                                                                                                           $routeDefinitionCallback
36 |      * @param array{routeParser?: class-string<RouteParser>, dataGenerator?: class-string<DataGenerator>, dispatcher?: class-string<Dispatcher>, routeCollector?: class-string<ConfigureRoutes>, cacheDisabled?: bool, cacheKey?: string, cacheFile?: string, cacheDriver?: class-string<Cache>|Cache} $options
37 |      */
38 |     function cachedDispatcher(callable $routeDefinitionCallback, array $options = []): Dispatcher
39 |     {
40 |         $options += [
41 |             'routeParser' => RouteParser\Std::class,
42 |             'dataGenerator' => DataGenerator\MarkBased::class,
43 |             'dispatcher' => Dispatcher\MarkBased::class,
44 |             'routeCollector' => RouteCollector::class,
45 |             'cacheDisabled' => false,
46 |             'cacheDriver' => FileCache::class,
47 |         ];
48 | 
49 |         $loader = static function () use ($routeDefinitionCallback, $options): array {
50 |             $routeCollector = new $options['routeCollector'](
51 |                 new $options['routeParser'](),
52 |                 new $options['dataGenerator']()
53 |             );
54 | 
55 |             $routeDefinitionCallback($routeCollector);
56 | 
57 |             return $routeCollector->processedRoutes();
58 |         };
59 | 
60 |         if ($options['cacheDisabled'] === true) {
61 |             return new $options['dispatcher']($loader());
62 |         }
63 | 
64 |         $cacheKey = $options['cacheKey'] ?? $options['cacheFile'] ?? null;
65 | 
66 |         if ($cacheKey === null) {
67 |             throw new LogicException('Must specify "cacheKey" option');
68 |         }
69 | 
70 |         $cache = $options['cacheDriver'];
71 | 
72 |         if (is_string($cache)) {
73 |             $cache = new $cache();
74 |         }
75 | 
76 |         return new $options['dispatcher']($cache->get($cacheKey, $loader));
77 |     }
78 | }
79 | 


--------------------------------------------------------------------------------