url.php 8.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320
  1. <?php namespace Laravel; use Laravel\Routing\Router, Laravel\Routing\Route;
  2. class URL {
  3. /**
  4. * The cached base URL.
  5. *
  6. * @var string
  7. */
  8. public static $base;
  9. /**
  10. * Get the full URI including the query string.
  11. *
  12. * @return string
  13. */
  14. public static function full()
  15. {
  16. return static::to(URI::full());
  17. }
  18. /**
  19. * Get the full URL for the current request.
  20. *
  21. * @return string
  22. */
  23. public static function current()
  24. {
  25. return static::to(URI::current());
  26. }
  27. /**
  28. * Get the URL for the application root.
  29. *
  30. * @param bool $https
  31. * @return string
  32. */
  33. public static function home($https = false)
  34. {
  35. $route = Router::find('home');
  36. // If a route named "home" exists, we'll route to that instead of using
  37. // the single slash root URI. This allows the HTTPS attribute to be
  38. // respected instead of being hard-coded in the redirect.
  39. if ( ! is_null($route))
  40. {
  41. return static::to_route('home');
  42. }
  43. return static::to('/', $https);
  44. }
  45. /**
  46. * Get the base URL of the application.
  47. *
  48. * @return string
  49. */
  50. public static function base()
  51. {
  52. if (isset(static::$base)) return static::$base;
  53. $base = 'http://localhost';
  54. // If the application's URL configuration is set, we will just use that
  55. // instead of trying to guess the URL from the $_SERVER array's host
  56. // and script variables as this is a more reliable method.
  57. if (($url = Config::get('application.url')) !== '')
  58. {
  59. $base = $url;
  60. }
  61. else
  62. {
  63. $base = Request::foundation()->getRootUrl();
  64. }
  65. return static::$base = $base;
  66. }
  67. /**
  68. * Generate an application URL.
  69. *
  70. * <code>
  71. * // Create a URL to a location within the application
  72. * $url = URL::to('user/profile');
  73. *
  74. * // Create a HTTPS URL to a location within the application
  75. * $url = URL::to('user/profile', true);
  76. * </code>
  77. *
  78. * @param string $url
  79. * @param bool $https
  80. * @return string
  81. */
  82. public static function to($url = '', $https = false)
  83. {
  84. // If the given URL is already valid or begins with a hash, we'll just return
  85. // the URL unchanged since it is already well formed. Otherwise we will add
  86. // the base URL of the application and return the full URL.
  87. if (static::valid($url) or starts_with($url, '#'))
  88. {
  89. return $url;
  90. }
  91. $root = static::base().'/'.Config::get('application.index');
  92. // Since SSL is not often used while developing the application, we allow the
  93. // developer to disable SSL on all framework generated links to make it more
  94. // convenient to work with the site while developing locally.
  95. if ($https and Config::get('application.ssl'))
  96. {
  97. $root = preg_replace('~http://~', 'https://', $root, 1);
  98. }
  99. else
  100. {
  101. $root = preg_replace('~https://~', 'http://', $root, 1);
  102. }
  103. return rtrim($root, '/').'/'.ltrim($url, '/');
  104. }
  105. /**
  106. * Generate an application URL with HTTPS.
  107. *
  108. * @param string $url
  109. * @return string
  110. */
  111. public static function to_secure($url = '')
  112. {
  113. return static::to($url, true);
  114. }
  115. /**
  116. * Generate a URL to a controller action.
  117. *
  118. * <code>
  119. * // Generate a URL to the "index" method of the "user" controller
  120. * $url = URL::to_action('user@index');
  121. *
  122. * // Generate a URL to http://example.com/user/profile/taylor
  123. * $url = URL::to_action('user@profile', array('taylor'));
  124. * </code>
  125. *
  126. * @param string $action
  127. * @param array $parameters
  128. * @return string
  129. */
  130. public static function to_action($action, $parameters = array())
  131. {
  132. // This allows us to use true reverse routing to controllers, since
  133. // URIs may be setup to handle the action that do not follow the
  134. // typical Laravel controller URI conventions.
  135. $route = Router::uses($action);
  136. if ( ! is_null($route))
  137. {
  138. return static::explicit($route, $action, $parameters);
  139. }
  140. // If no route was found that handled the given action, we'll just
  141. // generate the URL using the typical controller routing setup
  142. // for URIs and turn SSL to false by default.
  143. else
  144. {
  145. return static::convention($action, $parameters);
  146. }
  147. }
  148. /**
  149. * Generate a action URL from a route definition
  150. *
  151. * @param array $route
  152. * @param string $action
  153. * @param array $parameters
  154. * @return string
  155. */
  156. protected static function explicit($route, $action, $parameters)
  157. {
  158. $https = array_get(current($route), 'https', false);
  159. return static::to(static::transpose(key($route), $parameters), $https);
  160. }
  161. /**
  162. * Generate an action URI by convention.
  163. *
  164. * @param string $action
  165. * @param array $parameters
  166. * @return string
  167. */
  168. protected static function convention($action, $parameters)
  169. {
  170. list($bundle, $action) = Bundle::parse($action);
  171. $bundle = Bundle::get($bundle);
  172. // If a bundle exists for the action, we will attempt to use it's "handles"
  173. // clause as the root of the generated URL, as the bundle can only handle
  174. // URIs that begin with that string and no others.
  175. $root = $bundle['handles'] ?: '';
  176. $https = false;
  177. $parameters = implode('/', $parameters);
  178. // We'll replace both dots and @ signs in the URI since both are used
  179. // to specify the controller and action, and by convention should be
  180. // translated into URI slashes for the URL.
  181. $uri = $root.'/'.str_replace(array('.', '@'), '/', $action);
  182. $uri = static::to(str_finish($uri, '/').$parameters);
  183. return trim($uri, '/');
  184. }
  185. /**
  186. * Generate an application URL to an asset.
  187. *
  188. * @param string $url
  189. * @param bool $https
  190. * @return string
  191. */
  192. public static function to_asset($url, $https = null)
  193. {
  194. if (static::valid($url)) return $url;
  195. // If a base asset URL is defined in the configuration, use that and don't
  196. // try and change the HTTP protocol. This allows the delivery of assets
  197. // through a different server or third-party content delivery network.
  198. if ($root = Config::get('application.asset_url', false))
  199. {
  200. return rtrim($root, '/').'/'.ltrim($url, '/');
  201. }
  202. if (is_null($https)) $https = Request::secure();
  203. $url = static::to($url, $https);
  204. // Since assets are not served by Laravel, we do not need to come through
  205. // the front controller. So, we'll remove the application index specified
  206. // in the application config from the generated URL.
  207. if (($index = Config::get('application.index')) !== '')
  208. {
  209. $url = str_replace($index.'/', '', $url);
  210. }
  211. return $url;
  212. }
  213. /**
  214. * Generate a URL from a route name.
  215. *
  216. * <code>
  217. * // Create a URL to the "profile" named route
  218. * $url = URL::to_route('profile');
  219. *
  220. * // Create a URL to the "profile" named route with wildcard parameters
  221. * $url = URL::to_route('profile', array($username));
  222. * </code>
  223. *
  224. * @param string $name
  225. * @param array $parameters
  226. * @param bool $https
  227. * @return string
  228. */
  229. public static function to_route($name, $parameters = array())
  230. {
  231. if (is_null($route = Routing\Router::find($name)))
  232. {
  233. throw new \Exception("Error creating URL for undefined route [$name].");
  234. }
  235. // To determine whether the URL should be HTTPS or not, we look for the "https"
  236. // value on the route action array. The route has control over whether the URL
  237. // should be generated with an HTTPS protocol string or just HTTP.
  238. $https = array_get(current($route), 'https', false);
  239. $uri = trim(static::transpose(key($route), $parameters), '/');
  240. return static::to($uri, $https);
  241. }
  242. /**
  243. * Substitute the parameters in a given URI.
  244. *
  245. * @param string $uri
  246. * @param array $parameters
  247. * @return string
  248. */
  249. public static function transpose($uri, $parameters)
  250. {
  251. // Spin through each route parameter and replace the route wildcard segment
  252. // with the corresponding parameter passed to the method. Afterwards, we'll
  253. // replace all of the remaining optional URI segments.
  254. foreach ((array) $parameters as $parameter)
  255. {
  256. if ( ! is_null($parameter))
  257. {
  258. $uri = preg_replace('/\(.+?\)/', $parameter, $uri, 1);
  259. }
  260. }
  261. // If there are any remaining optional place-holders, we'll just replace
  262. // them with empty strings since not every optional parameter has to be
  263. // in the array of parameters that were passed to us.
  264. $uri = preg_replace('/\(.+?\)/', '', $uri);
  265. return trim($uri, '/');
  266. }
  267. /**
  268. * Determine if the given URL is valid.
  269. *
  270. * @param string $url
  271. * @return bool
  272. */
  273. public static function valid($url)
  274. {
  275. return filter_var($url, FILTER_VALIDATE_URL) !== false;
  276. }
  277. }