Route
» Kohana_Route

public static __set_state ( array $values )

Returns:

• Route

Source:

public static function __set_state(array $values)
{
	// Reconstruct the route
	$route = new Route;

	foreach ($values as $key => $value)
	{
		// Set the route properties
		$route->$key = $value;
	}

	return $route;
}

public static set ( string $name, string $uri, array $regex = NULL )

Returns:

• Route

Source:

public static function set($name, $uri, array $regex = NULL)
{
	return Route::$_routes[$name] = new Route($uri, $regex);
}

public static get ( string $name )

Returns:

• Route
• FALSE when no route is found

Source:

public static function get($name)
{
	if ( ! isset(Route::$_routes[$name]))
	{
		throw new Kohana_Exception('The requested route does not exist: :route',
			array(':route' => $name));
	}

	return Route::$_routes[$name];
}

public static all ( )

Returns:

• array named routes

Source:

public static function all()
{
	return Route::$_routes;
}

public static cache ( boolean $save = false )

Returns:

• void when saving routes
• boolean when loading routes

Source:

public static function cache($save = FALSE)
{
	if ($save === TRUE)
	{
		// Cache all defined routes
		Kohana::cache('Route::cache()', Route::$_routes);
	}
	else
	{
		if ($routes = Kohana::cache('Route::cache()'))
		{
			Route::$_routes = $routes;

			// Routes were cached
			return TRUE;
		}
		else
		{
			// Routes were not cached
			return FALSE;
		}
	}
}

public __construct ( string $uri = NULL, array $regex = NULL )

Returns:

• void

Source:

public function __construct($uri = NULL, array $regex = NULL)
{
	if ($uri === NULL)
	{
		// Assume the route is from cache
		return;
	}

	if ( ! empty($regex))
	{
		$this->_regex = $regex;
	}

	// Store the URI that this route will match
	$this->_uri = $uri;

	// Store the compiled regex locally
	$this->_route_regex = $this->_compile();
}

public defaults ( array $defaults = NULL )

$route->defaults(array('controller' => 'welcome', 'action' => 'index'));

Returns:

• Route

Source:

public function defaults(array $defaults = NULL)
{
	$this->_defaults = $defaults;

	return $this;
}

public matches ( string $uri )

// This route will only match if the <controller>, <action>, and <id> exist
$params = Route::factory('<controller>/<action>/<id>', array('id' => '\d+'))
    ->matches('users/edit/10');
// The parameters are now: controller = users, action = edit, id = 10

if ($params = $route->matches($uri))
{
    // Parse the parameters
}

Returns:

• array on success
• FALSE on failure

Source:

public function matches($uri)
{
	if ( ! preg_match($this->_route_regex, $uri, $matches))
		return FALSE;

	$params = array();
	foreach ($matches as $key => $value)
	{
		if (is_int($key))
		{
			// Skip all unnamed keys
			continue;
		}

		// Set the value for all matched keys
		$params[$key] = $value;
	}

	foreach ($this->_defaults as $key => $value)
	{
		if ( ! isset($params[$key]) OR $params[$key] === '')
		{
			// Set default values for any key that was not matched
			$params[$key] = $value;
		}
	}

	return $params;
}

public uri ( array $params = NULL )

Returns:

• string

Source:

public function uri(array $params = NULL)
{
	if ($params === NULL)
	{
		// Use the default parameters
		$params = $this->_defaults;
	}
	else
	{
		// Add the default parameters
		$params += $this->_defaults;
	}

	// Start with the routed URI
	$uri = $this->_uri;

	if (strpos($uri, '<') === FALSE AND strpos($uri, '(') === FALSE)
	{
		// This is a static route, no need to replace anything
		return $uri;
	}

	while (preg_match('#\([^()]++\)#', $uri, $match))
	{
		// Search for the matched value
		$search = $match[0];

		// Remove the parenthesis from the match as the replace
		$replace = substr($match[0], 1, -1);

		while(preg_match('#'.Route::REGEX_KEY.'#', $replace, $match))
		{
			list($key, $param) = $match;

			if ( ! empty($params[$param]))
			{
				// Replace the key with the parameter value
				$replace = str_replace($key, $params[$param], $replace);
			}
			else
			{
				// This group has missing parameters
				$replace = '';
				break;
			}
		}

		// Replace the group in the URI
		$uri = str_replace($search, $replace, $uri);
	}

	while(preg_match('#'.Route::REGEX_KEY.'#', $uri, $match))
	{
		list($key, $param) = $match;

		if (empty($params[$param]))
		{
			// Ungrouped parameters are required
			throw new Kohana_Exception('Required route parameter not passed: :param',
				array(':param' => $param));
		}

		$uri = str_replace($key, $params[$param], $uri);
	}

	// Trim all extra slashes from the URI
	$uri = preg_replace('#//+#', '/', rtrim($uri, '/'));

	return $uri;
}

protected _compile ( )

Returns:

• string

Source:

protected function _compile()
{
	// The URI should be considered literal except for keys and optional parts
	// Escape everything preg_quote would escape except for : ( ) < >
	$regex = preg_replace('#'.Route::REGEX_ESCAPE.'#', '\\\\$0', $this->_uri);

	if (strpos($regex, '(') !== FALSE)
	{
		// Make optional parts of the URI non-capturing and optional
		$regex = str_replace(array('(', ')'), array('(?:', ')?'), $regex);
	}

	// Insert default regex for keys
	$regex = str_replace(array('<', '>'), array('(?P<', '>'.Route::REGEX_SEGMENT.')'), $regex);

	if ( ! empty($this->_regex))
	{
		$search = $replace = array();
		foreach ($this->_regex as $key => $value)
		{
			$search[]  = "<$key>".Route::REGEX_SEGMENT;
			$replace[] = "<$key>$value";
		}

		// Replace the default regex with the user-specified regex
		$regex = str_replace($search, $replace, $regex);
	}

	return '#^'.$regex.'$#';
}

access

protected