The API

Connects a new Route in the router.

Routes are a way of connecting request urls to objects in your application. At their core routes are a set or regular expressions that are used to match requests to destinations.

Examples:

Router::connect('/:controller/:action/*');

The first parameter will be used as a controller name while the second is used as the action name. the '/*' syntax makes this route greedy in that it will match requests like /posts/index as well as requests like /posts/edit/1/foo/bar.

Router::connect('/home-page', array('controller' => 'pages', 'action' => 'display', 'home'));

The above shows the use of route parameter defaults. And providing routing parameters for a static route.

Router::connect(
  '/:lang/:controller/:action/:id',
  array(),
  array('id' => '[0-9]+', 'lang' => '[a-z]{3}')
);

Shows connecting a route with custom route parameters as well as providing patterns for those parameters. Patterns for routing parameters do not need capturing groups, as one will be added for each route params.

$options offers three 'special' keys. pass, persist and routeClass have special meaning in the $options array.

pass is used to define which of the routed parameters should be shifted into the pass array. Adding a parameter to pass will remove it from the regular route array. Ex. 'pass' => array('slug')

persist is used to define which route parameters should be automatically included when generating new urls. You can override persistent parameters by redefining them in a url or remove them by setting the parameter to false. Ex. 'persist' => array('lang')

routeClass is used to extend and change how individual routes parse requests and handle reverse routing, via a custom routing class. Ex. 'routeClass' => 'SlugRoute'

Specifies what named parameters CakePHP should be parsing. The most common setups are:

Do not parse any named parameters:

Router::connectNamed(false);

Parse only default parameters used for CakePHP's pagination:

Router::connectNamed(false, array('default' => true));

Parse only the page parameter if its value is a number:

Router::connectNamed(array('page' => '[\d]+'), array('default' => false, 'greedy' => false));

Parse only the page parameter no mater what.

Router::connectNamed(array('page'), array('default' => false, 'greedy' => false));

Parse only the page parameter if the current action is 'index'.

Router::connectNamed(
   array('page' => array('action' => 'index')),
   array('default' => false, 'greedy' => false)
);

Parse only the page parameter if the current action is 'index' and the controller is 'pages'.

Router::connectNamed(
   array('page' => array('action' => 'index', 'controller' => 'pages')),
   array('default' => false, 'greedy' => false)
);

Returns the route matching the current request (useful for requestAction traces)

Tell router to connect or not connect the default routes.

If default routes are disabled all automatic route generation will be disabled and you will need to manually configure all the routes you want.

Takes a passed params and converts it to args

Gets a reference to the Router object instance

Takes an array of URL parameters and separates the ones that can be used as named arguments

Gets the named route elements for use in app/config/routes.php

Gets URL parameter by name

Gets parameter information

Gets path information

A special fallback method that handles url arrays that cannot match any defined routes.

Creates REST resource routes for the given controller(s)

Options:

• 'id' - The regular expression fragment to use when matching IDs. By default, matches integer values and UUIDs.
• 'prefix' - URL prefix to use for the generated routes. Defaults to '/'.

Return true if a given named $param's $val matches a given $rule depending on $context. Currently implemented rule types are controller, action and match that can be combined with each other.

Normalizes a URL for purposes of comparison. Will strip the base path off and replace any double /'s. It will not unify the casing and underscoring of the input value.

Parses given URL and returns an array of controller, action and parameters taken from that URL.

Instructs the router to parse out file extensions from the URL. For example, http://example.com/posts.rss would yield an file extension of "rss". The file extension itself is made available in the controller as $this->params['url']['ext'], and is used by the RequestHandler component to automatically switch to alternate layouts and templates, and load helpers corresponding to the given content, i.e. RssHelper.

A list of valid extension can be passed to this method, i.e. Router::parseExtensions('rss', 'xml'); If no parameters are given, anything after the first . (dot) after the last / in the URL will be parsed, excluding querystring parameters (i.e. ?q=...).

Returns the list of prefixes used in connected routes

Promote a route (by default, the last one added) to the beginning of the list

Generates a well-formed querystring from $q

Reloads default Router settings. Resets all class variables and removes all connected routes.

Returns the route matching the current request URL.

Reverses a parsed parameter array into a string. Works similarly to Router::url(), but Since parsed URL's contain additional 'pass' and 'named' as well as 'url.url' keys. Those keys need to be specially handled in order to reverse a params array into a string url.

This will strip out 'autoRender', 'bare', 'requested', and 'return' param names as those are used for CakePHP internals and should not normally be part of an output url.

Constructor for Router. Builds __prefixes

Takes parameter and path information back from the Dispatcher, sets these parameters as the current request parameters that are merged with url arrays created later in the request.

Removes the plugin name from the base URL.

Finds URL for specified action.

Returns an URL pointing to a combination of controller and action. Param $url can be:

• Empty - the method will find address to actual controller/action.
• '/' - the method will find base URL of application.
• A combination of controller/action - the method will find url for it.

There are a few 'special' parameters that can change the final URL string that is generated

• base - Set to false to remove the base path from the generated url. If your application is not in the root directory, this can be used to generate urls that are 'cake relative'. cake relative urls are required when using requestAction.
• ? - Takes an array of query string parameters
• # - Allows you to set url hash fragments.
• full_base - If true the FULL_BASE_URL constant will be prepended to generated urls.