1. sfPatternRouting.class.php
  2. /**
 * sfPatternRouting class controls the generation and parsing of URLs.
 *
 * It parses and generates URLs by delegating the work to an array of sfRoute objects.
 *
 * @package    symfony
 * @subpackage routing
 * @author     Fabien Potencier 
 * @version    SVN: $Id: sfPatternRouting.class.php 24061 2009-11-16 22:35:03Z FabianLange $
 */
  3. class sfPatternRouting extends sfRouting
  4. {
  5.   protected
  6.     $currentRouteName   = null,
  7.     $currentInternalUri = array(),
  8.     $routes             = array(),
  9.     $defaultParamsDirty = false,
  10.     $cacheData          = array(),
  11.     $cacheChanged       = false;
  13.   /**
  14.    * Initializes this Routing.
  15.    *
  16.    * Available options:
  17.    *
  18.    *  * suffix:                           The default suffix
  19.    *  * variable_prefixes:                An array of characters that starts a variable name (: by default)
  20.    *  * segment_separators:               An array of allowed characters for segment separators (/ and . by default)
  21.    *  * variable_regex:                   A regex that match a valid variable name ([\w\d_]+ by default)
  22.    *  * generate_shortest_url:            Whether to generate the shortest URL possible (true by default)
  23.    *  * extra_parameters_as_query_string: Whether to generate extra parameters as a query string
  24.    *  * lookup_cache_dedicated_keys:      Whether to use dedicated keys for parse/generate cache (false by default)
  25.    *                                      WARNING: When this option is activated, do not use sfFileCache; use a fast access
  26.    *                                      cache backend (like sfAPCCache).
  27.    *
  28.    * @see sfRouting
  29.    */
  30.   public function initialize(sfEventDispatcher $dispatcher, sfCache $cache = null, $options = array())
  31.   {
  32.     $options = array_merge(array(
  33.       'variable_prefixes'                => array(':'),
  34.       'segment_separators'               => array('/', '.'),
  35.       'variable_regex'                   => '[\w\d_]+',
  36.       'load_configuration'               => false,
  37.       'suffix'                           => '',
  38.       'generate_shortest_url'            => true,
  39.       'extra_parameters_as_query_string' => true,
  40.       'lookup_cache_dedicated_keys'      => false,
  41.     ), $options);
  43.     // for BC
  44.     if ('.' == $options['suffix'])
  45.     {
  46.       $options['suffix'] = '';
  47.     }
  49.     parent::initialize($dispatcher, $cache, $options);
  51.     if (null !== $this->cache && !$options['lookup_cache_dedicated_keys'] && $cacheData = $this->cache->get('symfony.routing.data'))
  52.     {
  53.       $this->cacheData = unserialize($cacheData);
  54.     }
  55.   }
  57.   /**
  58.    * @see sfRouting
  59.    */
  60.   public function loadConfiguration()
  61.   {
  62.     if ($this->options['load_configuration'] && $config = $this->getConfigFilename())
  63.     {
  64.       include($config);
  65.     }
  67.     parent::loadConfiguration();
  68.   }
  70.   /**
  71.    * Added for better performance. We need to ensure that changed default parameters
  72.    * are set, but resetting them everytime wastes many cpu cycles
  73.    */
  74.   protected function ensureDefaultParametersAreSet()
  75.   {
  76.     if ($this->defaultParamsDirty)
  77.     {
  78.       foreach ($this->routes as $route)
  79.       {
  80.         $route->setDefaultParameters($this->defaultParameters);
  81.       }
  82.       $this->defaultParamsDirty = false;
  83.     }
  84.   }
  86.   /**
  87.    * @see sfRouting
  88.    */
  89.   public function setDefaultParameter($key, $value)
  90.   {
  91.     parent::setDefaultParameter($key, $value);
  92.     $this->defaultParamsDirty = true;
  93.   }
  95.   /**
  96.    * @see sfRouting
  97.    */
  98.   public function setDefaultParameters($parameters)
  99.   {
  100.     parent::setDefaultParameters($parameters);
  101.     $this->defaultParamsDirty = true;
  102.   }
  104.   protected function getConfigFileName()
  105.   {
  106.     return sfContext::getInstance()->getConfigCache()->checkConfig('config/routing.yml', true);
  107.   }
  109.   /**
  110.    * @see sfRouting
  111.    */
  112.   public function getCurrentInternalUri($withRouteName = false)
  113.   {
  114.     return null === $this->currentRouteName ? null : $this->currentInternalUri[$withRouteName ? 0 : 1];
  115.   }
  117.   /**
  118.    * Gets the current route name.
  119.    *
  120.    * @return string The route name
  121.    */
  122.   public function getCurrentRouteName()
  123.   {
  124.     return $this->currentRouteName;
  125.   }
  127.   /**
  128.    * @see sfRouting
  129.    */
  130.   public function getRoutes()
  131.   {
  132.     return $this->routes;
  133.   }
  135.   /**
  136.    * @see sfRouting
  137.    */
  138.   public function setRoutes($routes)
  139.   {
  140.     foreach ($routes as $name => $route)
  141.     {
  142.       $this->connect($name, $route);
  143.     }
  144.   }
  146.   /**
  147.    * @see sfRouting
  148.    */
  149.   public function hasRoutes()
  150.   {
  151.     return count($this->routes) ? true : false;
  152.   }
  154.   /**
  155.    * @see sfRouting
  156.    */
  157.   public function clearRoutes()
  158.   {
  159.     if ($this->options['logging'])
  160.     {
  161.       $this->dispatcher->notify(new sfEvent($this, 'application.log', array('Clear all current routes')));
  162.     }
  164.     $this->routes = array();
  165.   }
  167.   /**
  168.    * Returns true if the route name given is defined.
  169.    *
  170.    * @param  string $name  The route name
  171.    *
  172.    * @return boolean
  173.    */
  174.   public function hasRouteName($name)
  175.   {
  176.     return isset($this->routes[$name]) ? true : false;
  177.   }
  179.   /**
  180.    * Adds a new route at the beginning of the current list of routes.
  181.    *
  182.    * @see connect
  183.    */
  184.   public function prependRoute($name, $route)
  185.   {
  186.     $routes = $this->routes;
  187.     $this->routes = array();
  188.     $this->connect($name, $route);
  189.     $this->routes = array_merge($this->routes, $routes);
  190.   }
  192.   /**
  193.    * Adds a new route.
  194.    *
  195.    * Alias for the connect method.
  196.    *
  197.    * @see connect
  198.    */
  199.   public function appendRoute($name, $route)
  200.   {
  201.     return $this->connect($name, $route);
  202.   }
  204.   /**
  205.    * Adds a new route before a given one in the current list of routes.
  206.    *
  207.    * @see connect
  208.    */
  209.   public function insertRouteBefore($pivot, $name, $route)
  210.   {
  211.     if (!isset($this->routes[$pivot]))
  212.     {
  213.       throw new sfConfigurationException(sprintf('Unable to insert route "%s" before inexistent route "%s".', $name, $pivot));
  214.     }
  216.     $routes = $this->routes;
  217.     $this->routes = array();
  218.     $newroutes = array();
  219.     foreach ($routes as $key => $value)
  220.     {
  221.       if ($key == $pivot)
  222.       {
  223.         $this->connect($name, $route);
  224.         $newroutes = array_merge($newroutes, $this->routes);
  225.       }
  226.       $newroutes[$key] = $value;
  227.     }
  229.     $this->routes = $newroutes;
  230.   }
  232.   /**
  233.    * Adds a new route at the end of the current list of routes.
  234.    *
  235.    * A route string is a string with 2 special constructions:
  236.    * - :string: :string denotes a named paramater (available later as $request->getParameter('string'))
  237.    * - *: * match an indefinite number of parameters in a route
  238.    *
  239.    * Here is a very common rule in a symfony project:
  240.    *
  241.    * <code>
  242.    * $r->connect('default', new sfRoute('/:module/:action/*'));
  243.    * </code>
  244.    *
  245.    * @param  string  $name  The route name
  246.    * @param  sfRoute $route A sfRoute instance
  247.    *
  248.    * @return array  current routes
  249.    */
  250.   public function connect($name, $route)
  251.   {
  252.     $routes = $route instanceof sfRouteCollection ? $route : array($name => $route);
  253.     foreach (self::flattenRoutes($routes) as $name => $route)
  254.     {
  255.       $this->routes[$name] = $route;
  256.       $this->configureRoute($route);
  258.       if ($this->options['logging'])
  259.       {
  260.         $this->dispatcher->notify(new sfEvent($this, 'application.log', array(sprintf('Connect %s "%s" (%s)', get_class($route), $name, $route->getPattern()))));
  261.       }
  262.     }
  263.   }
  265.   public function configureRoute(sfRoute $route)
  266.   {
  267.     $route->setDefaultParameters($this->defaultParameters);
  268.     $route->setDefaultOptions($this->options);
  269.   }
  271.   /**
  272.    * @see sfRouting
  273.    */
  274.   public function generate($name, $params = array(), $absolute = false)
  275.   {
  276.     // fetch from cache
  277.     if (null !== $this->cache)
  278.     {
  279.       $cacheKey = 'generate_'.$name.'_'.md5(serialize(array_merge($this->defaultParameters, $params))).'_'.md5(serialize($this->options['context']));
  280.       if ($this->options['lookup_cache_dedicated_keys'] && $url = $this->cache->get('symfony.routing.data.'.$cacheKey))
  281.       {
  282.         return $this->fixGeneratedUrl($url, $absolute);
  283.       }
  284.       elseif (isset($this->cacheData[$cacheKey]))
  285.       {
  286.         return $this->fixGeneratedUrl($this->cacheData[$cacheKey], $absolute);
  287.       }
  288.     }
  290.     if ($name)
  291.     {
  292.       // named route
  293.       if (!isset($this->routes[$name]))
  294.       {
  295.         throw new sfConfigurationException(sprintf('The route "%s" does not exist.', $name));
  296.       }
  297.       $route = $this->routes[$name];      $this->ensureDefaultParametersAreSet();
  298.     }
  299.     else
  300.     {
  301.       // find a matching route
  302.       if (false === $route = $this->getRouteThatMatchesParameters($params, $this->options['context']))
  303.       {
  304.         throw new sfConfigurationException(sprintf('Unable to find a matching route to generate url for params "%s".', is_object($params) ? 'Object('.get_class($params).')' : str_replace("\n", '', var_export($params, true))));
  305.       }
  306.     }
  308.     $url = $route->generate($params, $this->options['context'], $absolute);
  310.     // store in cache
  311.     if (null !== $this->cache)
  312.     {
  313.       if ($this->options['lookup_cache_dedicated_keys'])
  314.       {
  315.         $this->cache->set('symfony.routing.data.'.$cacheKey, $url);
  316.       }
  317.       else
  318.       {
  319.         $this->cacheChanged = true;
  320.         $this->cacheData[$cacheKey] = $url;
  321.       }
  322.     }
  324.     return $this->fixGeneratedUrl($url, $absolute);
  325.   }
  327.   /**
  328.    * @see sfRouting
  329.    */
  330.   public function parse($url)
  331.   {
  332.     if (false === $info = $this->findRoute($url))
  333.     {
  334.       $this->currentRouteName = null;
  335.       $this->currentInternalUri = array();
  337.       return false;
  338.     }
  340.     if ($this->options['logging'])
  341.     {
  342.       $this->dispatcher->notify(new sfEvent($this, 'application.log', array(sprintf('Match route "%s" (%s) for %s with parameters %s', $info['name'], $info['pattern'], $url, str_replace("\n", '', var_export($info['parameters'], true))))));
  343.     }
  345.     // store the current internal URI
  346.     $this->updateCurrentInternalUri($info['name'], $info['parameters']);
  348.     $route = $this->routes[$info['name']];
  350.     $this->ensureDefaultParametersAreSet();
  352.     $route->bind($this->options['context'], $info['parameters']);
  353.     $info['parameters']['_sf_route'] = $route;
  355.     return $info['parameters'];
  356.   }
  358.   protected function updateCurrentInternalUri($name, array $parameters)
  359.   {
  360.     // store the route name
  361.     $this->currentRouteName = $name;
  363.     $internalUri = array('@'.$this->currentRouteName, $parameters['module'].'/'.$parameters['action']);
  364.     unset($parameters['module'], $parameters['action']);
  366.     $params = array();
  367.     foreach ($parameters as $key => $value)
  368.     {
  369.       $params[] = $key.'='.$value;
  370.     }
  372.     // sort to guaranty unicity
  373.     sort($params);
  375.     $params = $params ? '?'.implode('&', $params) : '';
  377.     $this->currentInternalUri = array($internalUri[0].$params, $internalUri[1].$params);
  378.   }
  380.   /**
  381.    * Finds a matching route for given URL.
  382.    *
  383.    * Returns false if no route matches.
  384.    *
  385.    * Returned array contains:
  386.    *
  387.    *  - name:       name or alias of the route that matched
  388.    *  - pattern:    the compiled pattern of the route that matched
  389.    *  - parameters: array containing key value pairs of the request parameters including defaults
  390.    *
  391.    * @param  string $url     URL to be parsed
  392.    *
  393.    * @return array|false  An array with routing information or false if no route matched
  394.    */
  395.   public function findRoute($url)
  396.   {
  397.     $url = $this->normalizeUrl($url);
  399.     // fetch from cache
  400.     if (null !== $this->cache)
  401.     {
  402.       $cacheKey = 'parse_'.$url.'_'.md5(serialize($this->options['context']));
  403.       if ($this->options['lookup_cache_dedicated_keys'] && $info = $this->cache->get('symfony.routing.data.'.$cacheKey))
  404.       {
  405.         return unserialize($info);
  406.       }
  407.       elseif (isset($this->cacheData[$cacheKey]))
  408.       {
  409.         return $this->cacheData[$cacheKey];
  410.       }
  411.     }
  413.     $info = $this->getRouteThatMatchesUrl($url);
  415.     // store in cache
  416.     if (null !== $this->cache)
  417.     {
  418.       if ($this->options['lookup_cache_dedicated_keys'])
  419.       {
  420.         $this->cache->set('symfony.routing.data.'.$cacheKey, serialize($info));
  421.       }
  422.       else
  423.       {
  424.         $this->cacheChanged = true;
  425.         $this->cacheData[$cacheKey] = $info;
  426.       }
  427.     }
  429.     return $info;
  430.   }
  432.   static public function flattenRoutes($routes)
  433.   {
  434.     $flattenRoutes = array();
  435.     foreach ($routes as $name => $route)
  436.     {
  437.       if ($route instanceof sfRouteCollection)
  438.       {
  439.         $flattenRoutes = array_merge($flattenRoutes, self::flattenRoutes($route));
  440.       }
  441.       else
  442.       {
  443.         $flattenRoutes[$name] = $route;
  444.       }
  445.     }
  447.     return $flattenRoutes;
  448.   }
  450.   protected function getRouteThatMatchesUrl($url)
  451.   {
  452.     $this->ensureDefaultParametersAreSet();
  453.     foreach ($this->routes as $name => $route)
  454.     {
  455.       if (false === $parameters = $route->matchesUrl($url, $this->options['context']))
  456.       {
  457.         continue;
  458.       }
  460.       return array('name' => $name, 'pattern' => $route->getPattern(), 'parameters' => $parameters);
  461.     }
  463.     return false;
  464.   }
  466.   protected function getRouteThatMatchesParameters($parameters)
  467.   {
  468.     $this->ensureDefaultParametersAreSet();
  469.     foreach ($this->routes as $route)
  470.     {
  471.       if ($route->matchesParameters($parameters, $this->options['context']))
  472.       {
  473.         return $route;
  474.       }
  475.     }
  477.     return false;
  478.   }
  480.   protected function normalizeUrl($url)
  481.   {
  482.     // an URL should start with a '/', mod_rewrite doesn't respect that, but no-mod_rewrite version does.
  483.     if ('/' != substr($url, 0, 1))
  484.     {
  485.       $url = '/'.$url;
  486.     }
  488.     // we remove the query string
  489.     if (false !== $pos = strpos($url, '?'))
  490.     {
  491.       $url = substr($url, 0, $pos);
  492.     }
  494.     // remove multiple /
  495.     $url = preg_replace('#/+#', '/', $url);
  497.     return $url;
  498.   }
  500.   /**
  501.    * @see sfRouting
  502.    */
  503.   public function shutdown()
  504.   {
  505.     if (null !== $this->cache && $this->cacheChanged)
  506.     {
  507.       $this->cacheChanged = false;
  508.       $this->cache->set('symfony.routing.data', serialize($this->cacheData));
  509.     }
  510.   }
  511. }
Debug toolbar