Laminas Router

https://github.com/laminas/laminas-router
Admin
Laminas Router provides flexible HTTP routing capabilities, supporting literal, segment, and regular...
Tokens:96,975
Snippets:832
Trust Score:9.7
License:BSD-3-Clause
Update:3 days ago
Show doc for...
Tokens:
Raw
### Constructor usage examples

Source: https://github.com/laminas/laminas-router

Shows how to instantiate a Method route for a single HTTP method (GET) and for multiple methods (GET, HEAD). The defaults array provides parameters on match.

```php
// Match GET requests
$route = new \Laminas\Router\Http\Method(
    'GET',
    ['controller' => 'API', 'format' => 'json']
);
```

```php
// Match multiple methods
$route = new \Laminas\Router\Http\Method(
    'GET, HEAD',
    ['controller' => 'API']
);
```

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

### match() usage example

Source: https://github.com/laminas/laminas-router

Example of using match() to get controller and action parameters from a matched route, with fallback when no route matches.

```php
$match = $stack->match($request);
if ($match) {
    $controller = $match->getParam('controller');
    $action = $match->getParam('action');
} else {
    // No route matched
}
```

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

### assemble() usage example

Source: https://github.com/laminas/laminas-router

Example of assembling a URL with route parameters and the required 'name' option.

```php
$url = $stack->assemble(['id' => 123], ['name' => 'user-detail']);
// Returns assembled URL
```

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

### Install laminas-router via Composer

Source: https://github.com/laminas/laminas-router/blob/3.20.x/README.md

Use this command to install the laminas-router library. It requires Composer to be available in your project environment.

```bash
composer require laminas/laminas-router
```

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

### match() usage example

Source: https://github.com/laminas/laminas-router

Example of creating a Method route with verb 'POST' and defaults, then matching a request. If matched, retrieves the 'action' parameter.

```php
$route = \Laminas\Router\Http\Method::factory([
    'verb' => 'POST',
    'defaults' => ['action' => 'create']
]);

$request = /* POST request */;
$match = $route->match($request);
if ($match) {
    $action = $match->getParam('action'); // 'create'
}
```

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

### match() example with Hostname::factory

Source: https://github.com/laminas/laminas-router

Example of creating a Hostname route with constraints and defaults, then matching a request. Returns HttpRouteMatch with extracted parameters or null if no match.

```php
$route = \Laminas\Router\Http\Hostname::factory([
    'route' => ':subdomain.example.com',
    'constraints' => ['subdomain' => '[a-z0-9]+'],
    'defaults' => ['module' => 'api']
]);

$request = /* request to api.example.com */;
$match = $route->match($request);

if ($match) {
    $subdomain = $match->getParam('subdomain'); // 'api'
    $module = $match->getParam('module');       // 'api'
}
```

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

### Constructor example

Source: https://github.com/laminas/laminas-router

Creates a RouteMatch instance with initial parameters.

```php
$params = ['controller' => 'Home', 'action' => 'index'];
$match = new \Laminas\Router\RouteMatch($params);
```

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

### assemble() example with Hostname::factory

Source: https://github.com/laminas/laminas-router

Example of creating a Hostname route and assembling a hostname with a parameter. Returns the assembled hostname string.

```php
$route = \Laminas\Router\Http\Hostname::factory([
    'route' => ':subdomain.example.com'
]);

$hostname = $route->assemble(['subdomain' => 'api']);
// Returns: 'api.example.com'
```

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

### assemble() usage examples

Source: https://github.com/laminas/laminas-router

Shows three assembly scenarios: simple assembly without parameters, assembly with parameters, and assembly with options like name and force_canonical. The examples demonstrate how to generate URLs for Literal and Segment routes.

```php
// Simple assembly
$route = \Laminas\Router\Http\Literal::factory(['route' => '/about']);
$url = $route->assemble();
// Returns: '/about'

// With parameters
$route = \Laminas\Router\Http\Segment::factory([
    'route' => '/user/:id'
]);
$url = $route->assemble(['id' => 42]);
// Returns: '/user/42'

// With options
$url = $route->assemble(['id' => 42], [
    'name' => 'user',
    'force_canonical' => true
]);
```

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

### SimpleRouteStack instantiation example

Source: https://github.com/laminas/laminas-router

Shows how to create a SimpleRouteStack instance, optionally passing a custom plugin manager.

```php
$stack = new \Laminas\Router\SimpleRouteStack();
// Or with custom plugin manager:
$stack = new \Laminas\Router\SimpleRouteStack($pluginManager);
```

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

### assemble() usage example

Source: https://github.com/laminas/laminas-router

Example of assembling a URL with the 'user-detail' route. Requires the 'name' option; throws InvalidArgumentException if missing and RuntimeException if route not found.

```php
$url = $stack->assemble(['id' => 42], ['name' => 'user-detail']);
```

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

### Hostname route instantiation example

Source: https://github.com/laminas/laminas-router

Example of creating a Hostname route with a subdomain pattern, regex constraint, and default controller.

```php
$route = new \Laminas\Router\Http\Hostname(
    ':subdomain.example.com',
    ['subdomain' => '[a-z0-9]+'],
    ['controller' => 'API']
);
```

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

### assemble() usage example

Source: https://github.com/laminas/laminas-router

Example of calling assemble() on a Method route. It returns an empty string because the HTTP method is not part of the URL path.

```php
$url = $route->assemble();
// Returns: ''
```

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

### Regex::factory() example

Source: https://github.com/laminas/laminas-router

Example of creating a Regex route using the factory method with regex, spec, and defaults options.

```php
$route = \Laminas\Router\Http\Regex::factory([
    'regex' => '/^\/product\/(?P<id>[0-9]+)$/',
    'spec' => '/product/%id%',
    'defaults' => ['controller' => 'Product', 'action' => 'view']
]);
```

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

### Segment::match() usage example

Source: https://github.com/laminas/laminas-router

Creates a route and matches a request. The example shows how to retrieve parameters from the match result, including defaults.

```php
$route = \Laminas\Router\Http\Segment::factory([
    'route' => '/user/:id/posts/:post_id',
    'constraints' => ['id' => '[0-9]+', 'post_id' => '[0-9]+'],
    'defaults' => ['controller' => 'Posts']
]);

$request = /* request for /user/42/posts/100 */;
$match = $route->match($request);

if ($match) {
    $params = $match->getParams();
    // $params['id'] = '42'
    // $params['post_id'] = '100'
    // $params['controller'] = 'Posts'
}
```

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

### Hostname factory usage example

Source: https://github.com/laminas/laminas-router

Example of using the factory method with route, constraints, and defaults options.

```php
$route = \Laminas\Router\Http\Hostname::factory([
    'route' => ':subdomain.example.com',
    'constraints' => [
        'subdomain' => '[a-z0-9]+'
    ],
    'defaults' => [
        'module' => 'api'
    ]
]);
```

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

### match() usage example

Source: https://github.com/laminas/laminas-router

Example of using match() for exact and partial matching. Without pathOffset, matches only if the path exactly equals the literal; with pathOffset, matches if the literal starts at the given offset. Returns HttpRouteMatch on success with default parameters.

```php
// Exact match
$request = /* HTTP request for /about */;
$match = $route->match($request);
if ($match) {
    echo $match->getParam('controller'); // 'About'
}

// Partial match with offset
$match = $route->match($request, 5); // Start matching at position 5
```

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

### match() usage example

Source: https://github.com/laminas/laminas-router

Example of calling match() on a route stack. Returns a RouteMatch object on success; use getMatchedRouteName() and getParams() to retrieve route details.

```php
$match = $stack->match($httpRequest);
if ($match) {
    $routeName = $match->getMatchedRouteName();
    $params = $match->getParams();
}
```

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

### assemble() usage example

Source: https://github.com/laminas/laminas-router

Example of using the assemble() method with a Scheme route. Creates a route for 'https' scheme and assembles a URI, changing its scheme to 'https'.

```php
$route = \Laminas\Router\Http\Scheme::factory(['scheme' => 'https']);

$uri = new \Laminas\Uri\Http('http://example.com/page');
$route->assemble([], ['uri' => $uri]);
// URI scheme is now set to 'https'
```

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

### assemble() example

Source: https://github.com/laminas/laminas-router

Example of assembling a URL from a Regex route. The assemble method substitutes the 'id' parameter into the spec, returning '/user/42'.

```php
$route = \Laminas\Router\Http\Regex::factory([
    'regex' => '/^\/user\/(?P<id>[0-9]+)$/',
    'spec' => '/user/%id%'
]);

$url = $route->assemble(['id' => 42]);
// Returns: '/user/42'
```

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

### match() usage example

Source: https://github.com/laminas/laminas-router

Example of using the match() method with a Scheme route. Creates a route for 'https' scheme and matches a request, retrieving the default controller parameter.

```php
$route = \Laminas\Router\Http\Scheme::factory([
    'scheme' => 'https',
    'defaults' => ['controller' => 'Secure']
]);

$request = /* HTTPS request */;
$match = $route->match($request);
if ($match) {
    $controller = $match->getParam('controller'); // 'Secure'
}
```

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

### Constructor usage example

Source: https://github.com/laminas/laminas-router

Creates Scheme routes for https and http schemes, setting default parameters 'secure' to true and false respectively.

```php
$httpsRoute = new \Laminas\Router\Http\Scheme('https', ['secure' => true]);
$httpRoute = new \Laminas\Router\Http\Scheme('http', ['secure' => false]);
```

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

### Factory usage example

Source: https://github.com/laminas/laminas-router

Creates a Method route using the factory with 'verb' set to 'POST' and defaults for controller and action.

```php
$route = \Laminas\Router\Http\Method::factory([
    'verb' => 'POST',
    'defaults' => ['controller' => 'API', 'action' => 'create']
]);
```

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

### Segment::assemble() usage example

Source: https://github.com/laminas/laminas-router

Assembles a URL from a route pattern and parameters. The example shows the expected output for given parameters.

```php
$route = \Laminas\Router\Http\Segment::factory([
    'route' => '/user/:id/posts/:post_id'
]);

$url = $route->assemble(['id' => 42, 'post_id' => 100]);
// Returns: '/user/42/posts/100'
```

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

### Simple example with two literal routes

Source: https://github.com/laminas/laminas-router/blob/3.20.x/docs/book/routing.md

Defines two literal routes, 'home' and 'contact', in a module configuration file. The 'home' route matches the root path '/' and the 'contact' route matches 'contact'. Each route specifies a controller and action as defaults.

```php
return [
    'router' => [
        'routes' => [
            // Literal route named "home"
            'home' => [
                'type' => 'literal',
                'options' => [
                    'route' => '/',
                    'defaults' => [
                        'controller' => 'Application\Controller\IndexController',
                        'action' => 'index',
                    ],
                ],
            ],
            // Literal route named "contact"
            'contact' => [
                'type' => 'literal',
                'options' => [
                    'route' => 'contact',
                    'defaults' => [
                        'controller' => 'Application\Controller\ContactController',
                        'action' => 'form',
                    ],
                ],
            ],
        ],
    ],
];
```

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

### match() example

Source: https://github.com/laminas/laminas-router

Example of matching a request to a Regex route and retrieving parameters. The request is for /user/42, and the match returns parameters 'id' and 'controller'.

```php
$route = \Laminas\Router\Http\Regex::factory([
    'regex' => '/^\/user\/(?P<id>[0-9]+)$/',
    'spec' => '/user/%id%',
    'defaults' => ['controller' => 'User']
]);

$request = /* request for /user/42 */;
$match = $route->match($request);

if ($match) {
    $id = $match->getParam('id'); // '42'
    $controller = $match->getParam('controller'); // 'User'
}
```

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

### match() usage examples

Source: https://github.com/laminas/laminas-router

Shows standard matching, tree-based matching with a path offset, and matching with options. The pathOffset allows continuation matching from the middle of a path.

```php
$route = /* HttpRouteInterface instance */;

// Standard match
$match = $route->match($httpRequest);

// Tree-based match with offset
$match = $route->match($httpRequest, 5);

// With options
$match = $route->match($httpRequest, null, ['some' => 'option']);
```

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

### Route Matching Example with Priorities

Source: https://github.com/laminas/laminas-router

Adds routes with explicit priorities and demonstrates the matching order: highest priority first, returning the first successful match or null.

```php
// Given routes in stack:
// 1. 'specific' with priority 100
// 2. 'generic' with priority 50
// 3. 'catch-all' with priority 10

$stack->addRoute('specific', $route, 100);
$stack->addRoute('generic', $route, 50);
$stack->addRoute('catch-all', $route, 10);

// When matching:
// 1. Try 'specific' route
// 2. If no match, try 'generic' route
// 3. If no match, try 'catch-all' route
// 4. Return first successful match or null
```

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

### getParams() example

Source: https://github.com/laminas/laminas-router

Retrieves all matched parameters as an array.

```php
$allParams = $match->getParams();
// Returns: ['controller' => 'Home', 'action' => 'index']
```

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

### addRoute() usage examples

Source: https://github.com/laminas/laminas-router

Shows adding routes with a Literal instance, an array specification, and chaining with priority. Route names must be unique. Higher priority routes are matched first. Throws InvalidArgumentException for invalid specifications.

```php
$stack->addRoute('home', new \Laminas\Router\Http\Literal(
    ['route' => '/'],
    ['controller' => 'Home']
));

// Or with array specification
$stack->addRoute('about', [
    'type' => 'Literal',
    'options' => ['route' => '/about']
]);

// With priority
$stack->addRoute('specific', $specificRoute, 100)
      ->addRoute('generic', $genericRoute, 10);
```

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

### setParam() example

Source: https://github.com/laminas/laminas-router

Sets multiple parameters on a RouteMatch instance.

```php
$match->setParam('page', 2);
$match->setParam('limit', 10);
```

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

### match() usage example

Source: https://github.com/laminas/laminas-router

Creates a Literal route for the home page and matches an HTTP request. On success, retrieves controller and action parameters from the RouteMatch object; otherwise handles the no-match case.

```php
$route = \Laminas\Router\Http\Literal::factory([
    'route' => '/',
    'defaults' => ['controller' => 'Home', 'action' => 'index']
]);

$match = $route->match($httpRequest);
if ($match) {
    $controller = $match->getParam('controller'); // 'Home'
    $action = $match->getParam('action');         // 'index'
} else {
    // No match
}
```

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

### assemble() usage example

Source: https://github.com/laminas/laminas-router

Generates a URL using parameters and options.

```php
$url = $route->assemble(['id' => 42], ['name' => 'route']);
```

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

### Route factory exception handling example

Source: https://github.com/laminas/laminas-router

Shows how a route factory should throw InvalidArgumentException for bad configuration and RuntimeException for runtime errors. The example checks for a missing 'route' option and wraps buildRoute() failures in a RuntimeException with the original exception as the previous exception.

```php
public static function factory($options = [])
{
    if (!isset($options['route'])) {
        throw new \Laminas\Router\Exception\InvalidArgumentException(
            'Missing "route" in options'
        );
    }

    try {
        $route = $this->buildRoute($options);
    } catch (\Exception $e) {
        throw new \Laminas\Router\Exception\RuntimeException(
            'Failed to build route: ' . $e->getMessage(),
            0,
            $e
        );
    }

    return $route;
}
```

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

### Factory usage example

Source: https://github.com/laminas/laminas-router

Creates a Scheme route using the factory method with 'scheme' and 'defaults' options. Throws InvalidArgumentException if 'scheme' is missing.

```php
$route = \Laminas\Router\Http\Scheme::factory([
    'scheme' => 'https',
    'defaults' => ['secure' => true]
]);
```

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

### match() example - matching an HTTP request

Source: https://github.com/laminas/laminas-router

Attempts to match an HTTP request against the routes. If a match is found, retrieves the matched parameters and route name from the RouteMatch object. Returns null if no route matched.

```php
$match = $router->match($httpRequest);
if ($match) {
    $params = $match->getParams();
    $routeName = $match->getMatchedRouteName();
}
```

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

### getParam() example

Source: https://github.com/laminas/laminas-router

Retrieves a parameter value and a default for a missing parameter.

```php
$controller = $match->getParam('controller');
$nonexistent = $match->getParam('nonexistent', 'default-value');
// Returns 'default-value'
```

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

### Complex example with child routes

Source: https://github.com/laminas/laminas-router/blob/3.20.x/docs/book/routing.md

Defines a 'blog' literal route with child routes 'post' (segment) and 'rss' (literal). The 'may_terminate' flag allows the parent route to match alone. Child routes are named using the 'parent/child' pattern.

```php
return [
    'router' => [
        'routes' => [
            // Literal route named "home"
            'home' => [
                'type' => 'literal',
                'options' => [
                    'route' => '/',
                    'defaults' => [
                        'controller' => 'Application\Controller\IndexController',
                        'action' => 'index',
                    ],
                ],
            ],
            // Literal route named "blog", with child routes
            'blog' => [
                'type' => 'literal',
                'options' => [
                    'route' => '/blog',
                    'defaults' => [
                        'controller' => 'Application\Controller\BlogController',
                        'action' => 'index',
                    ],
                ],
                'may_terminate' => true,
                'child_routes' => [
                    // Segment route for viewing one blog post
                    'post' => [
                        'type' => 'segment',
                        'options' => [
                            'route' => '/[:slug]',
                            'constraints' => [
                                'slug' => '[a-zA-Z0-9_-]+',
                            ],
                            'defaults' => [
                                'action' => 'view',
                            ],
                        ],
                    ],
                    // Literal route for viewing blog RSS feed
                    'rss' => [
                        'type' => 'literal',
                        'options' => [
                            'route' => '/rss',
                            'defaults' => [
                                'action' => 'rss',
                            ],
                        ],
                    ],
                ],
            ],
        ],
    ],
];
```

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

### Literal and Segment route factory examples

Source: https://github.com/laminas/laminas-router

Shows how to create Literal and Segment route instances using the factory method with configuration arrays. The Literal route uses a static path, while the Segment route uses a pattern with constraints.

```php
// Literal route factory
$route = \Laminas\Router\Http\Literal::factory([
    'route' => '/about',
    'defaults' => ['controller' => 'About']
]);

// Segment route factory
$route = \Laminas\Router\Http\Segment::factory([
    'route' => '/user/:id',
    'constraints' => ['id' => '[0-9]+'],
    'defaults' => ['controller' => 'User']
]);
```

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

### addPrototypes() example - adding multiple prototype routes

Source: https://github.com/laminas/laminas-router

Adds multiple named prototype routes at once. This method is deprecated because prototype routes were removed in v4.0. The example defines a 'standard' prototype using a Segment route with a '/:controller/:action' pattern.

```php
$router->addPrototypes([
    'standard' => [
        'type' => 'Segment',
        'options' => ['route' => '/:controller/:action']
    ]
]);
```

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

### addRoutes() usage examples

Source: https://github.com/laminas/laminas-router

Shows adding multiple routes via an array specification and chaining multiple addRoutes() calls. Iterates routes and calls addRoute() for each, preserving priority information.

```php
$stack->addRoutes([
    'home' => [
        'type' => 'Literal',
        'options' => ['route' => '/']
    ],
    'about' => [
        'type' => 'Literal',
        'options' => ['route' => '/about']
    ],
    'contact' => [
        'type' => 'Literal',
        'options' => ['route' => '/contact']
    ]
]);

// Can chain
$stack->addRoutes($routes1)
      ->addRoutes($routes2)
      ->addRoutes($routes3);
```

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

### assemble() example - assembling a URL with and without URI object

Source: https://github.com/laminas/laminas-router

Assembles a URL from route parameters. The first call uses the 'name' option to specify the route. The second call includes a URI object to modify with assembled parts, using the 'uri' option.

```php
$url = $router->assemble(['id' => 42], ['name' => 'user-detail']);

// With URI object:
$uri = new \Laminas\Uri\Http('http://example.com');
$router->assemble(['page' => 2], [
    'name' => 'products',
    'uri' => $uri
]);
```

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

### setBaseUrl() example - setting the base URL

Source: https://github.com/laminas/laminas-router

Sets the base URL path for the application. The method returns self for chaining.

```php
$router->setBaseUrl('/app');
```

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

### Part::assemble() example with route name

Source: https://github.com/laminas/laminas-router

Assembles a URL for a Part route using parameters and a route name. Returns the assembled URL string.

```php
$url = $part->assemble(['id' => 42, 'post_id' => 100], 
    ['name' => 'user/posts']);
// Returns: '/user/42/posts/100'
```

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

### setRoutes() usage example

Source: https://github.com/laminas/laminas-router

Shows replacing all routes with a new set. Clears all existing routes first, then adds the provided ones. Equivalent to clear() followed by addRoutes().

```php
$stack->setRoutes([
    'new-route-1' => [...],
    'new-route-2' => [...],
]);
```

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

### Parameter Constraints Example

Source: https://github.com/laminas/laminas-router

Defines regex patterns for parameters to validate format during matching and enable more specific route matching.

```php
$constraints = [
    'id' => '[0-9]+',              // Digits only
    'slug' => '[a-z0-9-]+',       // Alphanumeric and hyphens
    'version' => 'v?[0-9]+\.[0-9]+', // v1.0, 1.0, etc.
];
```

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

### Part route instantiation example

Source: https://github.com/laminas/laminas-router

Creates a Part route with a Segment base route '/admin' that may terminate, and a Literal child route '/users'.

```php
$routePlugins = new \Laminas\Router\RoutePluginManager();
$part = new \Laminas\Router\Http\Part(
    ['type' => 'Segment', 'options' => ['route' => '/admin']],
    true, // mayTerminate - /admin alone is valid
    $routePlugins,
    ['list' => ['type' => 'Literal', 'options' => ['route' => '/users']]]
);
```

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

### Part::factory() example with child routes

Source: https://github.com/laminas/laminas-router

Creates a Part route with a Segment base route and a Literal child route. Demonstrates required 'route' and 'route_plugins' options and optional 'may_terminate' and 'child_routes'.

```php
$part = \Laminas\Router\Http\Part::factory([
    'route' => [
        'type' => 'Segment',
        'options' => ['route' => '/admin/:page']
    ],
    'route_plugins' => $routePlugins,
    'may_terminate' => true,
    'child_routes' => [
        'dashboard' => [
            'type' => 'Literal',
            'options' => ['route' => '/dashboard']
        ]
    ]
]);
```

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

### Segment::factory() usage example

Source: https://github.com/laminas/laminas-router

Creates a Segment route with a pattern, constraints, and defaults. The 'route' option is required; constraints and defaults are optional.

```php
$route = \Laminas\Router\Http\Segment::factory([
    'route' => '/products/:id',
    'constraints' => [
        'id' => '[0-9]+'
    ],
    'defaults' => [
        'controller' => 'Products',
        'action' => 'view'
    ]
]);
```

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

### getBaseUrl() example - retrieving the base URL

Source: https://github.com/laminas/laminas-router

Retrieves the configured base URL and assigns it to the $baseUrl variable.

```php
$baseUrl = $router->getBaseUrl();
```

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

### Part::match() example with child route

Source: https://github.com/laminas/laminas-router

Matches a request against a Part route with a Segment base route and a Segment child route. Shows how to retrieve parameters and matched route name.

```php
$part = \Laminas\Router\Http\Part::factory([
    'route' => ['type' => 'Segment', 'options' => ['route' => '/user/:id']],
    'route_plugins' => $routePlugins,
    'may_terminate' => true,
    'child_routes' => [
        'posts' => [
            'type' => 'Segment',
            'options' => ['route' => '/posts/:post_id']
        ]
    ]
]);

$request = /* request for /user/42/posts/100 */;
$match = $part->match($request);

if ($match) {
    $id = $match->getParam('id');           // '42'
    $postId = $match->getParam('post_id');  // '100'
    $routeName = $match->getMatchedRouteName(); // 'user/posts'
}
```

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

### Segment route configuration with constraints and defaults

Source: https://github.com/laminas/laminas-router/blob/3.20.x/docs/book/routing.md

Configures a Segment route matching '/:controller[/:action]' with regex constraints and default values. The example shows two ways to build the route: the deprecated Segment::factory() (before 3.20.0) and the recommended $routeBuilderContainer->build() (since 3.20.0).

```php
$options = [
    'type' => Segment::class,
    'route' => '/:controller[/:action]',
    'constraints' => [
        'controller' => '[a-zA-Z][a-zA-Z0-9_-]+',
        'action'     => '[a-zA-Z][a-zA-Z0-9_-]+',
    ],
    'defaults' => [
        'controller' => 'Application\Controller\IndexController',
        'action'     => 'index',
    ],
];

// Deprecated since 3.20.0:
$route = Segment::factory($options);

// Since 3.20.0:
$route = $routeBuilderContainer->build($options);
```

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

### assemble() usage example

Source: https://github.com/laminas/laminas-router

Example of using assemble() to get the literal route string. Parameters are ignored for literal routes, so passing parameters has no effect.

```php
$url = $route->assemble();
echo $url; // '/about'

// Parameters are ignored for literal routes
$url = $route->assemble(['id' => 123]);
echo $url; // '/about' (parameters have no effect)
```

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

### Part route configuration with child routes

Source: https://github.com/laminas/laminas-router/blob/3.20.x/docs/book/routing.md

Defines a Part route with a literal root route and nested child routes for blog, rss, subrss, and forum. The route matches paths like /, /blog, /blog/rss, /blog/rss/sub, and /forum. The example shows both deprecated Part::factory() and the recommended RouteBuilderContainer build method.

```php
$options = [
    'type' => Part::class,
    'route' => [
        'type' => 'literal',
        'options' => [
            'route' => '/',
            'defaults' => [
                'controller' => 'Application\Controller\IndexController',
                'action' => 'index',
            ],
        ],
    ],
    'route_plugins' => $routePlugins,
    'may_terminate' => true,
    'child_routes' => [
        'blog' => [
            'type' => 'literal',
            'options' => [
                'route' => '/blog',
                'defaults' => [
                    'controller' => 'Application\Controller\BlogController',
                    'action' => 'index',
                ],
            ],
            'may_terminate' => true,
            'child_routes' => [
                'rss' => [
                    'type' => 'literal',
                    'options' => [
                        'route' => '/rss',
                        'defaults' => [
                            'action' => 'rss',
                        ]
                    ],
                    'may_terminate' => true,
                    'child_routes' => [
                        'subrss' => [
                            'type' => 'literal',
                            'options' => [
                                'route' => '/sub',
                                'defaults' => [
                                    'action' => 'subrss',
                                ],
                            ],
                        ],
                    ],
                ],
            ],
        ],
        'forum' => [
            'type' => 'literal',
            'options' => [
                'route' => 'forum',
                'defaults' => [
                    'controller' => 'Application\Controller\ForumController',
                    'action' => 'index',
                ],
            ],
        ],
    ],
];

// Deprecated since 3.20.0:
$route = Part::factory($options);

// Since 3.20.0:
$route = $routeBuilderContainer->build($options);
```

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

### Router configuration with Literal, Segment, and Part routes

Source: https://github.com/laminas/laminas-router

Example application configuration for laminas-router defining routes in the 'router' key. Includes a Literal route for the home page, a Segment route with constraints for user actions and IDs, and a hierarchical Part route for admin with nested child routes.

```php
'router' => [
    'routes' => [
        // Simple literal route
        'home' => [
            'type' => 'Literal',
            'options' => [
                'route' => '/',
                'defaults' => [
                    'controller' => 'Application\Controller\IndexController',
                    'action' => 'index'
                ]
            ]
        ],
        
        // Segment with constraints
        'user' => [
            'type' => 'Segment',
            'options' => [
                'route' => '/user[/:action[/:id]]',
                'constraints' => [
                    'action' => '[a-z]+',
                    'id' => '[0-9]+'
                ],
                'defaults' => [
                    'controller' => 'User'
                ]
            ]
        ],
        
        // Hierarchical Part route
        'admin' => [
            'type' => 'Part',
            'options' => [
                'route' => [
                    'type' => 'Literal',
                    'options' => ['route' => '/admin']
                ],
                'may_terminate' => true,
                'defaults' => ['controller' => 'Admin\Dashboard']
            ],
            'child_routes' => [
                'users' => [
                    'type' => 'Part',
                    'options' => [
                        'route' => [
                            'type' => 'Literal',
                            'options' => ['route' => '/users']
                        ],
                        'may_terminate' => true,
                        'defaults' => ['action' => 'list']
                    ],
                    'child_routes' => [
                        'edit' => [
                            'type' => 'Segment',
                            'options' => [
                                'route' => '/:id/edit',
                                'constraints' => ['id' => '[0-9]+'],
                                'defaults' => ['action' => 'edit']
                            ]
                        ]
                    ]
                ]
            ]
        ]
    ]
]
```

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

### Basic HTTP Routing with TreeRouteStack

Source: https://github.com/laminas/laminas-router

Creates a router using Laminas\Router\Http\TreeRouteStack with a RoutePluginManager, defines Literal and Segment routes, matches a request, and assembles a URL. The assemble call returns '/user/42' for the 'user' route with id 42.

```php
use Laminas\Router\Http\TreeRouteStack;
use Laminas\Router\RoutePluginManager;

// Create router
$routePlugins = new RoutePluginManager($container);
$router = TreeRouteStack::factory([
    'route_plugins' => $routePlugins,
    'routes' => [
        'home' => [
            'type' => 'Literal',
            'options' => [
                'route' => '/',
                'defaults' => [
                    'controller' => 'Home',
                    'action' => 'index'
                ]
            ]
        ],
        'user' => [
            'type' => 'Segment',
            'options' => [
                'route' => '/user/:id',
                'constraints' => ['id' => '[0-9]+'],
                'defaults' => ['controller' => 'User']
            ]
        ]
    ]
]);

// Match request
$match = $router->match($httpRequest);
if ($match) {
    $controller = $match->getParam('controller');
    $action = $match->getParam('action');
}

// Assemble URL
$url = $router->assemble(['id' => 42], ['name' => 'user']);
// Returns: /user/42
```

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

### SimpleRouteStack::__construct

Source: https://github.com/laminas/laminas-router

Initializes the route stack with an optional route plugin manager.

```APIDOC
## SimpleRouteStack::__construct

### Description
Initializes the route stack with an optional route plugin manager.

### Method
`public function __construct(?RoutePluginManager $routePluginManager = null)`

### Parameters
- **routePluginManager** (RoutePluginManager|null) - Optional - Plugin manager for creating route instances

### Request Example
```php
$stack = new \Laminas\Router\SimpleRouteStack();
// Or with custom plugin manager:
$stack = new \Laminas\Router\SimpleRouteStack($pluginManager);
```
```

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

### Form Handling with GET and POST Method routes

Source: https://github.com/laminas/laminas-router

Defines a Literal route for /contact with child Method routes for GET (form) and POST (submit) actions. Method routes are typically used as child routes combined with path-based routes like Segment or Literal.

```php
'contact' => [
    'type' => 'Literal',
    'options' => [
        'route' => '/contact',
        'defaults' => ['controller' => 'Contact']
    ],
    'child_routes' => [
        'form' => [
            'type' => 'Method',
            'options' => ['verb' => 'GET', 'defaults' => ['action' => 'form']]
        ],
        'submit' => [
            'type' => 'Method',
            'options' => ['verb' => 'POST', 'defaults' => ['action' => 'submit']]
        ]
    ]
]
```

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

### match() method signature

Source: https://github.com/laminas/laminas-router

Attempts to match the request against routes in priority order. Returns RouteMatch|null - match result or null if no route matched.

```php
public function match(RequestInterface $request): ?RouteMatch
```

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

### getMatchedRouteName() example

Source: https://github.com/laminas/laminas-router

Retrieves and echoes the matched route name.

```php
$routeName = $match->getMatchedRouteName();
echo $routeName; // 'user-detail'
```

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

### Using RouteMatch parameters

Source: https://github.com/laminas/laminas-router/blob/3.20.x/docs/book/routing.md

Shows how to retrieve a parameter from a RouteMatch object, with a fallback default and error handling if missing.

```php
$id = $routeMatch->getParam('id', false);
if (! $id) {
    throw new Exception('Required identifier is missing!');
}
$entity = $resource->get($id);
```

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

### setMatchedRouteName() example

Source: https://github.com/laminas/laminas-router

Sets the matched route name on a RouteMatch instance.

```php
$match = new \Laminas\Router\RouteMatch(['id' => 123]);
$match->setMatchedRouteName('user-detail');
```

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

### SimpleRouteStack::factory() usage

Source: https://github.com/laminas/laminas-router

Creates a new SimpleRouteStack instance with configuration options. The options array can include 'routes' to add initial routes. Throws Exception\InvalidArgumentException if options is not an array or Traversable.

```php
$stack = \Laminas\Router\SimpleRouteStack::factory([
    'routes' => [
        'home' => [
            'type' => 'Literal',
            'options' => [
                'route' => '/',
                'defaults' => ['controller' => 'Home', 'action' => 'index']
            ]
        ]
    ]
]);
```

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

### Translatable Literals Example

Source: https://github.com/laminas/laminas-router

Use braces for translatable text. The text 'page-title' can be translated.

```php
'/user/{page-title}/:id'
// The text 'page-title' can be translated
```

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

### Catching RuntimeException on assemble

Source: https://github.com/laminas/laminas-router

Example of catching Laminas\Router\Exception\RuntimeException when assembling a route with a non-existent name.

```php
try {
    $router->assemble(['id' => 123], ['name' => 'nonexistent']);
} catch (\Laminas\Router\Exception\RuntimeException $e) {
    // Route not found
}
```

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

### assemble()

Source: https://github.com/laminas/laminas-router

Assembles a URL from route parameters. Requires the 'name' option to specify which route to assemble.

```APIDOC
## assemble()

### Description
Assembles a URL from route parameters. Requires the 'name' option to specify which route to assemble.

### Method
assemble

### Signature
```php
public function assemble(array $params = [], array $options = []): string
```

### Parameters
- **params** (array) - Optional - URL parameters
- **options** (array) - Optional - Assembly options

#### Options
- **name** (string) - Required - Name of the route to assemble

### Return
string - The assembled URL

### Throws
- Exception\InvalidArgumentException - if 'name' option is missing
- Exception\RuntimeException - if named route not found

### Request Example
```php
$url = $stack->assemble(['id' => 123], ['name' => 'user-detail']);
// Returns assembled URL
```
```

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

### Custom Delimiters Example

Source: https://github.com/laminas/laminas-router

Specify delimiters for parameters. The delimiter ':version{-}' stops at hyphen, matching /api/v1-users.

```php
'/api/:version-:resource'
// Matches: /api/v1-users
// With delimiters: ':version{-}' stops at hyphen
```

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

### Method::factory

Source: https://github.com/laminas/laminas-router

Creates a Method route from configuration options. The factory method requires a 'verb' option and throws an exception if it is missing.

```APIDOC
## Method::factory

### Description
Creates a Method route from configuration options.

### Signature
```php
public static function factory($options = []): self
```

### Parameters
- **options** (array|Traversable) - Required - Configuration options

### Required Options
- **verb** (string) - HTTP method(s) to match

### Optional Options
- **defaults** (array) - Default parameters

### Return
self

### Throws
Exception\InvalidArgumentException - if 'verb' is missing

### Request Example
```php
$route = \Laminas\Router\Http\Method::factory([
    'verb' => 'POST',
    'defaults' => ['controller' => 'API', 'action' => 'create']
]);
```
```

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

### Method::__construct

Source: https://github.com/laminas/laminas-router

Creates a new Method route that matches specific HTTP verbs. The constructor accepts a verb string (comma-separated for multiple methods) and optional default parameters.

```APIDOC
## Method::__construct

### Description
Creates a new Method route that matches specific HTTP verbs.

### Signature
```php
public function __construct(string $verb, array $defaults = [])
```

### Parameters
- **verb** (string) - Required - HTTP method(s) to match (comma-separated)
- **defaults** (array) - Optional - Default parameters on match

### Supported HTTP Methods
GET, HEAD, POST, PUT, DELETE, OPTIONS, PATCH, TRACE, CONNECT, PROPFIND, PROPPATCH, MKCOL, COPY, MOVE, LOCK, UNLOCK

### Request Example
```php
// Match GET requests
$route = new \Laminas\Router\Http\Method(
    'GET',
    ['controller' => 'API', 'format' => 'json']
);

// Match multiple methods
$route = new \Laminas\Router\Http\Method(
    'GET, HEAD',
    ['controller' => 'API']
);
```
```

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

### Composer require laminas/laminas-mvc-console

Source: https://github.com/laminas/laminas-router/blob/3.20.x/docs/book/migration/v2-to-v3.md

Install the laminas-mvc-console package to replace the removed console routing functionality in laminas-router v3.

```bash
$ composer require laminas/laminas-mvc-console
```

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

### removeRoute() usage examples

Source: https://github.com/laminas/laminas-router

Shows removing a single route and chaining multiple removals. Does not throw an exception if the route is not found.

```php
$stack->removeRoute('deprecated-route');

// Can chain
$stack->removeRoute('old-route1')
      ->removeRoute('old-route2');
```

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

### match()

Source: https://github.com/laminas/laminas-router

Attempts to match the request against routes in priority order. Returns a RouteMatch object if a route matches, or null otherwise.

```APIDOC
## match()

### Description
Attempts to match the request against routes in priority order. Returns a RouteMatch object if a route matches, or null otherwise.

### Method
match

### Signature
```php
public function match(RequestInterface $request): ?RouteMatch
```

### Parameters
- **request** (RequestInterface) - Required - The request to match

### Return
RouteMatch|null - Match result or null if no route matched

### Request Example
```php
$match = $stack->match($request);
if ($match) {
    $controller = $match->getParam('controller');
    $action = $match->getParam('action');
} else {
    // No route matched
}
```
```

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

### factory()

Source: https://github.com/laminas/laminas-router

Creates a route stack instance from configuration. Accepts routes, a plugin manager, and default parameters.

```APIDOC
## factory()

### Description
Creates a route stack instance from configuration.

### Method
factory

### Signature
```php
public static function factory($options = []): static
```

### Parameters
#### Factory Options
- **routes** (array) - Optional - Routes to add.
- **route_plugins** (RoutePluginManager) - Optional - Plugin manager for route creation.
- **default_params** (array) - Optional - Default parameters.

### Return
static - A new route stack instance.
```

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

### getAssembledParams() usage example

Source: https://github.com/laminas/laminas-router

Shows how to retrieve the parameters used in the last assemble() call. This method is deprecated and not forward-compatible; avoid using it in new code.

```php
$route->assemble(['id' => 42], ['name' => 'user']);
$params = $route->getAssembledParams();
// May return assembled parameters in some implementations
```

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

### assemble

Source: https://github.com/laminas/laminas-router

Assembles a URL from the given parameters and options. Returns the generated URL string.

```APIDOC
## assemble

### Description
Assembles a URL from the given parameters and options.

### Method
assemble

### Signature
public function assemble(array $params = [], array $options = []): string

### Parameters
- **params** (array) - Optional - Parameters for route assembly
- **options** (array) - Optional - Assembly options

### Return
- **string** - The assembled URL
```

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

### Constructor signature

Source: https://github.com/laminas/laminas-router

Creates a new Method route that matches specific HTTP verbs. The verb parameter is required and can be comma-separated for multiple methods; defaults are optional.

```php
public function __construct(string $verb, array $defaults = [])
```

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

### SimpleRouteStack Factory Options Configuration

Source: https://github.com/laminas/laminas-router

Configuration array for SimpleRouteStack factory options, including routes, optional route_plugins, and optional default_params. The 'routes' key holds route definitions, 'route_plugins' is an optional RoutePluginManager, and 'default_params' merges parameters into all matches.

```php
[
    'routes' => [
        // Array of route definitions
        'home' => [
            'type' => 'Literal',
            'options' => [...]
        ]
    ],
    'route_plugins' => ?RoutePluginManager,  // Optional
    'default_params' => [                    // Optional
        'module' => 'application',
        'controller' => 'Index'
    ]
]
```

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

### SimpleRouteStack::factory

Source: https://github.com/laminas/laminas-router

Creates a new SimpleRouteStack instance from configuration options.

```APIDOC
## SimpleRouteStack::factory

### Description
Creates a new SimpleRouteStack instance from configuration options.

### Method
`public static function factory($options = []): self`

### Parameters
- **options** (array) - Optional - Configuration options for the route stack.
```
Tokens:
Raw