/**
* Parse a SEF URL path into URL parameters
*
* @param string $path The path to parse, e.g. /foo/bar/1/2/3
*
* @return array|null The URL parameters or null if we can't parse the route with this rule
*/
public function parse($path)
{
$extraParams = array();
if (strpos($path, '?') !== false) {
$uri = new Uri($path);
$path = $uri->getPath();
$extraParams = $uri->getQuery(true);
}
if ($this->useCallableForParse) {
$ret = call_user_func($this->parseCallable, $path);
} else {
// Explode the path parts
$segments = explode('/', $path);
// Try to extract the URL parameters by parsing the segments
$params = $this->parseRoute($segments);
// If we got null back we can't parse this route
if (is_null($params)) {
return null;
}
// Mix in the push variables
$params = array_merge($this->pushVars, $params);
// Return the URL parameters
$ret = $params;
}
return array_merge($ret, $extraParams);
}
/**
* Sets the additional URL parameters from the input. If no input is specified we will use the application's
* input. The URL parameters of the base URL will be automatically removed.
*
* @param Input $input The input object to use
*
* @return void
*/
public function setAdditionalUrlParamsFromInput(Input $input = null)
{
// Make sure we have an input
if (!is_object($input)) {
$input = $this->application->getContainer()->input;
}
// Get the input's data array
$data = $input->getData();
// Get the rebase URL parameters to eliminate
$rebase = Uri::rebase('index.php', $this->application->getContainer());
$rebase = new Uri($rebase);
$eliminateParams = $rebase->getQuery(true);
$eliminateParams = array_keys($eliminateParams);
// Set the additional URL parameters
foreach ($data as $key => $value) {
// We can't process object data automatically
if (is_object($value)) {
continue;
}
// We can't process array data automatically
if (is_array($value)) {
continue;
}
// Ignore the URL parameters from the URL rebasing
if (in_array($key, $eliminateParams)) {
continue;
}
$this->setAdditionalUrlParam($key, $value);
}
}
/**
* A utility function to rebase a (partial) URL based on the live_site and base_url of the application configuration
* in the provided container. You can override the base_url of the application through the $baseUrl parameter.
*
* It's simpler to explain with a short example. Let's consider an application with
* live_site = 'http://www.example.com' and base_url='/administrator/index.php?option=com_foobar&baz=1'.
* Using Uri::rebase('?view=report&item=export', $container) will result to the following absolute URL:
* http://www.example.com/administrator/index.php?baz=1&item=export&option=com_foobar&view=report
* Using Uri::rebase('?option=com_whatever', $container) will result to the following absolute URL:
* http://www.example.com/administrator/index.php?baz=1&option=com_whatever
* Therefore by manipulating the base_url in the application's configuration you can have an application which runs
* inside another application (no matter if the other application is based on Awf or not). The "only" thing you will
* have to do is specialise your Application object to act as a bridge to the parent application.
*
* @param $url
* @param Application $container
* @param null $baseUrl
*
* @return string
*/
public static function rebase($url, Container $container, $baseUrl = null)
{
if (empty($baseUrl)) {
$baseUrl = $container->appConfig->get('base_url', 'index.php');
if (empty($baseUrl)) {
$baseUrl = 'index.php';
}
$baseUrl = rtrim($baseUrl, '/');
}
$base = self::base(false, $container);
$base = rtrim($base, '/') . '/' . ltrim($baseUrl, '/');
$rebaseURI = new Uri($base);
$oldURI = new Uri($url);
$vars = $oldURI->getQuery(true);
if (!empty($vars)) {
foreach ($vars as $k => $v) {
$rebaseURI->setVar($k, $v);
}
}
if ($oldURI->getFragment()) {
$rebaseURI->setFragment($oldURI->getFragment());
}
return (string) $rebaseURI;
}
/**
* Parse a routed URL based on the routing rules, setting the input variables of the attached application.
*
* @param string $url The URL to parse. If omitted the current URL will be used.
* @param boolean $rebase Is this a rebased URL? If false we assume we're given a relative URL.
*/
public function parse($url = null, $rebase = true)
{
// If we are not given a URL, use the current URL of the site
if (empty($url)) {
$url = Uri::current();
}
// Initialise
$removePath = null;
$removeVars = null;
if ($rebase) {
// Get the base URL
$baseUrl = $this->container->appConfig->get('base_url', '');
if (empty($baseUrl)) {
$baseUrl = '';
}
$baseUrl = rtrim($baseUrl, '/');
$base = Uri::base(false, $this->container);
$base = rtrim($base, '/') . '/' . $baseUrl;
$rebaseURI = new Uri($base);
// Get the path and vars to remove from the parsed route
$removePath = $rebaseURI->getPath();
$removePath = trim($removePath, '/');
$removeVars = $rebaseURI->getQuery(true);
}
$uri = new Uri($url);
$path = $uri->getPath();
$path = trim($path, '/');
// Remove the $removePath
if (!empty($removePath)) {
if (strpos($path, $removePath) === 0) {
$path = substr($path, strlen($removePath));
}
}
// Use the routing rules to parse the URL
$routeVars = null;
if (!empty($this->rules)) {
/** @var Rule $rule */
foreach ($this->rules as $rule) {
$routeVars = $rule->parse($path);
if (is_array($routeVars)) {
break;
}
}
}
if (is_null($routeVars)) {
$routeVars = array();
}
// Mix route and URI vars
$uriVars = $uri->getQuery(true);
$routeVars = array_merge($routeVars, $uriVars);
// Eliminate $removeVars
if (is_array($removeVars) && !empty($removeVars)) {
foreach ($removeVars as $k => $v) {
if (isset($routeVars[$k]) && $routeVars[$k] == $v) {
unset($routeVars[$k]);
}
}
}
// Set the query vars to the application
if (is_array($routeVars) && !empty($routeVars)) {
$this->container->input->setData($routeVars);
}
}