source: Dev/branches/cakephp/cake/libs/router.php @ 126

Last change on this file since 126 was 126, checked in by fpvanagthoven, 14 years ago

Cakephp branch.

File size: 46.2 KB
RevLine 
[126]1<?php
2/**
3 * Parses the request URL into controller, action, and parameters.
4 *
5 * PHP versions 4 and 5
6 *
7 * CakePHP(tm) : Rapid Development Framework (http://cakephp.org)
8 * Copyright 2005-2011, Cake Software Foundation, Inc. (http://cakefoundation.org)
9 *
10 * Licensed under The MIT License
11 * Redistributions of files must retain the above copyright notice.
12 *
13 * @copyright     Copyright 2005-2011, Cake Software Foundation, Inc. (http://cakefoundation.org)
14 * @link          http://cakephp.org CakePHP(tm) Project
15 * @package       cake
16 * @subpackage    cake.cake.libs
17 * @since         CakePHP(tm) v 0.2.9
18 * @license       MIT License (http://www.opensource.org/licenses/mit-license.php)
19 */
20
21/**
22 * Parses the request URL into controller, action, and parameters.
23 *
24 * @package       cake
25 * @subpackage    cake.cake.libs
26 */
27class Router {
28
29/**
30 * Array of routes connected with Router::connect()
31 *
32 * @var array
33 * @access public
34 */
35        var $routes = array();
36
37/**
38 * List of action prefixes used in connected routes.
39 * Includes admin prefix
40 *
41 * @var array
42 * @access private
43 */
44        var $__prefixes = array();
45
46/**
47 * Directive for Router to parse out file extensions for mapping to Content-types.
48 *
49 * @var boolean
50 * @access private
51 */
52        var $__parseExtensions = false;
53
54/**
55 * List of valid extensions to parse from a URL.  If null, any extension is allowed.
56 *
57 * @var array
58 * @access private
59 */
60        var $__validExtensions = null;
61
62/**
63 * 'Constant' regular expression definitions for named route elements
64 *
65 * @var array
66 * @access private
67 */
68        var $__named = array(
69                'Action'        => 'index|show|add|create|edit|update|remove|del|delete|view|item',
70                'Year'          => '[12][0-9]{3}',
71                'Month'         => '0[1-9]|1[012]',
72                'Day'           => '0[1-9]|[12][0-9]|3[01]',
73                'ID'            => '[0-9]+',
74                'UUID'          => '[A-Fa-f0-9]{8}-[A-Fa-f0-9]{4}-[A-Fa-f0-9]{4}-[A-Fa-f0-9]{4}-[A-Fa-f0-9]{12}'
75        );
76
77/**
78 * Stores all information necessary to decide what named arguments are parsed under what conditions.
79 *
80 * @var string
81 * @access public
82 */
83        var $named = array(
84                'default' => array('page', 'fields', 'order', 'limit', 'recursive', 'sort', 'direction', 'step'),
85                'greedy' => true,
86                'separator' => ':',
87                'rules' => false,
88        );
89
90/**
91 * The route matching the URL of the current request
92 *
93 * @var array
94 * @access private
95 */
96        var $__currentRoute = array();
97
98/**
99 * Default HTTP request method => controller action map.
100 *
101 * @var array
102 * @access private
103 */
104        var $__resourceMap = array(
105                array('action' => 'index',      'method' => 'GET',              'id' => false),
106                array('action' => 'view',       'method' => 'GET',              'id' => true),
107                array('action' => 'add',        'method' => 'POST',             'id' => false),
108                array('action' => 'edit',       'method' => 'PUT',              'id' => true),
109                array('action' => 'delete',     'method' => 'DELETE',   'id' => true),
110                array('action' => 'edit',       'method' => 'POST',     'id' => true)
111        );
112
113/**
114 * List of resource-mapped controllers
115 *
116 * @var array
117 * @access private
118 */
119        var $__resourceMapped = array();
120
121/**
122 * Maintains the parameter stack for the current request
123 *
124 * @var array
125 * @access private
126 */
127        var $__params = array();
128
129/**
130 * Maintains the path stack for the current request
131 *
132 * @var array
133 * @access private
134 */
135        var $__paths = array();
136
137/**
138 * Keeps Router state to determine if default routes have already been connected
139 *
140 * @var boolean
141 * @access private
142 */
143        var $__defaultsMapped = false;
144
145/**
146 * Keeps track of whether the connection of default routes is enabled or disabled.
147 *
148 * @var boolean
149 * @access private
150 */
151        var $__connectDefaults = true;
152
153/**
154 * Constructor for Router.
155 * Builds __prefixes
156 *
157 * @return void
158 */
159        function Router() {
160                $this->__setPrefixes();
161        }
162
163/**
164 * Sets the Routing prefixes. Includes compatibility for existing Routing.admin
165 * configurations.
166 *
167 * @return void
168 * @access private
169 * @todo Remove support for Routing.admin in future versions.
170 */
171        function __setPrefixes() {
172                $routing = Configure::read('Routing');
173                if (!empty($routing['admin'])) {
174                        $this->__prefixes[] = $routing['admin'];
175                }
176                if (!empty($routing['prefixes'])) {
177                        $this->__prefixes = array_merge($this->__prefixes, (array)$routing['prefixes']);
178                }
179        }
180
181/**
182 * Gets a reference to the Router object instance
183 *
184 * @return Router Instance of the Router.
185 * @access public
186 * @static
187 */
188        function &getInstance() {
189                static $instance = array();
190
191                if (!$instance) {
192                        $instance[0] =& new Router();
193                }
194                return $instance[0];
195        }
196
197/**
198 * Gets the named route elements for use in app/config/routes.php
199 *
200 * @return array Named route elements
201 * @access public
202 * @see Router::$__named
203 * @static
204 */
205        function getNamedExpressions() {
206                $self =& Router::getInstance();
207                return $self->__named;
208        }
209
210/**
211 * Connects a new Route in the router.
212 *
213 * Routes are a way of connecting request urls to objects in your application.  At their core routes
214 * are a set or regular expressions that are used to match requests to destinations.
215 *
216 * Examples:
217 *
218 * `Router::connect('/:controller/:action/*');`
219 *
220 * The first parameter will be used as a controller name while the second is used as the action name.
221 * the '/*' syntax makes this route greedy in that it will match requests like `/posts/index` as well as requests
222 * like `/posts/edit/1/foo/bar`.
223 *
224 * `Router::connect('/home-page', array('controller' => 'pages', 'action' => 'display', 'home'));`
225 *
226 * The above shows the use of route parameter defaults. And providing routing parameters for a static route.
227 *
228 * {{{
229 * Router::connect(
230 *   '/:lang/:controller/:action/:id',
231 *   array(),
232 *   array('id' => '[0-9]+', 'lang' => '[a-z]{3}')
233 * );
234 * }}}
235 *
236 * Shows connecting a route with custom route parameters as well as providing patterns for those parameters.
237 * Patterns for routing parameters do not need capturing groups, as one will be added for each route params.
238 *
239 * $options offers three 'special' keys. `pass`, `persist` and `routeClass` have special meaning in the $options array.
240 *
241 * `pass` is used to define which of the routed parameters should be shifted into the pass array.  Adding a
242 * parameter to pass will remove it from the regular route array. Ex. `'pass' => array('slug')`
243 *
244 * `persist` is used to define which route parameters should be automatically included when generating
245 * new urls. You can override persistent parameters by redefining them in a url or remove them by
246 * setting the parameter to `false`.  Ex. `'persist' => array('lang')`
247 *
248 * `routeClass` is used to extend and change how individual routes parse requests and handle reverse routing,
249 * via a custom routing class. Ex. `'routeClass' => 'SlugRoute'`
250 *
251 * @param string $route A string describing the template of the route
252 * @param array $defaults An array describing the default route parameters. These parameters will be used by default
253 *   and can supply routing parameters that are not dynamic. See above.
254 * @param array $options An array matching the named elements in the route to regular expressions which that
255 *   element should match.  Also contains additional parameters such as which routed parameters should be
256 *   shifted into the passed arguments, supplying patterns for routing parameters and supplying the name of a
257 *   custom routing class.
258 * @see routes
259 * @return array Array of routes
260 * @access public
261 * @static
262 */
263        function connect($route, $defaults = array(), $options = array()) {
264                $self =& Router::getInstance();
265
266                foreach ($self->__prefixes as $prefix) {
267                        if (isset($defaults[$prefix])) {
268                                $defaults['prefix'] = $prefix;
269                                break;
270                        }
271                }
272                if (isset($defaults['prefix'])) {
273                        $self->__prefixes[] = $defaults['prefix'];
274                        $self->__prefixes = array_keys(array_flip($self->__prefixes));
275                }
276                $defaults += array('plugin' => null);
277                if (empty($options['action'])) {
278                        $defaults += array('action' => 'index');
279                }
280                $routeClass = 'CakeRoute';
281                if (isset($options['routeClass'])) {
282                        $routeClass = $options['routeClass'];
283                        unset($options['routeClass']);
284                }
285                //TODO 2.0 refactor this to use a string class name, throw exception, and then construct.
286                $Route =& new $routeClass($route, $defaults, $options);
287                if ($routeClass !== 'CakeRoute' && !is_subclass_of($Route, 'CakeRoute')) {
288                        trigger_error(__('Route classes must extend CakeRoute', true), E_USER_WARNING);
289                        return false;
290                }
291                $self->routes[] =& $Route;
292                return $self->routes;
293        }
294
295/**
296 * Specifies what named parameters CakePHP should be parsing. The most common setups are:
297 *
298 * Do not parse any named parameters:
299 *
300 * {{{ Router::connectNamed(false); }}}
301 *
302 * Parse only default parameters used for CakePHP's pagination:
303 *
304 * {{{ Router::connectNamed(false, array('default' => true)); }}}
305 *
306 * Parse only the page parameter if its value is a number:
307 *
308 * {{{ Router::connectNamed(array('page' => '[\d]+'), array('default' => false, 'greedy' => false)); }}}
309 *
310 * Parse only the page parameter no mater what.
311 *
312 * {{{ Router::connectNamed(array('page'), array('default' => false, 'greedy' => false)); }}}
313 *
314 * Parse only the page parameter if the current action is 'index'.
315 *
316 * {{{
317 * Router::connectNamed(
318 *    array('page' => array('action' => 'index')),
319 *    array('default' => false, 'greedy' => false)
320 * );
321 * }}}
322 *
323 * Parse only the page parameter if the current action is 'index' and the controller is 'pages'.
324 *
325 * {{{
326 * Router::connectNamed(
327 *    array('page' => array('action' => 'index', 'controller' => 'pages')),
328 *    array('default' => false, 'greedy' => false)
329 * );
330 * }}}
331 *
332 * @param array $named A list of named parameters. Key value pairs are accepted where values are
333 *    either regex strings to match, or arrays as seen above.
334 * @param array $options Allows to control all settings: separator, greedy, reset, default
335 * @return array
336 * @access public
337 * @static
338 */
339        function connectNamed($named, $options = array()) {
340                $self =& Router::getInstance();
341
342                if (isset($options['argSeparator'])) {
343                        $self->named['separator'] = $options['argSeparator'];
344                        unset($options['argSeparator']);
345                }
346
347                if ($named === true || $named === false) {
348                        $options = array_merge(array('default' => $named, 'reset' => true, 'greedy' => $named), $options);
349                        $named = array();
350                } else {
351                        $options = array_merge(array('default' => false, 'reset' => false, 'greedy' => true), $options);
352                }
353
354                if ($options['reset'] == true || $self->named['rules'] === false) {
355                        $self->named['rules'] = array();
356                }
357
358                if ($options['default']) {
359                        $named = array_merge($named, $self->named['default']);
360                }
361
362                foreach ($named as $key => $val) {
363                        if (is_numeric($key)) {
364                                $self->named['rules'][$val] = true;
365                        } else {
366                                $self->named['rules'][$key] = $val;
367                        }
368                }
369                $self->named['greedy'] = $options['greedy'];
370                return $self->named;
371        }
372
373/**
374 * Tell router to connect or not connect the default routes.
375 *
376 * If default routes are disabled all automatic route generation will be disabled
377 * and you will need to manually configure all the routes you want.
378 *
379 * @param boolean $connect Set to true or false depending on whether you want or don't want default routes.
380 * @return void
381 * @access public
382 * @static
383 */
384        function defaults($connect = true) {
385                $self =& Router::getInstance();
386                $self->__connectDefaults = $connect;
387        }
388
389/**
390 * Creates REST resource routes for the given controller(s)
391 *
392 * ### Options:
393 *
394 * - 'id' - The regular expression fragment to use when matching IDs.  By default, matches
395 *    integer values and UUIDs.
396 * - 'prefix' - URL prefix to use for the generated routes.  Defaults to '/'.
397 *
398 * @param mixed $controller A controller name or array of controller names (i.e. "Posts" or "ListItems")
399 * @param array $options Options to use when generating REST routes
400 * @return void
401 * @access public
402 * @static
403 */
404        function mapResources($controller, $options = array()) {
405                $self =& Router::getInstance();
406                $options = array_merge(array('prefix' => '/', 'id' => $self->__named['ID'] . '|' . $self->__named['UUID']), $options);
407                $prefix = $options['prefix'];
408
409                foreach ((array)$controller as $ctlName) {
410                        $urlName = Inflector::underscore($ctlName);
411
412                        foreach ($self->__resourceMap as $params) {
413                                extract($params);
414                                $url = $prefix . $urlName . (($id) ? '/:id' : '');
415
416                                Router::connect($url,
417                                        array('controller' => $urlName, 'action' => $action, '[method]' => $params['method']),
418                                        array('id' => $options['id'], 'pass' => array('id'))
419                                );
420                        }
421                        $self->__resourceMapped[] = $urlName;
422                }
423        }
424
425/**
426 * Returns the list of prefixes used in connected routes
427 *
428 * @return array A list of prefixes used in connected routes
429 * @access public
430 * @static
431 */
432        function prefixes() {
433                $self =& Router::getInstance();
434                return $self->__prefixes;
435        }
436
437/**
438 * Parses given URL and returns an array of controller, action and parameters
439 * taken from that URL.
440 *
441 * @param string $url URL to be parsed
442 * @return array Parsed elements from URL
443 * @access public
444 * @static
445 */
446        function parse($url) {
447                $self =& Router::getInstance();
448                if (!$self->__defaultsMapped && $self->__connectDefaults) {
449                        $self->__connectDefaultRoutes();
450                }
451                $out = array(
452                        'pass' => array(),
453                        'named' => array(),
454                );
455                $r = $ext = null;
456
457                if (ini_get('magic_quotes_gpc') === '1') {
458                        $url = stripslashes_deep($url);
459                }
460
461                if ($url && strpos($url, '/') !== 0) {
462                        $url = '/' . $url;
463                }
464                if (strpos($url, '?') !== false) {
465                        $url = substr($url, 0, strpos($url, '?'));
466                }
467                extract($self->__parseExtension($url));
468
469                for ($i = 0, $len = count($self->routes); $i < $len; $i++) {
470                        $route =& $self->routes[$i];
471                        if (($r = $route->parse($url)) !== false) {
472                                $self->__currentRoute[] =& $route;
473
474                                $params = $route->options;
475                                $argOptions = array();
476
477                                if (array_key_exists('named', $params)) {
478                                        $argOptions['named'] = $params['named'];
479                                        unset($params['named']);
480                                }
481                                if (array_key_exists('greedy', $params)) {
482                                        $argOptions['greedy'] = $params['greedy'];
483                                        unset($params['greedy']);
484                                }
485                                $out = $r;
486
487                                if (isset($out['_args_'])) {
488                                        $argOptions['context'] = array('action' => $out['action'], 'controller' => $out['controller']);
489                                        $parsedArgs = $self->getArgs($out['_args_'], $argOptions);
490                                        $out['pass'] = array_merge($out['pass'], $parsedArgs['pass']);
491                                        $out['named'] = $parsedArgs['named'];
492                                        unset($out['_args_']);
493                                }
494
495                                if (isset($params['pass'])) {
496                                        $j = count($params['pass']);
497                                        while($j--) {
498                                                if (isset($out[$params['pass'][$j]])) {
499                                                        array_unshift($out['pass'], $out[$params['pass'][$j]]);
500                                                }
501                                        }
502                                }
503                                break;
504                        }
505                }
506
507                if (!empty($ext) && !isset($out['url']['ext'])) {
508                        $out['url']['ext'] = $ext;
509                }
510                return $out;
511        }
512
513/**
514 * Parses a file extension out of a URL, if Router::parseExtensions() is enabled.
515 *
516 * @param string $url
517 * @return array Returns an array containing the altered URL and the parsed extension.
518 * @access private
519 */
520        function __parseExtension($url) {
521                $ext = null;
522
523                if ($this->__parseExtensions) {
524                        if (preg_match('/\.[0-9a-zA-Z]*$/', $url, $match) === 1) {
525                                $match = substr($match[0], 1);
526                                if (empty($this->__validExtensions)) {
527                                        $url = substr($url, 0, strpos($url, '.' . $match));
528                                        $ext = $match;
529                                } else {
530                                        foreach ($this->__validExtensions as $name) {
531                                                if (strcasecmp($name, $match) === 0) {
532                                                        $url = substr($url, 0, strpos($url, '.' . $name));
533                                                        $ext = $match;
534                                                        break;
535                                                }
536                                        }
537                                }
538                        }
539                        if (empty($ext)) {
540                                $ext = 'html';
541                        }
542                }
543                return compact('ext', 'url');
544        }
545
546/**
547 * Connects the default, built-in routes, including prefix and plugin routes. The following routes are created
548 * in the order below:
549 *
550 * For each of the Routing.prefixes the following routes are created. Routes containing `:plugin` are only
551 * created when your application has one or more plugins.
552 *
553 * - `/:prefix/:plugin` a plugin shortcut route.
554 * - `/:prefix/:plugin/:action/*` a plugin shortcut route.
555 * - `/:prefix/:plugin/:controller`
556 * - `/:prefix/:plugin/:controller/:action/*`
557 * - `/:prefix/:controller`
558 * - `/:prefix/:controller/:action/*`
559 *
560 * If plugins are found in your application the following routes are created:
561 *
562 * - `/:plugin` a plugin shortcut route.
563 * - `/:plugin/:action/*` a plugin shortcut route.
564 * - `/:plugin/:controller`
565 * - `/:plugin/:controller/:action/*`
566 *
567 * And lastly the following catch-all routes are connected.
568 *
569 * - `/:controller'
570 * - `/:controller/:action/*'
571 *
572 * You can disable the connection of default routes with Router::defaults().
573 *
574 * @return void
575 * @access private
576 */
577        function __connectDefaultRoutes() {
578                if ($plugins = App::objects('plugin')) {
579                        foreach ($plugins as $key => $value) {
580                                $plugins[$key] = Inflector::underscore($value);
581                        }
582                        $pluginPattern = implode('|', $plugins);
583                        $match = array('plugin' => $pluginPattern);
584                        $shortParams = array('routeClass' => 'PluginShortRoute', 'plugin' => $pluginPattern);
585
586                        foreach ($this->__prefixes as $prefix) {
587                                $params = array('prefix' => $prefix, $prefix => true);
588                                $indexParams = $params + array('action' => 'index');
589                                $this->connect("/{$prefix}/:plugin", $indexParams, $shortParams);
590                                $this->connect("/{$prefix}/:plugin/:controller", $indexParams, $match);
591                                $this->connect("/{$prefix}/:plugin/:controller/:action/*", $params, $match);
592                        }
593                        $this->connect('/:plugin', array('action' => 'index'), $shortParams);
594                        $this->connect('/:plugin/:controller', array('action' => 'index'), $match);
595                        $this->connect('/:plugin/:controller/:action/*', array(), $match);
596                }
597
598                foreach ($this->__prefixes as $prefix) {
599                        $params = array('prefix' => $prefix, $prefix => true);
600                        $indexParams = $params + array('action' => 'index');
601                        $this->connect("/{$prefix}/:controller", $indexParams);
602                        $this->connect("/{$prefix}/:controller/:action/*", $params);
603                }
604                $this->connect('/:controller', array('action' => 'index'));
605                $this->connect('/:controller/:action/*');
606
607                if ($this->named['rules'] === false) {
608                        $this->connectNamed(true);
609                }
610                $this->__defaultsMapped = true;
611        }
612
613/**
614 * Takes parameter and path information back from the Dispatcher, sets these
615 * parameters as the current request parameters that are merged with url arrays
616 * created later in the request.
617 *
618 * @param array $params Parameters and path information
619 * @return void
620 * @access public
621 * @static
622 */
623        function setRequestInfo($params) {
624                $self =& Router::getInstance();
625                $defaults = array('plugin' => null, 'controller' => null, 'action' => null);
626                $params[0] = array_merge($defaults, (array)$params[0]);
627                $params[1] = array_merge($defaults, (array)$params[1]);
628                list($self->__params[], $self->__paths[]) = $params;
629
630                if (count($self->__paths)) {
631                        if (isset($self->__paths[0]['namedArgs'])) {
632                                foreach ($self->__paths[0]['namedArgs'] as $arg => $value) {
633                                        $self->named['rules'][$arg] = true;
634                                }
635                        }
636                }
637        }
638
639/**
640 * Gets parameter information
641 *
642 * @param boolean $current Get current request parameter, useful when using requestAction
643 * @return array Parameter information
644 * @access public
645 * @static
646 */
647        function getParams($current = false) {
648                $self =& Router::getInstance();
649                if ($current) {
650                        return $self->__params[count($self->__params) - 1];
651                }
652                if (isset($self->__params[0])) {
653                        return $self->__params[0];
654                }
655                return array();
656        }
657
658/**
659 * Gets URL parameter by name
660 *
661 * @param string $name Parameter name
662 * @param boolean $current Current parameter, useful when using requestAction
663 * @return string Parameter value
664 * @access public
665 * @static
666 */
667        function getParam($name = 'controller', $current = false) {
668                $params = Router::getParams($current);
669                if (isset($params[$name])) {
670                        return $params[$name];
671                }
672                return null;
673        }
674
675/**
676 * Gets path information
677 *
678 * @param boolean $current Current parameter, useful when using requestAction
679 * @return array
680 * @access public
681 * @static
682 */
683        function getPaths($current = false) {
684                $self =& Router::getInstance();
685                if ($current) {
686                        return $self->__paths[count($self->__paths) - 1];
687                }
688                if (!isset($self->__paths[0])) {
689                        return array('base' => null);
690                }
691                return $self->__paths[0];
692        }
693
694/**
695 * Reloads default Router settings.  Resets all class variables and
696 * removes all connected routes.
697 *
698 * @access public
699 * @return void
700 * @static
701 */
702        function reload() {
703                $self =& Router::getInstance();
704                foreach (get_class_vars('Router') as $key => $val) {
705                        $self->{$key} = $val;
706                }
707                $self->__setPrefixes();
708        }
709
710/**
711 * Promote a route (by default, the last one added) to the beginning of the list
712 *
713 * @param $which A zero-based array index representing the route to move. For example,
714 *    if 3 routes have been added, the last route would be 2.
715 * @return boolean Returns false if no route exists at the position specified by $which.
716 * @access public
717 * @static
718 */
719        function promote($which = null) {
720                $self =& Router::getInstance();
721                if ($which === null) {
722                        $which = count($self->routes) - 1;
723                }
724                if (!isset($self->routes[$which])) {
725                        return false;
726                }
727                $route =& $self->routes[$which];
728                unset($self->routes[$which]);
729                array_unshift($self->routes, $route);
730                return true;
731        }
732
733/**
734 * Finds URL for specified action.
735 *
736 * Returns an URL pointing to a combination of controller and action. Param
737 * $url can be:
738 *
739 * - Empty - the method will find address to actual controller/action.
740 * - '/' - the method will find base URL of application.
741 * - A combination of controller/action - the method will find url for it.
742 *
743 * There are a few 'special' parameters that can change the final URL string that is generated
744 *
745 * - `base` - Set to false to remove the base path from the generated url. If your application
746 *   is not in the root directory, this can be used to generate urls that are 'cake relative'.
747 *   cake relative urls are required when using requestAction.
748 * - `?` - Takes an array of query string parameters
749 * - `#` - Allows you to set url hash fragments.
750 * - `full_base` - If true the `FULL_BASE_URL` constant will be prepended to generated urls.
751 *
752 * @param mixed $url Cake-relative URL, like "/products/edit/92" or "/presidents/elect/4"
753 *   or an array specifying any of the following: 'controller', 'action',
754 *   and/or 'plugin', in addition to named arguments (keyed array elements),
755 *   and standard URL arguments (indexed array elements)
756 * @param mixed $full If (bool) true, the full base URL will be prepended to the result.
757 *   If an array accepts the following keys
758 *    - escape - used when making urls embedded in html escapes query string '&'
759 *    - full - if true the full base URL will be prepended.
760 * @return string Full translated URL with base path.
761 * @access public
762 * @static
763 */
764        function url($url = null, $full = false) {
765                $self =& Router::getInstance();
766                $defaults = $params = array('plugin' => null, 'controller' => null, 'action' => 'index');
767
768                if (is_bool($full)) {
769                        $escape = false;
770                } else {
771                        extract($full + array('escape' => false, 'full' => false));
772                }
773
774                if (!empty($self->__params)) {
775                        if (isset($this) && !isset($this->params['requested'])) {
776                                $params = $self->__params[0];
777                        } else {
778                                $params = end($self->__params);
779                        }
780                }
781                $path = array('base' => null);
782
783                if (!empty($self->__paths)) {
784                        if (isset($this) && !isset($this->params['requested'])) {
785                                $path = $self->__paths[0];
786                        } else {
787                                $path = end($self->__paths);
788                        }
789                }
790                $base = $path['base'];
791                $extension = $output = $mapped = $q = $frag = null;
792
793                if (is_array($url)) {
794                        if (isset($url['base']) && $url['base'] === false) {
795                                $base = null;
796                                unset($url['base']);
797                        }
798                        if (isset($url['full_base']) && $url['full_base'] === true) {
799                                $full = true;
800                                unset($url['full_base']);
801                        }
802                        if (isset($url['?'])) {
803                                $q = $url['?'];
804                                unset($url['?']);
805                        }
806                        if (isset($url['#'])) {
807                                $frag = '#' . urlencode($url['#']);
808                                unset($url['#']);
809                        }
810                        if (empty($url['action'])) {
811                                if (empty($url['controller']) || $params['controller'] === $url['controller']) {
812                                        $url['action'] = $params['action'];
813                                } else {
814                                        $url['action'] = 'index';
815                                }
816                        }
817
818                        $prefixExists = (array_intersect_key($url, array_flip($self->__prefixes)));
819                        foreach ($self->__prefixes as $prefix) {
820                                if (!empty($params[$prefix]) && !$prefixExists) {
821                                        $url[$prefix] = true;
822                                } elseif (isset($url[$prefix]) && !$url[$prefix]) {
823                                        unset($url[$prefix]);
824                                }
825                                if (isset($url[$prefix]) && strpos($url['action'], $prefix . '_') === 0) {
826                                        $url['action'] = substr($url['action'], strlen($prefix) + 1);
827                                }
828                        }
829
830                        $url += array('controller' => $params['controller'], 'plugin' => $params['plugin']);
831
832                        if (isset($url['ext'])) {
833                                $extension = '.' . $url['ext'];
834                                unset($url['ext']);
835                        }
836                        $match = false;
837
838                        for ($i = 0, $len = count($self->routes); $i < $len; $i++) {
839                                $originalUrl = $url;
840
841                                if (isset($self->routes[$i]->options['persist'], $params)) {
842                                        $url = $self->routes[$i]->persistParams($url, $params);
843                                }
844
845                                if ($match = $self->routes[$i]->match($url)) {
846                                        $output = trim($match, '/');
847                                        break;
848                                }
849                                $url = $originalUrl;
850                        }
851                        if ($match === false) {
852                                $output = $self->_handleNoRoute($url);
853                        }
854                        $output = str_replace('//', '/', $base . '/' . $output);
855                } else {
856                        if (((strpos($url, '://')) || (strpos($url, 'javascript:') === 0) || (strpos($url, 'mailto:') === 0)) || (!strncmp($url, '#', 1))) {
857                                return $url;
858                        }
859                        if (empty($url)) {
860                                if (!isset($path['here'])) {
861                                        $path['here'] = '/';
862                                }
863                                $output = $path['here'];
864                        } elseif (substr($url, 0, 1) === '/') {
865                                $output = $base . $url;
866                        } else {
867                                $output = $base . '/';
868                                foreach ($self->__prefixes as $prefix) {
869                                        if (isset($params[$prefix])) {
870                                                $output .= $prefix . '/';
871                                                break;
872                                        }
873                                }
874                                if (!empty($params['plugin']) && $params['plugin'] !== $params['controller']) {
875                                        $output .= Inflector::underscore($params['plugin']) . '/';
876                                }
877                                $output .= Inflector::underscore($params['controller']) . '/' . $url;
878                        }
879                        $output = str_replace('//', '/', $output);
880                }
881                if ($full && defined('FULL_BASE_URL')) {
882                        $output = FULL_BASE_URL . $output;
883                }
884                if (!empty($extension) && substr($output, -1) === '/') {
885                        $output = substr($output, 0, -1);
886                }
887
888                return $output . $extension . $self->queryString($q, array(), $escape) . $frag;
889        }
890
891/**
892 * A special fallback method that handles url arrays that cannot match
893 * any defined routes.
894 *
895 * @param array $url A url that didn't match any routes
896 * @return string A generated url for the array
897 * @access protected
898 * @see Router::url()
899 */
900        function _handleNoRoute($url) {
901                $named = $args = array();
902                $skip = array_merge(
903                        array('bare', 'action', 'controller', 'plugin', 'prefix'),
904                        $this->__prefixes
905                );
906
907                $keys = array_values(array_diff(array_keys($url), $skip));
908                $count = count($keys);
909
910                // Remove this once parsed URL parameters can be inserted into 'pass'
911                for ($i = 0; $i < $count; $i++) {
912                        if (is_numeric($keys[$i])) {
913                                $args[] = $url[$keys[$i]];
914                        } else {
915                                $named[$keys[$i]] = $url[$keys[$i]];
916                        }
917                }
918
919                list($args, $named) = array(Set::filter($args, true), Set::filter($named, true));
920                foreach ($this->__prefixes as $prefix) {
921                        if (!empty($url[$prefix])) {
922                                $url['action'] = str_replace($prefix . '_', '', $url['action']);
923                                break;
924                        }
925                }
926
927                if (empty($named) && empty($args) && (!isset($url['action']) || $url['action'] === 'index')) {
928                        $url['action'] = null;
929                }
930
931                $urlOut = array_filter(array($url['controller'], $url['action']));
932
933                if (isset($url['plugin'])) {
934                        array_unshift($urlOut, $url['plugin']);
935                }
936
937                foreach ($this->__prefixes as $prefix) {
938                        if (isset($url[$prefix])) {
939                                array_unshift($urlOut, $prefix);
940                                break;
941                        }
942                }
943                $output = implode('/', $urlOut);
944
945                if (!empty($args)) {
946                        $output .= '/' . implode('/', $args);
947                }
948
949                if (!empty($named)) {
950                        foreach ($named as $name => $value) {
951                                $output .= '/' . $name . $this->named['separator'] . $value;
952                        }
953                }
954                return $output;
955        }
956
957/**
958 * Takes an array of URL parameters and separates the ones that can be used as named arguments
959 *
960 * @param array $params Associative array of URL parameters.
961 * @param string $controller Name of controller being routed.  Used in scoping.
962 * @param string $action Name of action being routed.  Used in scoping.
963 * @return array
964 * @access public
965 * @static
966 */
967        function getNamedElements($params, $controller = null, $action = null) {
968                $self =& Router::getInstance();
969                $named = array();
970
971                foreach ($params as $param => $val) {
972                        if (isset($self->named['rules'][$param])) {
973                                $rule = $self->named['rules'][$param];
974                                if (Router::matchNamed($param, $val, $rule, compact('controller', 'action'))) {
975                                        $named[$param] = $val;
976                                        unset($params[$param]);
977                                }
978                        }
979                }
980                return array($named, $params);
981        }
982
983/**
984 * Return true if a given named $param's $val matches a given $rule depending on $context. Currently implemented
985 * rule types are controller, action and match that can be combined with each other.
986 *
987 * @param string $param The name of the named parameter
988 * @param string $val The value of the named parameter
989 * @param array $rule The rule(s) to apply, can also be a match string
990 * @param string $context An array with additional context information (controller / action)
991 * @return boolean
992 * @access public
993 * @static
994 */
995        function matchNamed($param, $val, $rule, $context = array()) {
996                if ($rule === true || $rule === false) {
997                        return $rule;
998                }
999                if (is_string($rule)) {
1000                        $rule = array('match' => $rule);
1001                }
1002                if (!is_array($rule)) {
1003                        return false;
1004                }
1005
1006                $controllerMatches = !isset($rule['controller'], $context['controller']) || in_array($context['controller'], (array)$rule['controller']);
1007                if (!$controllerMatches) {
1008                        return false;
1009                }
1010                $actionMatches = !isset($rule['action'], $context['action']) || in_array($context['action'], (array)$rule['action']);
1011                if (!$actionMatches) {
1012                        return false;
1013                }
1014                return (!isset($rule['match']) || preg_match('/' . $rule['match'] . '/', $val));
1015        }
1016
1017/**
1018 * Generates a well-formed querystring from $q
1019 *
1020 * @param mixed $q Query string
1021 * @param array $extra Extra querystring parameters.
1022 * @param bool $escape Whether or not to use escaped &
1023 * @return array
1024 * @access public
1025 * @static
1026 */
1027        function queryString($q, $extra = array(), $escape = false) {
1028                if (empty($q) && empty($extra)) {
1029                        return null;
1030                }
1031                $join = '&';
1032                if ($escape === true) {
1033                        $join = '&amp;';
1034                }
1035                $out = '';
1036
1037                if (is_array($q)) {
1038                        $q = array_merge($extra, $q);
1039                } else {
1040                        $out = $q;
1041                        $q = $extra;
1042                }
1043                $out .= http_build_query($q, null, $join);
1044                if (isset($out[0]) && $out[0] != '?') {
1045                        $out = '?' . $out;
1046                }
1047                return $out;
1048        }
1049
1050/**
1051 * Reverses a parsed parameter array into a string. Works similarly to Router::url(), but
1052 * Since parsed URL's contain additional 'pass' and 'named' as well as 'url.url' keys.
1053 * Those keys need to be specially handled in order to reverse a params array into a string url.
1054 *
1055 * This will strip out 'autoRender', 'bare', 'requested', and 'return' param names as those
1056 * are used for CakePHP internals and should not normally be part of an output url.
1057 *
1058 * @param array $param The params array that needs to be reversed.
1059 * @return string The string that is the reversed result of the array
1060 * @access public
1061 * @static
1062 */
1063        function reverse($params) {
1064                $pass = $params['pass'];
1065                $named = $params['named'];
1066                $url = $params['url'];
1067                unset(
1068                        $params['pass'], $params['named'], $params['paging'], $params['models'], $params['url'], $url['url'],
1069                        $params['autoRender'], $params['bare'], $params['requested'], $params['return']
1070                );
1071                $params = array_merge($params, $pass, $named);
1072                if (!empty($url)) {
1073                        $params['?'] = $url;
1074                }
1075                return Router::url($params);
1076        }
1077
1078/**
1079 * Normalizes a URL for purposes of comparison.  Will strip the base path off
1080 * and replace any double /'s.  It will not unify the casing and underscoring
1081 * of the input value.
1082 *
1083 * @param mixed $url URL to normalize Either an array or a string url.
1084 * @return string Normalized URL
1085 * @access public
1086 * @static
1087 */
1088        function normalize($url = '/') {
1089                if (is_array($url)) {
1090                        $url = Router::url($url);
1091                } elseif (preg_match('/^[a-z\-]+:\/\//', $url)) {
1092                        return $url;
1093                }
1094                $paths = Router::getPaths();
1095
1096                if (!empty($paths['base']) && stristr($url, $paths['base'])) {
1097                        $url = preg_replace('/^' . preg_quote($paths['base'], '/') . '/', '', $url, 1);
1098                }
1099                $url = '/' . $url;
1100
1101                while (strpos($url, '//') !== false) {
1102                        $url = str_replace('//', '/', $url);
1103                }
1104                $url = preg_replace('/(?:(\/$))/', '', $url);
1105
1106                if (empty($url)) {
1107                        return '/';
1108                }
1109                return $url;
1110        }
1111
1112/**
1113 * Returns the route matching the current request URL.
1114 *
1115 * @return CakeRoute Matching route object.
1116 * @access public
1117 * @static
1118 */
1119        function &requestRoute() {
1120                $self =& Router::getInstance();
1121                return $self->__currentRoute[0];
1122        }
1123
1124/**
1125 * Returns the route matching the current request (useful for requestAction traces)
1126 *
1127 * @return CakeRoute Matching route object.
1128 * @access public
1129 * @static
1130 */
1131        function &currentRoute() {
1132                $self =& Router::getInstance();
1133                return $self->__currentRoute[count($self->__currentRoute) - 1];
1134        }
1135
1136/**
1137 * Removes the plugin name from the base URL.
1138 *
1139 * @param string $base Base URL
1140 * @param string $plugin Plugin name
1141 * @return base url with plugin name removed if present
1142 * @access public
1143 * @static
1144 */
1145        function stripPlugin($base, $plugin = null) {
1146                if ($plugin != null) {
1147                        $base = preg_replace('/(?:' . $plugin . ')/', '', $base);
1148                        $base = str_replace('//', '', $base);
1149                        $pos1 = strrpos($base, '/');
1150                        $char = strlen($base) - 1;
1151
1152                        if ($pos1 === $char) {
1153                                $base = substr($base, 0, $char);
1154                        }
1155                }
1156                return $base;
1157        }
1158
1159/**
1160 * Instructs the router to parse out file extensions from the URL. For example,
1161 * http://example.com/posts.rss would yield an file extension of "rss".
1162 * The file extension itself is made available in the controller as
1163 * $this->params['url']['ext'], and is used by the RequestHandler component to
1164 * automatically switch to alternate layouts and templates, and load helpers
1165 * corresponding to the given content, i.e. RssHelper.
1166 *
1167 * A list of valid extension can be passed to this method, i.e. Router::parseExtensions('rss', 'xml');
1168 * If no parameters are given, anything after the first . (dot) after the last / in the URL will be
1169 * parsed, excluding querystring parameters (i.e. ?q=...).
1170 *
1171 * @access public
1172 * @return void
1173 * @static
1174 */
1175        function parseExtensions() {
1176                $self =& Router::getInstance();
1177                $self->__parseExtensions = true;
1178                if (func_num_args() > 0) {
1179                        $self->__validExtensions = func_get_args();
1180                }
1181        }
1182
1183/**
1184 * Takes a passed params and converts it to args
1185 *
1186 * @param array $params
1187 * @return array Array containing passed and named parameters
1188 * @access public
1189 * @static
1190 */
1191        function getArgs($args, $options = array()) {
1192                $self =& Router::getInstance();
1193                $pass = $named = array();
1194                $args = explode('/', $args);
1195
1196                $greedy = isset($options['greedy']) ? $options['greedy'] : $self->named['greedy'];
1197                $context = array();
1198                if (isset($options['context'])) {
1199                        $context = $options['context'];
1200                }
1201                $rules = $self->named['rules'];
1202                if (isset($options['named'])) {
1203                        $greedy = isset($options['greedy']) && $options['greedy'] === true;
1204                        foreach ((array)$options['named'] as $key => $val) {
1205                                if (is_numeric($key)) {
1206                                        $rules[$val] = true;
1207                                        continue;
1208                                }
1209                                $rules[$key] = $val;
1210                        }
1211                }
1212
1213                foreach ($args as $param) {
1214                        if (empty($param) && $param !== '0' && $param !== 0) {
1215                                continue;
1216                        }
1217
1218                        $separatorIsPresent = strpos($param, $self->named['separator']) !== false;
1219                        if ((!isset($options['named']) || !empty($options['named'])) && $separatorIsPresent) {
1220                                list($key, $val) = explode($self->named['separator'], $param, 2);
1221                                $hasRule = isset($rules[$key]);
1222                                $passIt = (!$hasRule && !$greedy) || ($hasRule && !$self->matchNamed($key, $val, $rules[$key], $context));
1223                                if ($passIt) {
1224                                        $pass[] = $param;
1225                                } else {
1226                                        $named[$key] = $val;
1227                                }
1228                        } else {
1229                                $pass[] = $param;
1230                        }
1231                }
1232                return compact('pass', 'named');
1233        }
1234}
1235
1236/**
1237 * A single Route used by the Router to connect requests to
1238 * parameter maps.
1239 *
1240 * Not normally created as a standalone.  Use Router::connect() to create
1241 * Routes for your application.
1242 *
1243 * @package cake.libs
1244 * @since 1.3.0
1245 * @see Router::connect()
1246 */
1247class CakeRoute {
1248
1249/**
1250 * An array of named segments in a Route.
1251 * `/:controller/:action/:id` has 3 key elements
1252 *
1253 * @var array
1254 * @access public
1255 */
1256        var $keys = array();
1257
1258/**
1259 * An array of additional parameters for the Route.
1260 *
1261 * @var array
1262 * @access public
1263 */
1264        var $options = array();
1265
1266/**
1267 * Default parameters for a Route
1268 *
1269 * @var array
1270 * @access public
1271 */
1272        var $defaults = array();
1273
1274/**
1275 * The routes template string.
1276 *
1277 * @var string
1278 * @access public
1279 */
1280        var $template = null;
1281
1282/**
1283 * Is this route a greedy route?  Greedy routes have a `/*` in their
1284 * template
1285 *
1286 * @var string
1287 * @access protected
1288 */
1289        var $_greedy = false;
1290
1291/**
1292 * The compiled route regular expresssion
1293 *
1294 * @var string
1295 * @access protected
1296 */
1297        var $_compiledRoute = null;
1298
1299/**
1300 * HTTP header shortcut map.  Used for evaluating header-based route expressions.
1301 *
1302 * @var array
1303 * @access private
1304 */
1305        var $__headerMap = array(
1306                'type' => 'content_type',
1307                'method' => 'request_method',
1308                'server' => 'server_name'
1309        );
1310
1311/**
1312 * Constructor for a Route
1313 *
1314 * @param string $template Template string with parameter placeholders
1315 * @param array $defaults Array of defaults for the route.
1316 * @param string $params Array of parameters and additional options for the Route
1317 * @return void
1318 * @access public
1319 */
1320        function CakeRoute($template, $defaults = array(), $options = array()) {
1321                $this->template = $template;
1322                $this->defaults = (array)$defaults;
1323                $this->options = (array)$options;
1324        }
1325
1326/**
1327 * Check if a Route has been compiled into a regular expression.
1328 *
1329 * @return boolean
1330 * @access public
1331 */
1332        function compiled() {
1333                return !empty($this->_compiledRoute);
1334        }
1335
1336/**
1337 * Compiles the route's regular expression.  Modifies defaults property so all necessary keys are set
1338 * and populates $this->names with the named routing elements.
1339 *
1340 * @return array Returns a string regular expression of the compiled route.
1341 * @access public
1342 */
1343        function compile() {
1344                if ($this->compiled()) {
1345                        return $this->_compiledRoute;
1346                }
1347                $this->_writeRoute();
1348                return $this->_compiledRoute;
1349        }
1350
1351/**
1352 * Builds a route regular expression.  Uses the template, defaults and options
1353 * properties to compile a regular expression that can be used to parse request strings.
1354 *
1355 * @return void
1356 * @access protected
1357 */
1358        function _writeRoute() {
1359                if (empty($this->template) || ($this->template === '/')) {
1360                        $this->_compiledRoute = '#^/*$#';
1361                        $this->keys = array();
1362                        return;
1363                }
1364                $route = $this->template;
1365                $names = $routeParams = array();
1366                $parsed = preg_quote($this->template, '#');
1367                $parsed = str_replace('\\-', '-', $parsed);
1368
1369                preg_match_all('#:([A-Za-z0-9_-]+[A-Z0-9a-z])#', $parsed, $namedElements);
1370                foreach ($namedElements[1] as $i => $name) {
1371                        $search = '\\' . $namedElements[0][$i];
1372                        if (isset($this->options[$name])) {
1373                                $option = null;
1374                                if ($name !== 'plugin' && array_key_exists($name, $this->defaults)) {
1375                                        $option = '?';
1376                                }
1377                                $slashParam = '/\\' . $namedElements[0][$i];
1378                                if (strpos($parsed, $slashParam) !== false) {
1379                                        $routeParams[$slashParam] = '(?:/(' . $this->options[$name] . ')' . $option . ')' . $option;
1380                                } else {
1381                                        $routeParams[$search] = '(?:(' . $this->options[$name] . ')' . $option . ')' . $option;
1382                                }
1383                        } else {
1384                                $routeParams[$search] = '(?:([^/]+))';
1385                        }
1386                        $names[] = $name;
1387                }
1388                if (preg_match('#\/\*$#', $route, $m)) {
1389                        $parsed = preg_replace('#/\\\\\*$#', '(?:/(?P<_args_>.*))?', $parsed);
1390                        $this->_greedy = true;
1391                }
1392                krsort($routeParams);
1393                $parsed = str_replace(array_keys($routeParams), array_values($routeParams), $parsed);
1394                $this->_compiledRoute = '#^' . $parsed . '[/]*$#';
1395                $this->keys = $names;
1396        }
1397
1398/**
1399 * Checks to see if the given URL can be parsed by this route.
1400 * If the route can be parsed an array of parameters will be returned; if not,
1401 * false will be returned. String urls are parsed if they match a routes regular expression.
1402 *
1403 * @param string $url The url to attempt to parse.
1404 * @return mixed Boolean false on failure, otherwise an array or parameters
1405 * @access public
1406 */
1407        function parse($url) {
1408                if (!$this->compiled()) {
1409                        $this->compile();
1410                }
1411                if (!preg_match($this->_compiledRoute, $url, $parsed)) {
1412                        return false;
1413                } else {
1414                        foreach ($this->defaults as $key => $val) {
1415                                if ($key[0] === '[' && preg_match('/^\[(\w+)\]$/', $key, $header)) {
1416                                        if (isset($this->__headerMap[$header[1]])) {
1417                                                $header = $this->__headerMap[$header[1]];
1418                                        } else {
1419                                                $header = 'http_' . $header[1];
1420                                        }
1421
1422                                        $val = (array)$val;
1423                                        $h = false;
1424
1425                                        foreach ($val as $v) {
1426                                                if (env(strtoupper($header)) === $v) {
1427                                                        $h = true;
1428                                                }
1429                                        }
1430                                        if (!$h) {
1431                                                return false;
1432                                        }
1433                                }
1434                        }
1435                        array_shift($parsed);
1436                        $route = array();
1437                        foreach ($this->keys as $i => $key) {
1438                                if (isset($parsed[$i])) {
1439                                        $route[$key] = $parsed[$i];
1440                                }
1441                        }
1442                        $route['pass'] = $route['named'] = array();
1443                        $route += $this->defaults;
1444                        if (isset($parsed['_args_'])) {
1445                                $route['_args_'] = $parsed['_args_'];
1446                        }
1447                        foreach ($route as $key => $value) {
1448                                if (is_integer($key)) {
1449                                        $route['pass'][] = $value;
1450                                        unset($route[$key]);
1451                                }
1452                        }
1453                        return $route;
1454                }
1455        }
1456
1457/**
1458 * Apply persistent parameters to a url array. Persistant parameters are a special
1459 * key used during route creation to force route parameters to persist when omitted from
1460 * a url array.
1461 *
1462 * @param array $url The array to apply persistent parameters to.
1463 * @param array $params An array of persistent values to replace persistent ones.
1464 * @return array An array with persistent parameters applied.
1465 * @access public
1466 */
1467        function persistParams($url, $params) {
1468                foreach ($this->options['persist'] as $persistKey) {
1469                        if (array_key_exists($persistKey, $params) && !isset($url[$persistKey])) {
1470                                $url[$persistKey] = $params[$persistKey];
1471                        }
1472                }
1473                return $url;
1474        }
1475
1476/**
1477 * Attempt to match a url array.  If the url matches the route parameters and settings, then
1478 * return a generated string url.  If the url doesn't match the route parameters, false will be returned.
1479 * This method handles the reverse routing or conversion of url arrays into string urls.
1480 *
1481 * @param array $url An array of parameters to check matching with.
1482 * @return mixed Either a string url for the parameters if they match or false.
1483 * @access public
1484 */
1485        function match($url) {
1486                if (!$this->compiled()) {
1487                        $this->compile();
1488                }
1489                $defaults = $this->defaults;
1490
1491                if (isset($defaults['prefix'])) {
1492                        $url['prefix'] = $defaults['prefix'];
1493                }
1494
1495                //check that all the key names are in the url
1496                $keyNames = array_flip($this->keys);
1497                if (array_intersect_key($keyNames, $url) != $keyNames) {
1498                        return false;
1499                }
1500
1501                $diffUnfiltered = Set::diff($url, $defaults);
1502                $diff = array();
1503
1504                foreach ($diffUnfiltered as $key => $var) {
1505                        if ($var === 0 || $var === '0' || !empty($var)) {
1506                                $diff[$key] = $var;
1507                        }
1508                }
1509
1510                //if a not a greedy route, no extra params are allowed.
1511                if (!$this->_greedy && array_diff_key($diff, $keyNames) != array()) {
1512                        return false;
1513                }
1514
1515                //remove defaults that are also keys. They can cause match failures
1516                foreach ($this->keys as $key) {
1517                        unset($defaults[$key]);
1518                }
1519                $filteredDefaults = array_filter($defaults);
1520
1521                //if the difference between the url diff and defaults contains keys from defaults its not a match
1522                if (array_intersect_key($filteredDefaults, $diffUnfiltered) !== array()) {
1523                        return false;
1524                }
1525
1526                $passedArgsAndParams = array_diff_key($diff, $filteredDefaults, $keyNames);
1527                list($named, $params) = Router::getNamedElements($passedArgsAndParams, $url['controller'], $url['action']);
1528
1529                //remove any pass params, they have numeric indexes, skip any params that are in the defaults
1530                $pass = array();
1531                $i = 0;
1532                while (isset($url[$i])) {
1533                        if (!isset($diff[$i])) {
1534                                $i++;
1535                                continue;
1536                        }
1537                        $pass[] = $url[$i];
1538                        unset($url[$i], $params[$i]);
1539                        $i++;
1540                }
1541
1542                //still some left over parameters that weren't named or passed args, bail.
1543                if (!empty($params)) {
1544                        return false;
1545                }
1546
1547                //check patterns for routed params
1548                if (!empty($this->options)) {
1549                        foreach ($this->options as $key => $pattern) {
1550                                if (array_key_exists($key, $url) && !preg_match('#^' . $pattern . '$#', $url[$key])) {
1551                                        return false;
1552                                }
1553                        }
1554                }
1555                return $this->_writeUrl(array_merge($url, compact('pass', 'named')));
1556        }
1557
1558/**
1559 * Converts a matching route array into a url string. Composes the string url using the template
1560 * used to create the route.
1561 *
1562 * @param array $params The params to convert to a string url.
1563 * @return string Composed route string.
1564 * @access protected
1565 */
1566        function _writeUrl($params) {
1567                if (isset($params['prefix'], $params['action'])) {
1568                        $params['action'] = str_replace($params['prefix'] . '_', '', $params['action']);
1569                        unset($params['prefix']);
1570                }
1571
1572                if (is_array($params['pass'])) {
1573                        $params['pass'] = implode('/', $params['pass']);
1574                }
1575
1576                $instance =& Router::getInstance();
1577                $separator = $instance->named['separator'];
1578
1579                if (!empty($params['named']) && is_array($params['named'])) {
1580                        $named = array();
1581                        foreach ($params['named'] as $key => $value) {
1582                                $named[] = $key . $separator . $value;
1583                        }
1584                        $params['pass'] = $params['pass'] . '/' . implode('/', $named);
1585                }
1586                $out = $this->template;
1587
1588                $search = $replace = array();
1589                foreach ($this->keys as $key) {
1590                        $string = null;
1591                        if (isset($params[$key])) {
1592                                $string = $params[$key];
1593                        } elseif (strpos($out, $key) != strlen($out) - strlen($key)) {
1594                                $key .= '/';
1595                        }
1596                        $search[] = ':' . $key;
1597                        $replace[] = $string;
1598                }
1599                $out = str_replace($search, $replace, $out);
1600
1601                if (strpos($this->template, '*')) {
1602                        $out = str_replace('*', $params['pass'], $out);
1603                }
1604                $out = str_replace('//', '/', $out);
1605                return $out;
1606        }
1607}
1608
1609/**
1610 * Plugin short route, that copies the plugin param to the controller parameters
1611 * It is used for supporting /:plugin routes.
1612 *
1613 * @package cake.libs
1614 */
1615class PluginShortRoute extends CakeRoute {
1616
1617/**
1618 * Parses a string url into an array.  If a plugin key is found, it will be copied to the
1619 * controller parameter
1620 *
1621 * @param string $url The url to parse
1622 * @return mixed false on failure, or an array of request parameters
1623 */
1624        function parse($url) {
1625                $params = parent::parse($url);
1626                if (!$params) {
1627                        return false;
1628                }
1629                $params['controller'] = $params['plugin'];
1630                return $params;
1631        }
1632
1633/**
1634 * Reverse route plugin shortcut urls.  If the plugin and controller
1635 * are not the same the match is an auto fail.
1636 *
1637 * @param array $url Array of parameters to convert to a string.
1638 * @return mixed either false or a string url.
1639 */
1640        function match($url) {
1641                if (isset($url['controller']) && isset($url['plugin']) && $url['plugin'] != $url['controller']) {
1642                        return false;
1643                }
1644                $this->defaults['controller'] = $url['controller'];
1645                $result = parent::match($url);
1646                unset($this->defaults['controller']);
1647                return $result;
1648        }
1649}
Note: See TracBrowser for help on using the repository browser.