1. sfRouting.class.php
  2. /**
 * sfRouting class controls the generation and parsing of URLs.
 *
 * @package    symfony
 * @subpackage routing
 * @author     Fabien Potencier 
 * @version    SVN: $Id: sfRouting.class.php 23810 2009-11-12 11:07:44Z Kris.Wallsmith $
 */
  3. abstract class sfRouting
  4. {
  5.   protected
  6.     $dispatcher        = null,
  7.     $cache             = null,
  8.     $defaultParameters = array(),
  9.     $options           = array();
  11.   /**
  12.    * Class constructor.
  13.    *
  14.    * @see initialize()
  15.    */
  16.   public function __construct(sfEventDispatcher $dispatcher, sfCache $cache = null, $options = array())
  17.   {
  18.     $this->initialize($dispatcher, $cache, $options);
  20.     if (!isset($this->options['auto_shutdown']) || $this->options['auto_shutdown'])
  21.     {
  22.       register_shutdown_function(array($this, 'shutdown'));
  23.     }
  24.   }
  26.   /**
  27.    * Returns the routing cache object.
  28.    *
  29.    * @return sfCache A sfCache instance or null
  30.    */
  31.   public function getCache()
  32.   {
  33.     return $this->cache;
  34.   }
  36.   /**
  37.    * Initializes this sfRouting instance.
  38.    *
  39.    * Available options:
  40.    *
  41.    *  * default_module: The default module name
  42.    *  * default_action: The default action name
  43.    *  * logging:        Whether to log or not (false by default)
  44.    *  * debug:          Whether to cache or not (false by default)
  45.    *  * context:        An array of context variables to help URL matching and generation
  46.    *
  47.    * @param sfEventDispatcher $dispatcher  An sfEventDispatcher instance
  48.    * @param sfCache           $cache       An sfCache instance
  49.    * @param array             $options     An associative array of initialization options.
  50.    */
  51.   public function initialize(sfEventDispatcher $dispatcher, sfCache $cache = null, $options = array())
  52.   {
  53.     $this->dispatcher = $dispatcher;
  55.     $options['debug'] = isset($options['debug']) ? (boolean) $options['debug'] : false;
  57.     // disable caching when in debug mode
  58.     $this->cache = $options['debug'] ? null : $cache;
  60.     $this->setDefaultParameter('module', isset($options['default_module']) ? $options['default_module'] : 'default');
  61.     $this->setDefaultParameter('action', isset($options['default_action']) ? $options['default_action'] : 'index');
  63.     if (!isset($options['logging']))
  64.     {
  65.       $options['logging'] = false;
  66.     }
  68.     if (!isset($options['context']))
  69.     {
  70.       $options['context'] = array();
  71.     }
  73.     $this->options = $options;
  75.     $this->dispatcher->connect('user.change_culture', array($this, 'listenToChangeCultureEvent'));
  76.     $this->dispatcher->connect('request.filter_parameters', array($this, 'filterParametersEvent'));
  78.     $this->loadConfiguration();
  79.   }
  81.   /**
  82.    * Returns the options.
  83.    *
  84.    * @return array An array of options
  85.    */
  86.   public function getOptions()
  87.   {
  88.     return $this->options;
  89.   }
  91.   /**
  92.    * Loads routing configuration.
  93.    *
  94.    * This methods notifies a routing.load_configuration event.
  95.    */
  96.   public function loadConfiguration()
  97.   {
  98.     $this->dispatcher->notify(new sfEvent($this, 'routing.load_configuration'));
  99.   }
  101.   /**
  102.    * Gets the internal URI for the current request.
  103.    *
  104.    * @param  bool $with_route_name  Whether to give an internal URI with the route name (@route)
  105.    *                                or with the module/action pair
  106.    *
  107.    * @return string The current internal URI
  108.    */
  109.   abstract public function getCurrentInternalUri($with_route_name = false);
  111.   /**
  112.    * Gets the current compiled route array.
  113.    *
  114.    * @return array The route array
  115.    */
  116.   abstract public function getRoutes();
  118.   /**
  119.    * Sets the compiled route array.
  120.    *
  121.    * @param  array $routes  The route array
  122.    *
  123.    * @return array The route array
  124.    */
  125.   abstract public function setRoutes($routes);
  127.   /**
  128.    * Returns true if this instance has some routes.
  129.    *
  130.    * @return bool
  131.    */
  132.   abstract public function hasRoutes();
  134.   /**
  135.    * Clears all current routes.
  136.    */
  137.   abstract public function clearRoutes();
  139.  /**
  140.   * Generates a valid URLs for parameters.
  141.   *
  142.   * @param  string  $name      The route name
  143.   * @param  array   $params    The parameter values
  144.   * @param  Boolean $absolute  Whether to generate an absolute URL
  145.   *
  146.   * @return string The generated URL
  147.   */
  148.   abstract public function generate($name, $params = array(), $absolute = false);
  150.  /**
  151.   * Parses a URL to find a matching route and sets internal state.
  152.   *
  153.   * Returns false if no route match the URL.
  154.   *
  155.   * @param  string $url  URL to be parsed
  156.   *
  157.   * @return array|false  An array of parameters or false if the route does not match
  158.   */
  159.   abstract public function parse($url);
  161.   /**
  162.    * Gets the default parameters for URL generation.
  163.    *
  164.    * @return array  An array of default parameters
  165.    */
  166.   public function getDefaultParameters()
  167.   {
  168.     return $this->defaultParameters;
  169.   }
  171.   /**
  172.    * Gets a default parameter.
  173.    *
  174.    * @param  string $key    The key
  175.    *
  176.    * @return string The value
  177.    */
  178.   public function getDefaultParameter($key)
  179.   {
  180.     return isset($this->defaultParameters[$key]) ? $this->defaultParameters[$key] : null;
  181.   }
  183.   /**
  184.    * Sets a default parameter.
  185.    *
  186.    * @param string $key    The key
  187.    * @param string $value  The value
  188.    */
  189.   public function setDefaultParameter($key, $value)
  190.   {
  191.     $this->defaultParameters[$key] = $value;
  192.   }
  194.   /**
  195.    * Sets the default parameters for URL generation.
  196.    *
  197.    * @param array $parameters  An array of default parameters
  198.    */
  199.   public function setDefaultParameters($parameters)
  200.   {
  201.     $this->defaultParameters = $parameters;
  202.   }
  204.   /**
  205.    * Listens to the user.change_culture event.
  206.    *
  207.    * @param sfEvent $event An sfEvent instance
  208.    *
  209.    */
  210.   public function listenToChangeCultureEvent(sfEvent $event)
  211.   {
  212.     // change the culture in the routing default parameters
  213.     $this->setDefaultParameter('sf_culture', $event['culture']);
  214.   }
  216.   /**
  217.    * Listens to the request.filter_parameters event.
  218.    *
  219.    * @param  sfEvent $event       An sfEvent instance
  220.    *
  221.    * @return array   $parameters  An array of parameters for the event
  222.    */
  223.   public function filterParametersEvent(sfEvent $event, $parameters)
  224.   {
  225.     $context = $event->getParameters();
  227.     $this->options['context'] = $context;
  229.     if (false === $params = $this->parse($event['path_info']))
  230.     {
  231.       return $parameters;
  232.     }
  234.     return array_merge($parameters, $params);
  235.   }
  237.   protected function fixGeneratedUrl($url, $absolute = false)
  238.   {
  239.     if (isset($this->options['context']['prefix']))
  240.     {
  241.       if (0 === strpos($url, 'http'))
  242.       {
  243.         $url = preg_replace('#https?\://[^/]+#', '$0'.$this->options['context']['prefix'], $url);
  244.       }
  245.       else
  246.       {
  247.         $url = $this->options['context']['prefix'].$url;
  248.       }
  249.     }
  251.     if ($absolute && isset($this->options['context']['host']) && 0 !== strpos($url, 'http'))
  252.     {
  253.       $url = 'http'.(isset($this->options['context']['is_secure']) && $this->options['context']['is_secure'] ? 's' : '').'://'.$this->options['context']['host'].$url;
  254.     }
  256.     return $url;
  257.   }
  259.   /**
  260.    * Execute the shutdown procedure.
  261.    *
  262.    * @return void
  263.    */
  264.   public function shutdown()
  265.   {
  266.   }
  267. }
Debug toolbar