/**
* Retrieves an object from the given route.
*
* @param sfRoute $route A sfRoute instance
*/
protected function getObjectForRoute(sfRoute $route)
{
if ($route instanceof sfObjectRoute) {
try {
return $route->getObject();
} catch (Exception $e) {
}
}
return null;
}
protected function fixSuffix()
{
parent::fixSuffix();
if (sfConfig::get('op_is_mail_address_contain_hash', false) && !$this->nonAuth) {
$this->pattern = $this->pattern . '.:hash';
}
}
/**
* @see sfRoute
* @param string $url The URL
* @param array $context The context
* @return array An array of parameters
*/
public function matchesUrl($url, $context = array())
{
$parameters = parent::matchesUrl($url, $context);
$matches = array();
if (preg_match('/^([^(]+)(\\(.*\\))(\\..*?)$/', $parameters['file_name'], $matches)) {
$parameters['file_name'] = $matches[1] . $matches[3];
preg_match_all('/\\((.*?):(.*?)\\)/', $matches[2], $matches);
$parameters = array_merge($parameters, $this->matchParameters($matches[1], $matches[2]));
}
return $parameters;
}
public function matchesParameters($params, $context = array())
{
$culture = $this->getCulture($context);
if (isset($this->requirements['sf_host_culture'])) {
$sfHostCulture = $this->requirements['sf_host_culture'];
if ($culture != $sfHostCulture) {
return false;
}
}
return parent::matchesParameters($params, $context);
}
public function matchesUrl($url, $context = array())
{
$result = parent::matchesUrl($url, $context);
if (!$result) {
return $result;
}
$message = array('This routing rule is deprecated. Please use other rules instead of this.', 'priority' => sfLogger::NOTICE);
if (sfContext::hasInstance()) {
sfContext::getInstance()->getEventDispatcher()->notify(new sfEvent($this, 'application.log', $message));
}
return $result;
}
/**
* Generates a URL from the given parameters.
*
* @param mixed $params The parameter values
* @param array $context The context
* @param Boolean $absolute Whether to generate an absolute URL
*
* @return string The generated URL
*/
public function generate($params, $context = array(), $absolute = false)
{
$slug = null;
if (isset($params['engine-slug'])) {
$slug = $params['engine-slug'];
aRouteTools::pushTargetEnginePage($slug);
unset($params['engine-slug']);
}
// Note that you must pass false to parent::generate for the $absolute parameter
$result = aRouteTools::addPageToUrl($this, parent::generate($params, $context, false), $absolute);
if ($slug) {
aRouteTools::popTargetEnginePage($slug);
}
return $result;
}
// ->parseStarParameter()
$t->diag('->parseStarParameter()');
$route = new sfRoute('/foo/*');
$t->is($route->matchesUrl('/foo/foo/bar/bar/foo'), array('foo' => 'bar', 'bar' => 'foo'), '->parseStarParameter() parses * as key/value pairs');
$t->is($route->matchesUrl('/foo/foo/foo.bar'), array('foo' => 'foo.bar'), '->parseStarParameter() uses / as the key/value separator');
$t->is($route->matchesUrl('/foo'), array(), '->parseStarParameter() returns no additional parameters if the * value is empty');
$route = new sfRoute('/foo/*', array('module' => 'foo'));
$t->is($route->matchesUrl('/foo/foo/bar/module/barbar'), array('foo' => 'bar', 'module' => 'foo'), '->parseStarParameter() cannot override a default value');
$route = new sfRoute('/:foo/*');
$t->is($route->matchesUrl('/bar/foo/barbar'), array('foo' => 'bar'), '->parseStarParameter() cannot override pattern variables');
$route = new sfRoute('/foo/*/bar');
$t->is($route->matchesUrl('/foo/foo/bar/bar'), array('foo' => 'bar'), '->parseStarParameter() is able to parse a star in the middle of a rule');
$t->is($route->matchesUrl('/foo/bar'), array(), '->parseStarParameter() is able to parse a star if it is empty');
// ->generateStarParameter()
$t->diag('->generateStarParameter()');
$route = new sfRoute('/foo/:foo/*');
$t->is($route->generate(array('foo' => 'bar', 'bar' => 'foo')), '/foo/bar/bar/foo', '->generateStarParameter() replaces * with all the key/pair values that are not variables');
// custom token
$t->diag('custom token');
class MyRoute extends sfRoute
{
protected function tokenizeBufferBefore(&$buffer, &$tokens, &$afterASeparator, &$currentSeparator)
{
if ($afterASeparator && preg_match('#^=(' . $this->options['variable_regex'] . ')#', $buffer, $match)) {
// a labelled variable
$this->tokens[] = array('label', $currentSeparator, $match[0], $match[1]);
$currentSeparator = '';
$buffer = substr($buffer, strlen($match[0]));
$afterASeparator = false;
} else {
return false;
/**
* @see sfRoute
*/
public function generate($params, $context = array(), $absolute = false)
{
return parent::generate($this->filterParams($params), $context, $absolute);
}
protected function getGlobPatterns(sfRoute $route)
{
$routeOptions = $route->getOptions();
$pathBase = $this->getOption('cache_dir');
$pathStart = $this->getPathStart($route);
$pathEnd = $this->getPathEnd($route);
$depth = substr_count($pathStart . '*' . $pathEnd, '/');
$paths = array();
for ($i = $depth; $i <= $routeOptions['max_folder_depth']; $i++) {
$paths[] = $pathBase . $pathStart . str_repeat('*/', $i - $depth) . '*' . $pathEnd;
}
return $paths;
}
/**
* Returns a new route object for inspecting and generating the host.
*
* @param string $pattern The host pattern
* @param array $defaults All defaults for the current route
* @param array $requirements All requirements for the current route
* @param array $options All options for the current route
*
* @return sfRoute
*/
protected function createHostRoute($pattern, $defaults, $requirements, $options)
{
$filteredDefaults = array();
$filteredRequirements = array();
// this temporary route is just for extracting variables from the pattern
$tmp = new sfRoute($pattern);
foreach (array_keys($tmp->getVariables()) as $name) {
if (isset($defaults[$name])) {
$filteredDefaults[$name] = $defaults[$name];
}
if (isset($requirements[$name])) {
$filteredRequirements[$name] = $requirements[$name];
}
}
return new sfRoute($pattern, $filteredDefaults, $filteredRequirements, $options);
}
/**
* Generates a URL from the given parameters.
*
* @param mixed $params The parameter values
* @param array $context The context
* @param Boolean $absolute Whether to generate an absolute URL
*
* @return string The generated URL
*/
public function generate($params, $context = array(), $absolute = false)
{
unset($params['sf_method']);
return parent::generate($params, $context, $absolute);
}
/**
* If an engine page has already been pushed or we are on an engine page now,
* returns that engine page slug. Otherwise returns null. Useful to determine
* whether you should get clever or not in a getEngineSlug() method for an
* aDoctrineRoute.
*
* @param sfRoute $route
*
* @return string The engine slug, or null
*/
public static function getContextEngineSlug(sfRoute $route)
{
$defaults = $route->getDefaults();
$currentPage = aTools::getCurrentPage();
$engine = $defaults['module'];
if (isset(self::$targetEnginePageSlugs[$engine]) && count(self::$targetEnginePageSlugs[$engine])) {
return end(self::$targetEnginePageSlugs[$engine]);
} elseif ($currentPage && $currentPage->engine === $defaults['module']) {
return $currentPage->slug;
} else {
return null;
}
}
/**
* Generates a URL from the given parameters.
*
* @param mixed $params The parameter values
* @param array $context The context
* @param Boolean $absolute Whether to generate an absolute URL
*
* @return string The generated URL
*/
public function generate($params, $context = array(), $absolute = false)
{
// Note that you must pass false to parent::generate for the $absolute parameter
return aRouteTools::addPageToUrl($this, parent::generate($params, $context, false), $absolute);
}
public function generate($params, $context = array(), $absolute = false)
{
$url = parent::generate($params, $context, $absolute);
return 'http://' . $context['host'] . $url;
}
/**
* Prepends the current CMS page to the URL.
*
* @param string $url The URL so far obtained from parent::generate
* @param Boolean $absolute Whether to generate an absolute URL
*
* @return string The generated URL
*/
public static function addPageToUrl(sfRoute $route, $url, $absolute)
{
$defaults = $route->getDefaults();
$currentPage = aTools::getCurrentPage();
$engine = $defaults['module'];
if (isset(self::$targetEnginePages[$engine]) && count(self::$targetEnginePages[$engine])) {
$page = end(self::$targetEnginePages[$engine]);
} elseif (!$currentPage || $currentPage->engine !== $defaults['module']) {
$page = aPageTable::getFirstEnginePage($defaults['module']);
} else {
$page = $currentPage;
}
if (!$page) {
throw new sfException('Attempt to generate aRoute URL for module ' . $defaults['module'] . ' with no matching engine page on the site');
}
// A route URL of / for an engine route maps to the page itself, without a trailing /
if ($url === '/') {
$url = '';
}
// Ditto for / followed by a query string (missed this before)
if (substr($url, 0, 2) === '/?') {
$url = substr($url, 1);
}
$pageUrl = $page->getUrl($absolute);
// Strip controller off so it doesn't duplicate the controller in the
// URL we just generated. We could use the slug directly, but that would
// break if the CMS were not mounted at the root on a particular site.
// Take care to function properly in the presence of an absolute URL
if (preg_match("/^(https?:\\/\\/[^\\/]+)?\\/[^\\/]+\\.php(.*)\$/", $pageUrl, $matches)) {
$pageUrl = $matches[2];
}
return $pageUrl . $url;
}
public function configureRoute(sfRoute $route)
{
$route->setDefaultParameters($this->defaultParameters);
$route->setDefaultOptions($this->options);
}
/**
* get the security settings for a route
*
* @param sfRoute $route
* @return array
*/
protected function getSecurityConfigForRoute(sfRoute $route)
{
$route_defaults = $route->getDefaults() ? $route->getDefaults() : $route->getDefaultParameters();
$config = $this->context->getConfiguration();
if ($file = $config->getConfigCache()->checkConfig('modules/' . $route_defaults['module'] . '/config/security.yml', true)) {
require $file;
} else {
$this->security = array();
}
$secure = $this->getSecurityValue($route_defaults['action'], 'is_secure');
$credentials = $this->getSecurityValue($route_defaults['action'], 'credentials');
if (!is_null($credentials) && !is_array($credentials)) {
$credentials = array($credentials);
}
return array('is_secure' => $secure, 'credentials' => $credentials);
}
