/** * @param string $specification * @return string */ private function createUrlFromUri($specification) { preg_match('%^(?P<path>[^?#]*)(?:(?:\\?(?P<query>[^#]*))?(?:\\#(?P<fragment>.*))?)$%', (string) $specification, $matches); $path = $matches['path']; $query = isset($matches['query']) ? $matches['query'] : ''; $fragment = isset($matches['fragment']) ? $matches['fragment'] : ''; $uri = $this->uri->withQuery('')->withFragment(''); // Relative path if (!empty($path) && '/' !== $path[0]) { $path = rtrim($this->uri->getPath(), '/') . '/' . $path; } // Path present; set on URI if (!empty($path)) { $uri = $uri->withPath($path); } // Query present; set on URI if (!empty($query)) { $uri = $uri->withQuery($query); } // Fragment present; set on URI if (!empty($fragment)) { $uri = $uri->withFragment($fragment); } return (string) $uri; }
/** * Retrieves the message's request target. * * Retrieves the message's request-target either as it will appear (for * clients), as it appeared at request (for servers), or as it was * specified for the instance (see withRequestTarget()). * * In most cases, this will be the origin-form of the composed URI, * unless a value was provided to the concrete implementation (see * withRequestTarget() below). * * If no URI is available, and no request-target has been specifically * provided, this method MUST return the string "/". * * @return string */ public function getRequestTarget() : string { if ($this->target !== null) { return $this->target; } return $this->uri->getPath() === '' ? '/' : $this->uri->getPath(); }
/** * {@inheritdoc} */ public function getRequestTarget() { if ($this->requestTarget) { return $this->requestTarget; } $target = $this->uri->getPath(); $target = $target ? $target : '/'; $query = $this->uri->getQuery(); $target .= $query ? '?' . $query : ''; return $target; }
public function getRequestTarget() { if ($this->requestTarget !== null) { return $this->requestTarget; } $target = $this->uri->getPath(); if ($target == null) { $target = '/'; } if ($this->uri->getQuery()) { $target .= '?' . $this->uri->getQuery(); } return $target; }
/** * Retrieves the message's request target. * * Retrieves the message's request-target either as it will appear (for * clients), as it appeared at request (for servers), or as it was * specified for the instance (see withRequestTarget()). * * In most cases, this will be the origin-form of the composed URI, * unless a value was provided to the concrete implementation (see * withRequestTarget() below). * * If no URI is available, and no request-target has been specifically * provided, this method will return the string "/". * * @return string */ public function getRequestTarget() { // Use the explicitly set request target first. if (isset($this->requestTarget)) { return $this->requestTarget; } // Build the origin form from the composed URI. $target = $this->uri->getPath(); $query = $this->uri->getQuery(); if ($query) { $target .= "?" . $query; } // Return "/" if the origin form is empty. return $target ?: "/"; }
/** * Gets the request target from current URI * * @return string */ private function targetFromUri() { $target = $this->uri->getPath(); $target .= '' === $this->uri->getQuery() ? '' : '?' . $this->uri->getQuery(); $target = empty($target) ? '/' : $target; return $target; }
/** * @param UriInterface $uri Has to contain a host name and cans have a path. * @param array $hostConfig Config for AddHostPlugin. @see AddHostPlugin::configureOptions */ public function __construct(UriInterface $uri, array $hostConfig = []) { $this->addHostPlugin = new AddHostPlugin($uri, $hostConfig); if (rtrim($uri->getPath(), '/')) { $this->addPathPlugin = new AddPathPlugin($uri); } }
/** * @return string */ public function getRequestTarget() { if (isset($this->requestTarget) && $this->requestTarget !== '') { return $this->requestTarget; } if (!isset($this->uri)) { return '/'; } $target = $this->uri->getPath(); if ($this->uri->getQuery() !== '') { $target .= '?' . $this->uri->getQuery(); } if ($target === '') { $target = '/'; } return $target; }
/** * @inheritdoc */ public function getRequestTarget() { if ($this->requestTarget !== null) { return $this->requestTarget; } $this->requireUri(); if ($this->uri === null) { return '/'; } $target = $this->uri->getPath(); $query = $this->uri->getQuery(); if ($query !== '') { $target .= '?' . $query; } $this->requestTarget = $target; return $this->requestTarget; }
/** * {@inheritdoc} */ public function getRequestTarget() { if ($this->requestTarget !== null) { return $this->requestTarget; } if (!$this->uri instanceof UriInterface) { return '/'; } $this->requestTarget = $this->uri->getPath(); if (!$this->requestTarget) { $this->requestTarget = '/'; } if ($this->uri->getQuery()) { $this->requestTarget .= '?' . $this->uri->getQuery(); } return $this->requestTarget; }
private function createRtmpUrl(UriInterface $uri) { // Use a relative URL when creating Flash player URLs $result = ltrim($uri->getPath(), '/'); if ($query = $uri->getQuery()) { $result .= '?' . $query; } return $result; }
/** * Gets the path from a ``UriInterface`` instance after removing the version * prefix. * * @param UriInterface $uri * * @return string */ public function getPath(UriInterface $uri) { $path = trim($uri->getPath(), '/'); $parts = explode('/', $path); if ($parts[0] === 'v' . Client::API_VERSION) { unset($parts[0]); } return '/' . implode('/', $parts); }
private function parseVirtualHosted(UriInterface $url, array $matches) { $result = self::$defaultResult; $result['path_style'] = false; // Remove trailing "." from the prefix to get the bucket $result['bucket'] = substr($matches[1], 0, -1); $path = $url->getPath(); // Check if a key was present, and if so, removing the leading "/" $result['key'] = !$path || $path == '/' ? null : substr($path, 1); return $result; }
/** * Perform URI check. * @param null|integer|string $var1 * @param mixed $var2 * @param mixed $var3 * @param mixed $var4 * @return mixed */ public function runUri($var1 = null, $var2 = null, $var3 = null, $var4 = null) { if (is_null($var1)) { return $this->uri->getPath(); } if (is_numeric($var1) and is_null($var2)) { return $this->parts[$var1]; } if (is_numeric($var1) and is_string($var2)) { return $this->checkUriSegmentMatch($var1, $var2, $var3, $var4); } if (is_string($var1)) { return $this->checkUriRegexMatch($var1, $var2, $var3); } throw new LogicException('Invalid use of the uri function.'); }
/** * Retrieves the message's request target. * * Retrieves the message's request-target either as it will appear (for * clients), as it appeared at request (for servers), or as it was * specified for the instance (see withRequestTarget()). * * In most cases, this will be the origin-form of the composed URI, * unless a value was provided to the concrete implementation (see * withRequestTarget() below). * * If no URI is available, and no request-target has been specifically * provided, this method MUST return the string "/". * * @return string */ public function getRequestTarget() { if ($this->requestTarget) { return $this->requestTarget; } if ($this->uri === null) { return '/'; } $path = '/' . ltrim($this->uri->getPath(), '/'); $query = $this->uri->getQuery(); if ($query) { $path .= '?' . $query; } $this->requestTarget = $path; return $this->requestTarget; }
/** * Retrieves the message's request target. * * Retrieves the message's request-target either as it will appear (for * clients), as it appeared at request (for servers), or as it was * specified for the instance (see withRequestTarget()). * * In most cases, this will be the origin-form of the composed URI, * unless a value was provided to the concrete implementation (see * withRequestTarget() below). * * If no URI is available, and no request-target has been specifically * provided, this method MUST return the string "/". * * @return string */ public function getRequestTarget() { if (null !== $this->requestTarget) { return $this->requestTarget; } if (!$this->uri) { return '/'; } $target = $this->uri->getPath(); if ($this->uri->getQuery()) { $target .= '?' . $this->uri->getQuery(); } if (empty($target)) { $target = '/'; } return $target; }
/** * Retrieves the message's request target. * * Retrieves the message's request-target either as it will appear (for * clients), as it appeared at request (for servers), or as it was * specified for the instance (see withRequestTarget()). * * In most cases, this will be the origin-form of the composed URI, * unless a value was provided to the concrete implementation (see * withRequestTarget() below). * * If no URI is available, and no request-target has been specifically * provided, this method MUST return the string "/". * * @return string */ public function getRequestTarget() { if ($this->requestTarget) { return $this->requestTarget; } if ($this->uri === null) { return '/'; } $basePath = method_exists($this->uri, 'getBasePath') ? $this->uri->getBasePath() : ''; $path = $this->uri->getPath(); $path = $basePath . '/' . ltrim($path, '/'); $query = $this->uri->getQuery(); if ($query) { $path .= '?' . $query; } $this->requestTarget = $path; return $this->requestTarget; }
/** * @param UriInterface $uri * @return UriInterface * @throws \ErrorException */ protected function forward_aliases(UriInterface $uri) { // strip beginning / $path = substr($uri->getPath(), 1); $aliases = $this->db->conn()->prepare(<<<SQL SELECT `alias_go`, `alias_forward_to` FROM `{$this->db->getPrefix()}aliases` WHERE `alias_active` = 1 AND `alias_go` = ? SQL ); $aliases->execute(array($path)); $aliases = $aliases->fetchAll(\PDO::FETCH_ASSOC); foreach ($aliases as $alias) { if ($path == $alias['alias_go']) { $path = $alias['alias_forward_to']; } } return $uri->withPath('/' . $path); }
/** * Get each invalidation request replicated over all HTTP caching servers * * @return RequestInterface[] */ public function all() { $requests = []; foreach ($this->queue as $request) { $uri = $request->getUri(); // If a base URI is configured, try to make partial invalidation // requests complete. if ($this->baseUri) { if ($uri->getHost()) { // Absolute URI: does it already have a scheme? if (!$uri->getScheme() && $this->baseUri->getScheme() !== '') { $uri = $uri->withScheme($this->baseUri->getScheme()); } } else { // Relative URI if ($this->baseUri->getHost() !== '') { $uri = $uri->withHost($this->baseUri->getHost()); } if ($this->baseUri->getPort()) { $uri = $uri->withPort($this->baseUri->getPort()); } // Base path if ($this->baseUri->getPath() !== '') { $path = $this->baseUri->getPath() . '/' . ltrim($uri->getPath(), '/'); $uri = $uri->withPath($path); } } } // Close connections to make sure invalidation (PURGE/BAN) requests // will not interfere with content (GET) requests. $request = $request->withUri($uri)->withHeader('Connection', 'Close'); // Create a request to each caching proxy server foreach ($this->servers as $server) { $requests[] = $request->withUri($uri->withScheme($server->getScheme())->withHost($server->getHost())->withPort($server->getPort()), true); } } return $requests; }
/** * Returns an instance with the provided URI. * * This method MUST update the Host header of the returned request by * default if the URI contains a host component. If the URI does not * contain a host component, any pre-existing Host header MUST be carried * over to the returned request. * * You can opt-in to preserving the original state of the Host header by * setting `$preserveHost` to `true`. When `$preserveHost` is set to * `true`, this method interacts with the Host header in the following ways: * * - If the the Host header is missing or empty, and the new URI contains * a host component, this method MUST update the Host header in the returned * request. * - If the Host header is missing or empty, and the new URI does not contain a * host component, this method MUST NOT update the Host header in the returned * request. * - If a Host header is present and non-empty, this method MUST NOT update * the Host header in the returned request. * * @link http://tools.ietf.org/html/rfc3986#section-4.3 * * @param UriInterface $uri New request URI to use. * @param bool $preserveHost Preserve the original state of the Host header. * @return self */ public function withUri(UriInterface $uri, $preserveHost = false) { $request = clone $this; $request->scheme($uri->getScheme()); $userInfo = $uri->getUserInfo(); $parts = explode(':', $userInfo); $request->username($parts[0] ?: null); $request->password(!empty($parts[1]) ? $parts[1] : null); $request->port($uri->getPort()); if ($preserveHost) { $host = $request->headers['Host']; $request->host($uri->getHost()); $request->headers['Host'] = $host; } else { $request->host($uri->getHost()); } $request->path($uri->getPath()); $request->query($uri->getQuery()); $request->fragment($uri->getFragment()); return $request; }
/** * Provide private routes to be exposes by search engine * * @param \Psr\Http\Message\UriInterface $uri * @param \Slim\Http\Response $res * @return \Slim\Http\Response */ protected function filterPrivateRoutes(UriInterface $uri, Response $res) { $privates = $this->settings['privateRoutes']; $path = $uri->getPath(); if (is_string($privates) && $privates !== '') { $privates = [$privates]; } if (is_null($privates) || is_array($privates) && in_array($path, $privates)) { $res = $res->withHeader('X-Robots-Tag', 'noindex, nofollow, noarchive'); } return $res; }
private static function getRelativePath(UriInterface $base, UriInterface $target) { $sourceSegments = explode('/', $base->getPath()); $targetSegments = explode('/', $target->getPath()); array_pop($sourceSegments); $targetLastSegment = array_pop($targetSegments); foreach ($sourceSegments as $i => $segment) { if (isset($targetSegments[$i]) && $segment === $targetSegments[$i]) { unset($sourceSegments[$i], $targetSegments[$i]); } else { break; } } $targetSegments[] = $targetLastSegment; $relativePath = str_repeat('../', count($sourceSegments)) . implode('/', $targetSegments); // A reference to am empty last segment or an empty first sub-segment must be prefixed with "./". // This also applies to a segment with a colon character (e.g., "file:colon") that cannot be used // as the first segment of a relative-path reference, as it would be mistaken for a scheme name. if ('' === $relativePath || false !== strpos(explode('/', $relativePath, 2)[0], ':')) { $relativePath = "./{$relativePath}"; } elseif ('/' === $relativePath[0]) { if ($base->getAuthority() != '' && $base->getPath() === '') { // In this case an extra slash is added by resolve() automatically. So we must not add one here. $relativePath = ".{$relativePath}"; } else { $relativePath = "./{$relativePath}"; } } return $relativePath; }
/** * returns the resolve URI * * @param LeagueUriInterface|UriInterface $relative the relative URI * * @return LeagueUriInterface|UriInterface */ protected function resolveRelative($relative) { $path = $relative->getPath(); if (!empty($path)) { return $this->resolveRelativePath($relative, $path, $relative->getQuery()); } $query = $relative->getQuery(); if (!empty($query)) { return $this->getBaseUri($relative)->withPath($this->uri->getPath())->withQuery($query); } return $this->getBaseUri($relative)->withPath($this->uri->getPath())->withQuery($this->uri->getQuery()); }
/** * Resolve a base URI with a relative URI and return a new URI. * * @param UriInterface $base Base URI * @param null|string|UriInterface $rel Relative URI * * @throws \InvalidArgumentException * * @return UriInterface */ public static function resolve(UriInterface $base, $rel = null) { if ($rel === null || $rel === '') { return $base; } if (!$rel instanceof UriInterface) { $rel = new self($rel); } // Return the relative uri as-is if it has a scheme. if ($rel->getScheme()) { return $rel->withPath(static::removeDotSegments($rel->getPath())); } $relParts = ['scheme' => $rel->getScheme(), 'authority' => $rel->getAuthority(), 'path' => $rel->getPath(), 'query' => $rel->getQuery(), 'fragment' => $rel->getFragment()]; $parts = ['scheme' => $base->getScheme(), 'authority' => $base->getAuthority(), 'path' => $base->getPath(), 'query' => $base->getQuery(), 'fragment' => $base->getFragment()]; if (!empty($relParts['path'])) { if (strpos($relParts['path'], '/') === 0) { $parts['path'] = self::removeDotSegments($relParts['path']); $parts['query'] = $relParts['query']; $parts['fragment'] = $relParts['fragment']; } else { $mergedPath = substr($parts['path'], 0, strrpos($parts['path'], '/') + 1); $parts['path'] = self::removeDotSegments($mergedPath . $relParts['path']); $parts['query'] = $relParts['query']; $parts['fragment'] = $relParts['fragment']; } } elseif (!empty($relParts['query'])) { $parts['query'] = $relParts['query']; } elseif ($relParts['fragment'] !== null) { $parts['fragment'] = $relParts['fragment']; } return new self(static::createUriString($parts['scheme'], $parts['authority'], $parts['path'], $parts['query'], $parts['fragment'])); }
/** * Whether the URI is a relative-path reference. * * A relative reference that does not begin with a slash character is termed a relative-path reference. * * @param UriInterface $uri * * @return bool * @link https://tools.ietf.org/html/rfc3986#section-4.2 */ public static function isRelativePathReference(UriInterface $uri) { return $uri->getScheme() === '' && $uri->getAuthority() === '' && (!isset($uri->getPath()[0]) || $uri->getPath()[0] !== '/'); }
protected function getFiltersData(UriInterface $searchUri, Request $request) { $filter = new ViewData(); $filter->url = $searchUri->getPath(); $filter->list = new ViewDataCollection(); $filter->list->add($this->getCategoriesFacet($this->getCategory($request), new Uri($request->getRequestUri()))); $facetConfigs = $this->config->get('sunrise.products.facets'); $queryParams = \GuzzleHttp\Psr7\parse_query($searchUri->getQuery()); foreach ($facetConfigs as $facetName => $facetConfig) { $filter->list->add($this->getFacet($facetName, $facetConfig, $searchUri, $queryParams)); } return $filter; }
/** * Take a request URI and update the CI URI object state to match * * @param UriInterface $uri */ private function forgeUri(UriInterface $uri) { static::$ci->router->_set_request(explode('/', trim($uri->getPath(), '/'))); return $this; }
/** * Resolve a base URI with a relative URI and return a new URI. * * @param UriInterface $base Base URI * @param string $rel Relative URI * * @return UriInterface */ public static function resolve(UriInterface $base, $rel) { if ($rel === null || $rel === '') { return $base; } if ($rel instanceof UriInterface) { $relParts = ['scheme' => $rel->getScheme(), 'host' => $rel->getHost(), 'port' => $rel->getPort(), 'path' => $rel->getPath(), 'query' => $rel->getQuery(), 'fragment' => $rel->getFragment()]; } else { $relParts = parse_url($rel) + ['scheme' => '', 'host' => '', 'port' => '', 'path' => '', 'query' => '', 'fragment' => '']; } if (!empty($relParts['scheme']) && !empty($relParts['host'])) { return $rel instanceof UriInterface ? $rel : self::fromParts($relParts); } $parts = ['scheme' => $base->getScheme(), 'host' => $base->getHost(), 'port' => $base->getPort(), 'path' => $base->getPath(), 'query' => $base->getQuery(), 'fragment' => $base->getFragment()]; if (!empty($relParts['host'])) { $parts['host'] = $relParts['host']; $parts['port'] = $relParts['port']; $parts['path'] = self::removeDotSegments($relParts['path']); $parts['query'] = $relParts['query']; $parts['fragment'] = $relParts['fragment']; } elseif (!empty($relParts['path'])) { if (substr($relParts['path'], 0, 1) == '/') { $parts['path'] = self::removeDotSegments($relParts['path']); $parts['query'] = $relParts['query']; $parts['fragment'] = $relParts['fragment']; } else { if (!empty($parts['host']) && empty($parts['path'])) { $mergedPath = '/'; } else { $mergedPath = substr($parts['path'], 0, strrpos($parts['path'], '/') + 1); } $parts['path'] = self::removeDotSegments($mergedPath . $relParts['path']); $parts['query'] = $relParts['query']; $parts['fragment'] = $relParts['fragment']; } } elseif (!empty($relParts['query'])) { $parts['query'] = $relParts['query']; } elseif ($relParts['fragment'] != null) { $parts['fragment'] = $relParts['fragment']; } return static::fromParts($parts); }
private static function decodeUnreservedCharacters(UriInterface $uri) { $regex = '/%(?:2D|2E|5F|7E|3[0-9]|[46][1-9A-F]|[57][0-9A])/i'; $callback = function (array $match) { return rawurldecode($match[0]); }; return $uri->withPath(preg_replace_callback($regex, $callback, $uri->getPath()))->withQuery(preg_replace_callback($regex, $callback, $uri->getQuery())); }
/** * Indicates if the route matches with the URI. * * @param UriInterface $uri * @param array $attributes * * @return bool */ public final function matchesWithUri(UriInterface $uri, &$attributes = []) { $matched = ('' === ($scheme = $this->getScheme()) or $scheme === $uri->getScheme()) && ('' === ($host = $this->getHost()) or preg_match($this->compileHost(), $uri->getHost(), $attrs)) && preg_match($this->compilePath(), $uri->getPath(), $attrs); $attributes = array_filter($attrs, 'is_string'); return $matched; }