UrlGenerator.php 12 KB
Newer Older
1
2
3
4
<?php

/**
 * @file
Crell's avatar
Crell committed
5
 * Contains Drupal\Core\Routing\UrlGenerator.
6
7
8
9
 */

namespace Drupal\Core\Routing;

10
use Symfony\Component\HttpFoundation\Request;
11
12
use Symfony\Component\HttpKernel\Log\LoggerInterface;

13
14
15
use Symfony\Component\Routing\Route as SymfonyRoute;
use Symfony\Component\Routing\Exception\RouteNotFoundException;

16
17
use Symfony\Cmf\Component\Routing\ProviderBasedGenerator;

18
use Drupal\Component\Utility\Settings;
19
use Drupal\Component\Utility\Url;
20
21
use Drupal\Core\Config\ConfigFactory;
use Drupal\Core\PathProcessor\OutboundPathProcessorInterface;
22
23

/**
24
 * Generates URLs from route names and parameters.
25
 */
26
class UrlGenerator extends ProviderBasedGenerator implements UrlGeneratorInterface {
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

  /**
   * A request object.
   *
   * @var \Symfony\Component\HttpFoundation\Request
   */
  protected $request;

  /**
   * The path processor to convert the system path to one suitable for urls.
   *
   * @var \Drupal\Core\PathProcessor\OutboundPathProcessorInterface
   */
  protected $pathProcessor;

  /**
   * The base path to use for urls.
   *
   * @var string
   */
  protected $basePath;

  /**
   * The base url to use for urls.
   *
   * @var string
   */
  protected $baseUrl;

  /**
   * The script path to use for urls.
   *
   * @var string
   */
  protected $scriptPath;
62
63

  /**
64
   * Whether both secure and insecure session cookies can be used simultaneously.
65
   *
66
   * @var bool
67
   */
68
  protected $mixedModeSessions;
69

70
71
72
  /**
   *  Constructs a new generator object.
   *
73
   * @param \Drupal\Core\Routing\RouteProviderInterface $provider
74
75
76
77
78
79
   *   The route provider to be searched for routes.
   * @param \Drupal\Core\Path\AliasManagerInterface $alias_manager
   *   The alias manager responsible for path aliasing.
   * @param \Symfony\Component\HttpKernel\Log\LoggerInterface $logger
   *   An optional logger for recording errors.
   */
80
  public function __construct(RouteProviderInterface $provider, OutboundPathProcessorInterface $path_processor, ConfigFactory $config, Settings $settings, LoggerInterface $logger = NULL) {
81
82
    parent::__construct($provider, $logger);

83
84
85
    $this->pathProcessor = $path_processor;
    $this->mixedModeSessions = $settings->get('mixed_mode_sessions', FALSE);
    $allowed_protocols = $config->get('system.filter')->get('protocols') ?: array('http', 'https');
86
    Url::setAllowedProtocols($allowed_protocols);
87
88
89
  }

  /**
90
   * {@inheritdoc}
91
92
93
94
95
96
97
98
99
100
101
102
103
104
   */
  public function setRequest(Request $request) {
    $this->request = $request;
    // Set some properties, based on the request, that are used during path-based
    // url generation.
    $this->basePath = $request->getBasePath() . '/';
    $this->baseUrl = $request->getSchemeAndHttpHost() . $this->basePath;
    $this->scriptPath = '';
    $base_path_with_script = $request->getBaseUrl();
    $script_name = $request->getScriptName();
    if (!empty($base_path_with_script) && strpos($base_path_with_script, $script_name) !== FALSE) {
      $length = strlen($this->basePath);
      $this->scriptPath = ltrim(substr($script_name, $length), '/') . '/';
    }
105
106
  }

107
  /**
108
   * {@inheritdoc}
109
   */
110
  public function getPathFromRoute($name, $parameters = array()) {
111
    $route = $this->getRoute($name);
112
113
114
115
116
117
118
    $path = $this->getInternalPathFromRoute($route, $parameters);
    // Router-based paths may have a querystring on them but Drupal paths may
    // not have one, so remove any ? and anything after it. For generate() this
    // is handled in processPath().
    $path = preg_replace('/\?.*/', '', $path);
    return trim($path, '/');
  }
119

120
121
122
123
124
125
126
127
128
129
130
131
132
  /**
   * Gets the path of a route.
   *
   * @param \Symfony\Component\Routing\Route $route
   *  The route object.
   * @param array $parameters
   *  An array of parameters as passed to
   *  \Symfony\Component\Routing\Generator\UrlGeneratorInterface::generate().
   *
   * @return string
   *  The url path corresponding to the route, without the base path.
   */
  protected function getInternalPathFromRoute(SymfonyRoute $route, $parameters = array()) {
133
134
135
136
137
138
139
140
141
142
143
    // The Route has a cache of its own and is not recompiled as long as it does
    // not get modified.
    $compiledRoute = $route->compile();
    $hostTokens = $compiledRoute->getHostTokens();

    $route_requirements = $route->getRequirements();
    // We need to bypass the doGenerate() method's handling of absolute URLs as
    // we handle that ourselves after processing the path.
    if (isset($route_requirements['_scheme'])) {
      unset($route_requirements['_scheme']);
    }
144
    $path = $this->doGenerate($compiledRoute->getVariables(), $route->getDefaults(), $route_requirements, $compiledRoute->getTokens(), $parameters, $route->getPath(), FALSE, $hostTokens);
145
146
147
148
149
150
151
152

    // The URL returned from doGenerate() will include the base path if there is
    // one (i.e., if running in a subdirectory) so we need to strip that off
    // before processing the path.
    $base_url = $this->context->getBaseUrl();
    if (!empty($base_url) && strpos($path, $base_url) === 0) {
      $path = substr($path, strlen($base_url));
    }
153
154
    return $path;
  }
155

156
157
158
159
  /**
   * {@inheritdoc}
   */
  public function generate($name, $parameters = array(), $absolute = FALSE) {
160
161
162
    $options['absolute'] = $absolute;
    return $this->generateFromRoute($name, $parameters, $options);
  }
webchick's avatar
webchick committed
163

164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
  /**
   * {@inheritdoc}
   */
  public function generateFromRoute($name, $parameters = array(), $options = array()) {
    $absolute = !empty($options['absolute']);
    $route = $this->getRoute($name);
    // Symfony adds any parameters that are not path slugs as query strings.
    if (isset($options['query']) && is_array($options['query'])) {
      $parameters = (array) $parameters + $options['query'];
    }
    $path = $this->getInternalPathFromRoute($route, $parameters);
    $path = $this->processPath($path, $options);
    $fragment = '';
    if (isset($options['fragment'])) {
      if (($fragment = trim($options['fragment'])) != '') {
        $fragment = '#' . $fragment;
      }
    }
182
    $base_url = $this->context->getBaseUrl();
183
    if (!$absolute || !$host = $this->context->getHost()) {
184
      return $base_url . $path . $fragment;
185
186
187
188
    }

    // Prepare an absolute URL by getting the correct scheme, host and port from
    // the request context.
189
190
191
192
193
194
    if (isset($options['https']) && $this->mixedModeSessions) {
      $scheme = $options['https'] ? 'https' : 'http';
    }
    else {
      $scheme = $this->context->getScheme();
    }
195
    $scheme_req = $route->getRequirement('_scheme');
196
197
198
199
200
201
202
203
204
    if (isset($scheme_req) && ($req = strtolower($scheme_req)) && $scheme !== $req) {
      $scheme = $req;
    }
    $port = '';
    if ('http' === $scheme && 80 != $this->context->getHttpPort()) {
      $port = ':' . $this->context->getHttpPort();
    } elseif ('https' === $scheme && 443 != $this->context->getHttpsPort()) {
      $port = ':' . $this->context->getHttpsPort();
    }
205
    return $scheme . '://' . $host . $port . $base_url . $path . $fragment;
206
207
208
  }

  /**
209
   * {@inheritdoc}
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
   */
  public function generateFromPath($path = NULL, $options = array()) {

    if (!$this->initialized()) {
      throw new GeneratorNotInitializedException();
    }

    // Merge in defaults.
    $options += array(
      'fragment' => '',
      'query' => array(),
      'absolute' => FALSE,
      'prefix' => '',
    );

    if (!isset($options['external'])) {
      // Return an external link if $path contains an allowed absolute URL. Only
227
228
229
230
      // call the slow \Drupal\Component\Utility\Url::stripDangerousProtocols()
      // if $path contains a ':' before any / ? or #. Note: we could use
      // url_is_external($path) here, but that would require another function
      // call, and performance inside url() is critical.
231
      $colonpos = strpos($path, ':');
232
      $options['external'] = ($colonpos !== FALSE && !preg_match('![/?#]!', substr($path, 0, $colonpos)) && Url::stripDangerousProtocols($path) == $path);
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
    }

    if (isset($options['fragment']) && $options['fragment'] !== '') {
      $options['fragment'] = '#' . $options['fragment'];
    }

    if ($options['external']) {
      // Split off the fragment.
      if (strpos($path, '#') !== FALSE) {
        list($path, $old_fragment) = explode('#', $path, 2);
        // If $options contains no fragment, take it over from the path.
        if (isset($old_fragment) && !$options['fragment']) {
          $options['fragment'] = '#' . $old_fragment;
        }
      }
      // Append the query.
      if ($options['query']) {
250
        $path .= (strpos($path, '?') !== FALSE ? '&' : '?') . Url::buildQuery($options['query']);
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
      }
      if (isset($options['https']) && $this->mixedModeSessions) {
        if ($options['https'] === TRUE) {
          $path = str_replace('http://', 'https://', $path);
        }
        elseif ($options['https'] === FALSE) {
          $path = str_replace('https://', 'http://', $path);
        }
      }
      // Reassemble.
      return $path . $options['fragment'];
    }
    else {
      $path = ltrim($this->processPath($path, $options), '/');
    }

    if (!isset($options['script'])) {
      $options['script'] = $this->scriptPath;
    }
    // The base_url might be rewritten from the language rewrite in domain mode.
    if (!isset($options['base_url'])) {
      if (isset($options['https']) && $this->mixedModeSessions) {
        if ($options['https'] === TRUE) {
          $options['base_url'] = str_replace('http://', 'https://', $this->baseUrl);
          $options['absolute'] = TRUE;
        }
        elseif ($options['https'] === FALSE) {
          $options['base_url'] = str_replace('https://', 'http://', $this->baseUrl);
          $options['absolute'] = TRUE;
        }
      }
      else {
        $options['base_url'] = $this->baseUrl;
      }
    }
    elseif (rtrim($options['base_url'], '/') == $options['base_url']) {
      $options['base_url'] .= '/';
    }
    $base = $options['absolute'] ? $options['base_url'] : $this->basePath;
    $prefix = empty($path) ? rtrim($options['prefix'], '/') : $options['prefix'];

    $path = str_replace('%2F', '/', rawurlencode($prefix . $path));
293
    $query = $options['query'] ? ('?' . Url::buildQuery($options['query'])) : '';
294
295
296
297
    return $base . $options['script'] . $path . $query . $options['fragment'];
  }

  /**
298
   * {@inheritdoc}
299
300
301
302
303
304
   */
  public function setBaseUrl($url) {
    $this->baseUrl = $url;
  }

  /**
305
   * {@inheritdoc}
306
307
308
309
310
311
   */
  public function setBasePath($path) {
    $this->basePath = $path;
  }

  /**
312
   * {@inheritdoc}
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
   */
  public function setScriptPath($path) {
    $this->scriptPath = $path;
  }

  /**
   * Passes the path to a processor manager to allow alterations.
   */
  protected function processPath($path, &$options = array()) {
    // Router-based paths may have a querystring on them.
    if ($query_pos = strpos($path, '?')) {
      // We don't need to do a strict check here because position 0 would mean we
      // have no actual path to work with.
      $actual_path = substr($path, 0, $query_pos);
      $query_string = substr($path, $query_pos);
    }
    else {
      $actual_path = $path;
      $query_string = '';
    }
    $path = '/' . $this->pathProcessor->processOutbound(trim($actual_path, '/'), $options, $this->request);
    $path .= $query_string;
335
336
337
    return $path;
  }

338
339
340
341
342
343
344
345
346
347
348
  /**
   * Returns whether or not the url generator has been initialized.
   *
   * @return bool
   *   Returns TRUE if the basePath, baseUrl and scriptPath properties have been
   *   set, FALSE otherwise.
   */
  protected function initialized() {
    return isset($this->basePath) && isset($this->baseUrl) && isset($this->scriptPath);
  }

349
  /**
350
   * Find the route using the provided route name.
351
352
353
354
355
356
357
358
359
360
361
362
   *
   * @param string $name
   *   The route name to fetch
   *
   * @return \Symfony\Component\Routing\Route
   *   The found route.
   *
   * @throws \Symfony\Component\Routing\Exception\RouteNotFoundException
   *   Thrown if there is no route with that name in this repository.
   *
   * @see \Drupal\Core\Routing\RouteProviderInterface
   */
363
  protected function getRoute($name) {
364
365
366
    if ($name instanceof SymfonyRoute) {
      $route = $name;
    }
367
    elseif (NULL === $route = $this->provider->getRouteByName($name)) {
368
369
370
371
372
      throw new RouteNotFoundException(sprintf('Route "%s" does not exist.', $name));
    }
    return $route;
  }

373
}