Skip to content
This repository
Fetching contributors…

Octocat-spinner-32-eaf2f5

Cannot retrieve contributors at this time

file 332 lines (287 sloc) 8.764 kb
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331
<?php namespace Laravel; use Laravel\Routing\Router, Laravel\Routing\Route;

class URL {

/**
* The cached base URL.
*
* @var string
*/
public static $base;

/**
* Get the full URI including the query string.
*
* @return string
*/
public static function full()
{
return static::to(URI::full());
}

/**
* Get the full URL for the current request.
*
* @return string
*/
public static function current()
{
return static::to(URI::current(), null, false, false);
}

/**
* Get the URL for the application root.
*
* @param bool $https
* @return string
*/
public static function home($https = null)
{
$route = Router::find('home');

// If a route named "home" exists, we'll route to that instead of using
// the single slash root URI. This allows the HTTPS attribute to be
// respected instead of being hard-coded in the redirect.
if ( ! is_null($route))
{
return static::to_route('home');
}

return static::to('/', $https);
}

/**
* Get the base URL of the application.
*
* @return string
*/
public static function base()
{
if (isset(static::$base)) return static::$base;

$base = 'http://localhost';

// If the application's URL configuration is set, we will just use that
// instead of trying to guess the URL from the $_SERVER array's host
// and script variables as this is a more reliable method.
if (($url = Config::get('application.url')) !== '')
{
$base = $url;
}
else
{
$base = Request::foundation()->getRootUrl();
}

return static::$base = $base;
}

/**
* Generate an application URL.
*
* <code>
* // Create a URL to a location within the application
* $url = URL::to('user/profile');
*
* // Create a HTTPS URL to a location within the application
* $url = URL::to('user/profile', true);
* </code>
*
* @param string $url
* @param bool $https
* @param bool $asset
* @param bool $locale
* @return string
*/
public static function to($url = '', $https = null, $asset = false, $locale = true)
{
// If the given URL is already valid or begins with a hash, we'll just return
// the URL unchanged since it is already well formed. Otherwise we will add
// the base URL of the application and return the full URL.
if (static::valid($url) or starts_with($url, '#'))
{
return $url;
}

// Unless $https is specified (true or false), we maintain the current request
// security for any new links generated. So https for all secure links.
if (is_null($https)) $https = Request::secure();

$root = static::base();

if ( ! $asset)
{
$root .= '/'.Config::get('application.index');
}

if ( ! $asset and $locale and count(Config::get('application.languages')) > 0)
{
$root .= '/'.Config::get('application.language');
}

// Since SSL is not often used while developing the application, we allow the
// developer to disable SSL on all framework generated links to make it more
// convenient to work with the site while developing locally.
if ($https and Config::get('application.ssl'))
{
$root = preg_replace('~http://~', 'https://', $root, 1);
}
else
{
$root = preg_replace('~https://~', 'http://', $root, 1);
}

return rtrim($root, '/').'/'.ltrim($url, '/');
}

/**
* Generate an application URL with HTTPS.
*
* @param string $url
* @return string
*/
public static function to_secure($url = '')
{
return static::to($url, true);
}

/**
* Generate a URL to a controller action.
*
* <code>
* // Generate a URL to the "index" method of the "user" controller
* $url = URL::to_action('user@index');
*
* // Generate a URL to http://example.com/user/profile/taylor
* $url = URL::to_action('user@profile', array('taylor'));
* </code>
*
* @param string $action
* @param array $parameters
* @return string
*/
public static function to_action($action, $parameters = array())
{
// This allows us to use true reverse routing to controllers, since
// URIs may be setup to handle the action that do not follow the
// typical Laravel controller URI conventions.
$route = Router::uses($action);

if ( ! is_null($route))
{
return static::explicit($route, $action, $parameters);
}
// If no route was found that handled the given action, we'll just
// generate the URL using the typical controller routing setup
// for URIs and turn SSL to false by default.
else
{
return static::convention($action, $parameters);
}
}

/**
* Generate an action URL from a route definition
*
* @param array $route
* @param string $action
* @param array $parameters
* @return string
*/
protected static function explicit($route, $action, $parameters)
{
$https = array_get(current($route), 'https', null);

return static::to(static::transpose(key($route), $parameters), $https);
}

/**
* Generate an action URI by convention.
*
* @param string $action
* @param array $parameters
* @return string
*/
protected static function convention($action, $parameters)
{
list($bundle, $action) = Bundle::parse($action);

$bundle = Bundle::get($bundle);

// If a bundle exists for the action, we will attempt to use its "handles"
// clause as the root of the generated URL, as the bundle can only handle
// URIs that begin with that string and no others.
$root = $bundle['handles'] ?: '';

$parameters = implode('/', $parameters);

// We'll replace both dots and @ signs in the URI since both are used
// to specify the controller and action, and by convention should be
// translated into URI slashes for the URL.
$uri = $root.'/'.str_replace(array('.', '@'), '/', $action);

$uri = static::to(str_finish($uri, '/').$parameters);

return trim($uri, '/');
}

/**
* Generate an application URL to an asset.
*
* @param string $url
* @param bool $https
* @return string
*/
public static function to_asset($url, $https = null)
{
if (static::valid($url)) return $url;

// If a base asset URL is defined in the configuration, use that and don't
// try and change the HTTP protocol. This allows the delivery of assets
// through a different server or third-party content delivery network.
if ($root = Config::get('application.asset_url', false))
{
return rtrim($root, '/').'/'.ltrim($url, '/');
}

$url = static::to($url, $https, true);

// Since assets are not served by Laravel, we do not need to come through
// the front controller. So, we'll remove the application index specified
// in the application config from the generated URL.
if (($index = Config::get('application.index')) !== '')
{
$url = str_replace($index.'/', '', $url);
}

return $url;
}

/**
* Generate a URL from a route name.
*
* <code>
* // Create a URL to the "profile" named route
* $url = URL::to_route('profile');
*
* // Create a URL to the "profile" named route with wildcard parameters
* $url = URL::to_route('profile', array($username));
* </code>
*
* @param string $name
* @param array $parameters
* @return string
*/
public static function to_route($name, $parameters = array())
{
if (is_null($route = Routing\Router::find($name)))
{
throw new \Exception("Error creating URL for undefined route [$name].");
}

// To determine whether the URL should be HTTPS or not, we look for the "https"
// value on the route action array. The route has control over whether the URL
// should be generated with an HTTPS protocol string or just HTTP.
$https = array_get(current($route), 'https', null);

$uri = trim(static::transpose(key($route), $parameters), '/');

return static::to($uri, $https);
}

/**
* Substitute the parameters in a given URI.
*
* @param string $uri
* @param array $parameters
* @return string
*/
public static function transpose($uri, $parameters)
{
// Spin through each route parameter and replace the route wildcard segment
// with the corresponding parameter passed to the method. Afterwards, we'll
// replace all of the remaining optional URI segments.
foreach ((array) $parameters as $parameter)
{
if ( ! is_null($parameter))
{
$uri = preg_replace('/\(.+?\)/', $parameter, $uri, 1);
}
}

// If there are any remaining optional place-holders, we'll just replace
// them with empty strings since not every optional parameter has to be
// in the array of parameters that were passed to us.
$uri = preg_replace('/\(.+?\)/', '', $uri);

return trim($uri, '/');
}

/**
* Determine if the given URL is valid.
*
* @param string $url
* @return bool
*/
public static function valid($url)
{
return filter_var($url, FILTER_VALIDATE_URL) !== false;
}

}
Something went wrong with that request. Please try again.