Documentation

Cli extends AbstractMatch
in package

Pop router CLI match class

Tags
category

Pop

author

Nick Sagona, III nick@popphp.org

copyright

Copyright (c) 2009-2026 Nick Sagona, III

license

https://www.popphp.org/license New BSD License

version
5.0.0

Table of Contents

Properties

$commands  : array<string|int, mixed>
Route commands
$defaultRoute  : array<string|int, mixed>|null
Default route
$dispatchableCache  : mixed
Cached dispatchable resolution for the current match cycle
$dispatchableParams  : array<string|int, mixed>
Dispatchable parameters
$dispatchableResolved  : bool
Whether the dispatchable has been resolved for the current match cycle
$dynamicRoute  : mixed
Dynamic route
$dynamicRouteActionIndex  : int|null
Position of the ':action'/'<action>' token within the dynamic route declaration
$dynamicRouteControllerIndex  : int|null
Position of the ':controller'/'<controller>' token within the dynamic route declaration
$dynamicRouteLiterals  : array<string|int, mixed>
Literal segments of the dynamic route declaration, keyed by their position within that declaration
$dynamicRoutePrefix  : mixed
Dynamic route prefix
$hasAllRequired  : bool
Flag for all required parameters
$isDynamicRoute  : bool
Flag for dynamic route
$options  : array<string|int, mixed>
Allowed route options
$parameters  : array<string|int, mixed>
Allowed route parameters
$preparedRoutes  : array<string|int, mixed>
Prepared routes
$route  : string|null
Matched route
$routeNames  : array<string|int, mixed>
Route names
$routeParams  : array<string|int, mixed>
Route parameters
$routes  : array<string|int, mixed>
Routes
$routeSpecificity  : array<string|int, mixed>
Specificity score per prepared route, keyed the same as preparedRoutes
$routeString  : string|null
Route string
$segments  : array<string|int, mixed>
Segments of route string

Methods

__construct()  : mixed
Constructor
addDispatchableParams()  : AbstractMatch
Add dispatchable params to be passed into a new dispatchable instance
addRoute()  : AbstractMatch
Add a route
addRoutes()  : AbstractMatch
Add multiple controller routes
appendDispatchableParams()  : AbstractMatch
Append dispatchable params to be passed into a new dispatchable instance
getAction()  : mixed
Get the action
getCommandOptions()  : array<string|int, mixed>
Get the command options
getCommandParameters()  : array<string|int, mixed>
Get the command parameters
getCommands()  : array<string|int, mixed>
Get the route commands
getDefaultRoute()  : array<string|int, mixed>
Get the default route
getDispatchable()  : mixed
Get the dispatchable
getDispatchableParams()  : mixed
Get the params assigned to the dispatchable
getDynamicRoute()  : mixed
Get the dynamic route
getDynamicRoutePrefix()  : mixed
Get the dynamic route prefix
getFlattenedRoutes()  : array<string|int, mixed>
Get flattened routes
getOption()  : mixed
Get a parsed route option
getOptions()  : array<string|int, mixed>
Get the parsed route options
getOriginalRoute()  : string|null
Get original route string
getParameter()  : mixed
Get a parsed route param
getParameters()  : array<string|int, mixed>
Get the parsed route params
getPreparedRoutes()  : array<string|int, mixed>
Get prepared routes
getRoute()  : string
Get route regex
getRouteConfig()  : mixed
Get route config
getRouteParams()  : array<string|int, mixed>
Get the params discovered from the route
getRoutes()  : array<string|int, mixed>
Get routes
getRouteString()  : string
Get the route string
getSegment()  : string|null
Get a route string segment
getSegments()  : array<string|int, mixed>
Get the route string segments
hasAction()  : bool
Determine if there is an action
hasDefaultRoute()  : bool
Determine if there is a default route
hasDispatchable()  : bool
Determine if there is a dispatchable
hasDispatchableParams()  : bool
Determine if the dispatchable has params
hasDynamicRoute()  : bool
Determine if there is a dynamic route
hasName()  : bool
Has a route name
hasRoute()  : bool
Determine if the route has been matched
hasRouteConfig()  : bool
Has route config
hasRouteParams()  : bool
Determine if the route has params
isDynamicRoute()  : bool
Determine if it is a dynamic route
match()  : bool
Match the route
name()  : AbstractMatch
Add a route name
noRouteFound()  : void
Method to process if a route was not found
prepare()  : static
Prepare the routes
removeDispatchableParams()  : AbstractMatch
Remove dispatchable params
buildOptionValueRegex()  : string
Build the value-matching regex fragment shared by option-value and option-value-array matches
extractRouteCommandsRegex()  : string
Extract the leading command-segment regex fragment from a route string, seeding $this->commands[$route] along the way
flattenRoutes()  : void
Flatten the nested routes
getDynamicRouteParamOffset()  : int
Get the segment offset at which the dynamic route's params start, i.e. the segment right after the action token
getRouteRegex()  : array<string|int, mixed>
Get the REGEX pattern for the route string
indexRouteOptions()  : void
Index the [-o]/[--option] flag matches for a route
indexRouteOptionValueArrays()  : void
Index the [--option=*]-style array-value-option matches for a route
indexRouteOptionValues()  : void
Index the [--option=]-style value-option matches for a route
indexRouteParameters()  : void
Index the <param>/[<param>] required and optional parameter positions for a route
isDynamicRouteDeclaration()  : bool
Determine if a route declaration is the dynamic-route (":controller"/"<controller") pattern
isDynamicRouteLiteral()  : bool
Determine if a dynamic route declaration token is a literal segment, i.e. neither a param token nor an option
matchesDynamicRoute()  : bool
Determine if the current request matches the dynamic route declaration: every literal segment of the declaration has to line up with the request's segment in that same position, and the request has to carry a segment where the declaration puts its controller token
normalizeController()  : mixed
Normalize a raw dispatchable value (closure, native callable, or a pop-utils pseudo-callable string such as 'Class->method', 'Class::method', 'Class', or 'new Class') into a ['controller' => $controller] config array. Already-formed config arrays (and nested-route sub-arrays) are returned unchanged.
parseDynamicRoute()  : void
Parse a dynamic route declaration, recording where its ':controller'/':action' (HTTP) or '<controller>'/'<action>' (CLI) tokens sit within the declaration, along with any literal segments the request has to match for the route to apply
parseOptionFlags()  : array<string|int, mixed>
Parse [-o]/[--option] boolean flags present in the route string
parseOptionValueArrays()  : array<string|int, mixed>
Parse [--option=*]-style array-value options present in the route string
parseOptionValues()  : array<string|int, mixed>
Parse [--option=]-style value options present in the route string
parsePositionalParameters()  : void
Match remaining route segments (after commands/options are filtered out) positionally against the route's required/optional parameters
parseRouteParams()  : void
Parse route dispatch parameters
registerDynamicRoute()  : void
Register a dynamic route
registerRegularRoute()  : mixed
Register a regular (literal or param-bearing) route, recursing for nested route configs
registerWildcardRoute()  : mixed
Register a wildcard/default route
seed()  : void
Seed the parsing inputs (segments and route string) from either pre-split argv-style segments or a raw command string

Properties

$commands

Route commands

protected array<string|int, mixed> $commands = []

$defaultRoute

Default route

protected array<string|int, mixed>|null $defaultRoute = null

$dispatchableCache

Cached dispatchable resolution for the current match cycle

protected mixed $dispatchableCache = null

$dispatchableParams

Dispatchable parameters

protected array<string|int, mixed> $dispatchableParams = []

$dispatchableResolved

Whether the dispatchable has been resolved for the current match cycle

protected bool $dispatchableResolved = false

$dynamicRoute

Dynamic route

protected mixed $dynamicRoute = null

$dynamicRouteActionIndex

Position of the ':action'/'<action>' token within the dynamic route declaration

protected int|null $dynamicRouteActionIndex = null

$dynamicRouteControllerIndex

Position of the ':controller'/'<controller>' token within the dynamic route declaration

protected int|null $dynamicRouteControllerIndex = null

$dynamicRouteLiterals

Literal segments of the dynamic route declaration, keyed by their position within that declaration

protected array<string|int, mixed> $dynamicRouteLiterals = []

$dynamicRoutePrefix

Dynamic route prefix

protected mixed $dynamicRoutePrefix = null

$hasAllRequired

Flag for all required parameters

protected bool $hasAllRequired = true

$isDynamicRoute

Flag for dynamic route

protected bool $isDynamicRoute = false

$options

Allowed route options

protected array<string|int, mixed> $options = [ 'options' => [], // [-v|--verbose] 'values' => [], // [-n|--name=] 'arrays' => [], ]

$parameters

Allowed route parameters

protected array<string|int, mixed> $parameters = []

$preparedRoutes

Prepared routes

protected array<string|int, mixed> $preparedRoutes = []

$routeNames

Route names

protected array<string|int, mixed> $routeNames = []

$routeParams

Route parameters

protected array<string|int, mixed> $routeParams = []

$routes

Routes

protected array<string|int, mixed> $routes = []

$routeSpecificity

Specificity score per prepared route, keyed the same as preparedRoutes

protected array<string|int, mixed> $routeSpecificity = []

$routeString

Route string

protected string|null $routeString = null

$segments

Segments of route string

protected array<string|int, mixed> $segments = []

Methods

__construct()

Constructor

public __construct() : mixed

cmd required command [cmd] optional command cmd1|cmd2 required command with alternate options [cmd1|cmd2] optional command with alternate options

[-o|--option] option flag [-o|--option=] option value [-o|--option=*] multiple option values

required parameter [] optional parameter

Instantiate the CLI match object

addDispatchableParams()

Add dispatchable params to be passed into a new dispatchable instance

public addDispatchableParams(string $dispatchable, mixed $params) : AbstractMatch
Parameters
$dispatchable : string
$params : mixed
Return values
AbstractMatch

appendDispatchableParams()

Append dispatchable params to be passed into a new dispatchable instance

public appendDispatchableParams(string $dispatchable, mixed $params) : AbstractMatch
Parameters
$dispatchable : string
$params : mixed
Return values
AbstractMatch

getCommandOptions()

Get the command options

public getCommandOptions() : array<string|int, mixed>
Return values
array<string|int, mixed>

getCommandParameters()

Get the command parameters

public getCommandParameters() : array<string|int, mixed>
Return values
array<string|int, mixed>

getCommands()

Get the route commands

public getCommands() : array<string|int, mixed>
Return values
array<string|int, mixed>

getDefaultRoute()

Get the default route

public getDefaultRoute() : array<string|int, mixed>
Return values
array<string|int, mixed>

getDispatchable()

Get the dispatchable

public getDispatchable() : mixed

getDispatchableParams()

Get the params assigned to the dispatchable

public getDispatchableParams(string $dispatchable) : mixed
Parameters
$dispatchable : string

getDynamicRoute()

Get the dynamic route

public getDynamicRoute() : mixed

getDynamicRoutePrefix()

Get the dynamic route prefix

public getDynamicRoutePrefix() : mixed

getFlattenedRoutes()

Get flattened routes

public getFlattenedRoutes() : array<string|int, mixed>
Return values
array<string|int, mixed>

getOption()

Get a parsed route option

public getOption(string $name) : mixed
Parameters
$name : string

getOptions()

Get the parsed route options

public getOptions() : array<string|int, mixed>
Return values
array<string|int, mixed>

getOriginalRoute()

Get original route string

public getOriginalRoute() : string|null
Return values
string|null

getParameter()

Get a parsed route param

public getParameter(string $name) : mixed
Parameters
$name : string

getParameters()

Get the parsed route params

public getParameters() : array<string|int, mixed>
Return values
array<string|int, mixed>

getPreparedRoutes()

Get prepared routes

public getPreparedRoutes() : array<string|int, mixed>
Return values
array<string|int, mixed>

getRoute()

Get route regex

public getRoute() : string
Return values
string

getRouteConfig()

Get route config

public getRouteConfig([string|null $key = null ]) : mixed
Parameters
$key : string|null = null

getRouteParams()

Get the params discovered from the route

public getRouteParams() : array<string|int, mixed>
Return values
array<string|int, mixed>

getRoutes()

Get routes

public getRoutes() : array<string|int, mixed>
Return values
array<string|int, mixed>

getRouteString()

Get the route string

public getRouteString() : string
Return values
string

getSegment()

Get a route string segment

public getSegment(int $i) : string|null
Parameters
$i : int
Return values
string|null

getSegments()

Get the route string segments

public getSegments() : array<string|int, mixed>
Return values
array<string|int, mixed>

hasAction()

Determine if there is an action

public hasAction() : bool
Return values
bool

hasDefaultRoute()

Determine if there is a default route

public hasDefaultRoute() : bool
Return values
bool

hasDispatchable()

Determine if there is a dispatchable

public hasDispatchable() : bool
Return values
bool

hasDispatchableParams()

Determine if the dispatchable has params

public hasDispatchableParams(string $dispatchable) : bool
Parameters
$dispatchable : string
Return values
bool

hasDynamicRoute()

Determine if there is a dynamic route

public hasDynamicRoute() : bool
Return values
bool

hasName()

Has a route name

public hasName(string $routeName) : bool
Parameters
$routeName : string
Return values
bool

hasRoute()

Determine if the route has been matched

public hasRoute() : bool
Return values
bool

hasRouteConfig()

Has route config

public hasRouteConfig([string|null $key = null ]) : bool
Parameters
$key : string|null = null
Return values
bool

hasRouteParams()

Determine if the route has params

public hasRouteParams() : bool
Return values
bool

isDynamicRoute()

Determine if it is a dynamic route

public isDynamicRoute() : bool
Return values
bool

match()

Match the route

public match([string|array<string|int, mixed>|null $forceRoute = null ]) : bool
Parameters
$forceRoute : string|array<string|int, mixed>|null = null
Return values
bool

noRouteFound()

Method to process if a route was not found

public noRouteFound([bool $exit = true ]) : void
Parameters
$exit : bool = true

prepare()

Prepare the routes

public prepare() : static
Return values
static

buildOptionValueRegex()

Build the value-matching regex fragment shared by option-value and option-value-array matches

protected buildOptionValueRegex(string $opt) : string
Parameters
$opt : string
Return values
string

extractRouteCommandsRegex()

Extract the leading command-segment regex fragment from a route string, seeding $this->commands[$route] along the way

protected extractRouteCommandsRegex(string $route) : string
Parameters
$route : string
Return values
string

flattenRoutes()

Flatten the nested routes

protected flattenRoutes(array<string|int, mixed>|string $route[, mixed $controller = null ]) : void
Parameters
$route : array<string|int, mixed>|string
$controller : mixed = null

getDynamicRouteParamOffset()

Get the segment offset at which the dynamic route's params start, i.e. the segment right after the action token

protected getDynamicRouteParamOffset() : int
Return values
int

getRouteRegex()

Get the REGEX pattern for the route string

protected getRouteRegex(string $route) : array<string|int, mixed>
Parameters
$route : string
Return values
array<string|int, mixed>

indexRouteOptions()

Index the [-o]/[--option] flag matches for a route

protected indexRouteOptions(string $route, array<string|int, mixed> $options) : void
Parameters
$route : string
$options : array<string|int, mixed>

indexRouteOptionValueArrays()

Index the [--option=*]-style array-value-option matches for a route

protected indexRouteOptionValueArrays(string $route, array<string|int, mixed> $optionValueArray) : void
Parameters
$route : string
$optionValueArray : array<string|int, mixed>

indexRouteOptionValues()

Index the [--option=]-style value-option matches for a route

protected indexRouteOptionValues(string $route, array<string|int, mixed> $optionValues) : void
Parameters
$route : string
$optionValues : array<string|int, mixed>

indexRouteParameters()

Index the <param>/[<param>] required and optional parameter positions for a route

protected indexRouteParameters(string $route, array<string|int, mixed> $requiredParameters, array<string|int, mixed> $optionalParameters) : void
Parameters
$route : string
$requiredParameters : array<string|int, mixed>
$optionalParameters : array<string|int, mixed>

isDynamicRouteDeclaration()

Determine if a route declaration is the dynamic-route (":controller"/"<controller") pattern

protected isDynamicRouteDeclaration(string $route) : bool
Parameters
$route : string
Return values
bool

isDynamicRouteLiteral()

Determine if a dynamic route declaration token is a literal segment, i.e. neither a param token nor an option

protected isDynamicRouteLiteral(string $token) : bool
Parameters
$token : string
Return values
bool

matchesDynamicRoute()

Determine if the current request matches the dynamic route declaration: every literal segment of the declaration has to line up with the request's segment in that same position, and the request has to carry a segment where the declaration puts its controller token

protected matchesDynamicRoute() : bool
Return values
bool

normalizeController()

Normalize a raw dispatchable value (closure, native callable, or a pop-utils pseudo-callable string such as 'Class->method', 'Class::method', 'Class', or 'new Class') into a ['controller' => $controller] config array. Already-formed config arrays (and nested-route sub-arrays) are returned unchanged.

protected normalizeController(mixed $controller) : mixed
Parameters
$controller : mixed

parseDynamicRoute()

Parse a dynamic route declaration, recording where its ':controller'/':action' (HTTP) or '<controller>'/'<action>' (CLI) tokens sit within the declaration, along with any literal segments the request has to match for the route to apply

protected parseDynamicRoute(string $route) : void
Parameters
$route : string

parseOptionFlags()

Parse [-o]/[--option] boolean flags present in the route string

protected parseOptionFlags(string $route) : array<string|int, mixed>
Parameters
$route : string
Return values
array<string|int, mixed>

parseOptionValueArrays()

Parse [--option=*]-style array-value options present in the route string

protected parseOptionValueArrays(string $route) : array<string|int, mixed>
Parameters
$route : string
Return values
array<string|int, mixed>

parseOptionValues()

Parse [--option=]-style value options present in the route string

protected parseOptionValues(string $route) : array<string|int, mixed>
Parameters
$route : string
Return values
array<string|int, mixed>

parsePositionalParameters()

Match remaining route segments (after commands/options are filtered out) positionally against the route's required/optional parameters

protected parsePositionalParameters(string $route) : void
Parameters
$route : string

parseRouteParams()

Parse route dispatch parameters

protected parseRouteParams() : void

registerDynamicRoute()

Register a dynamic route

protected registerDynamicRoute(string $route, mixed $controller) : void
Parameters
$route : string
$controller : mixed

registerRegularRoute()

Register a regular (literal or param-bearing) route, recursing for nested route configs

protected registerRegularRoute(string $route, mixed $controller) : mixed
Parameters
$route : string
$controller : mixed
Return values
mixed

the normalized controller config

registerWildcardRoute()

Register a wildcard/default route

protected registerWildcardRoute(string $route, mixed $controller) : mixed
Parameters
$route : string
$controller : mixed
Return values
mixed

the normalized controller config

seed()

Seed the parsing inputs (segments and route string) from either pre-split argv-style segments or a raw command string

protected seed(string|array<string|int, mixed> $input) : void
Parameters
$input : string|array<string|int, mixed>

        
On this page

Search results