[ Index ]

PHP Cross Reference of phpBB-3.3.7-deutsch

title

Body

[close]

/vendor/guzzlehttp/psr7/src/ -> UriNormalizer.php (source)

   1  <?php
   2  
   3  namespace GuzzleHttp\Psr7;
   4  
   5  use Psr\Http\Message\UriInterface;
   6  
   7  /**
   8   * Provides methods to normalize and compare URIs.
   9   *
  10   * @author Tobias Schultze
  11   *
  12   * @link https://tools.ietf.org/html/rfc3986#section-6
  13   */
  14  final class UriNormalizer
  15  {
  16      /**
  17       * Default normalizations which only include the ones that preserve semantics.
  18       *
  19       * self::CAPITALIZE_PERCENT_ENCODING | self::DECODE_UNRESERVED_CHARACTERS | self::CONVERT_EMPTY_PATH |
  20       * self::REMOVE_DEFAULT_HOST | self::REMOVE_DEFAULT_PORT | self::REMOVE_DOT_SEGMENTS
  21       */
  22      const PRESERVING_NORMALIZATIONS = 63;
  23  
  24      /**
  25       * All letters within a percent-encoding triplet (e.g., "%3A") are case-insensitive, and should be capitalized.
  26       *
  27       * Example: http://example.org/a%c2%b1b → http://example.org/a%C2%B1b
  28       */
  29      const CAPITALIZE_PERCENT_ENCODING = 1;
  30  
  31      /**
  32       * Decodes percent-encoded octets of unreserved characters.
  33       *
  34       * For consistency, percent-encoded octets in the ranges of ALPHA (%41–%5A and %61–%7A), DIGIT (%30–%39),
  35       * hyphen (%2D), period (%2E), underscore (%5F), or tilde (%7E) should not be created by URI producers and,
  36       * when found in a URI, should be decoded to their corresponding unreserved characters by URI normalizers.
  37       *
  38       * Example: http://example.org/%7Eusern%61me/ → http://example.org/~username/
  39       */
  40      const DECODE_UNRESERVED_CHARACTERS = 2;
  41  
  42      /**
  43       * Converts the empty path to "/" for http and https URIs.
  44       *
  45       * Example: http://example.org → http://example.org/
  46       */
  47      const CONVERT_EMPTY_PATH = 4;
  48  
  49      /**
  50       * Removes the default host of the given URI scheme from the URI.
  51       *
  52       * Only the "file" scheme defines the default host "localhost".
  53       * All of `file:/myfile`, `file:///myfile`, and `file://localhost/myfile`
  54       * are equivalent according to RFC 3986. The first format is not accepted
  55       * by PHPs stream functions and thus already normalized implicitly to the
  56       * second format in the Uri class. See `GuzzleHttp\Psr7\Uri::composeComponents`.
  57       *
  58       * Example: file://localhost/myfile → file:///myfile
  59       */
  60      const REMOVE_DEFAULT_HOST = 8;
  61  
  62      /**
  63       * Removes the default port of the given URI scheme from the URI.
  64       *
  65       * Example: http://example.org:80/ → http://example.org/
  66       */
  67      const REMOVE_DEFAULT_PORT = 16;
  68  
  69      /**
  70       * Removes unnecessary dot-segments.
  71       *
  72       * Dot-segments in relative-path references are not removed as it would
  73       * change the semantics of the URI reference.
  74       *
  75       * Example: http://example.org/../a/b/../c/./d.html → http://example.org/a/c/d.html
  76       */
  77      const REMOVE_DOT_SEGMENTS = 32;
  78  
  79      /**
  80       * Paths which include two or more adjacent slashes are converted to one.
  81       *
  82       * Webservers usually ignore duplicate slashes and treat those URIs equivalent.
  83       * But in theory those URIs do not need to be equivalent. So this normalization
  84       * may change the semantics. Encoded slashes (%2F) are not removed.
  85       *
  86       * Example: http://example.org//foo///bar.html → http://example.org/foo/bar.html
  87       */
  88      const REMOVE_DUPLICATE_SLASHES = 64;
  89  
  90      /**
  91       * Sort query parameters with their values in alphabetical order.
  92       *
  93       * However, the order of parameters in a URI may be significant (this is not defined by the standard).
  94       * So this normalization is not safe and may change the semantics of the URI.
  95       *
  96       * Example: ?lang=en&article=fred → ?article=fred&lang=en
  97       *
  98       * Note: The sorting is neither locale nor Unicode aware (the URI query does not get decoded at all) as the
  99       * purpose is to be able to compare URIs in a reproducible way, not to have the params sorted perfectly.
 100       */
 101      const SORT_QUERY_PARAMETERS = 128;
 102  
 103      /**
 104       * Returns a normalized URI.
 105       *
 106       * The scheme and host component are already normalized to lowercase per PSR-7 UriInterface.
 107       * This methods adds additional normalizations that can be configured with the $flags parameter.
 108       *
 109       * PSR-7 UriInterface cannot distinguish between an empty component and a missing component as
 110       * getQuery(), getFragment() etc. always return a string. This means the URIs "/?#" and "/" are
 111       * treated equivalent which is not necessarily true according to RFC 3986. But that difference
 112       * is highly uncommon in reality. So this potential normalization is implied in PSR-7 as well.
 113       *
 114       * @param UriInterface $uri   The URI to normalize
 115       * @param int          $flags A bitmask of normalizations to apply, see constants
 116       *
 117       * @return UriInterface The normalized URI
 118       *
 119       * @link https://tools.ietf.org/html/rfc3986#section-6.2
 120       */
 121      public static function normalize(UriInterface $uri, $flags = self::PRESERVING_NORMALIZATIONS)
 122      {
 123          if ($flags & self::CAPITALIZE_PERCENT_ENCODING) {
 124              $uri = self::capitalizePercentEncoding($uri);
 125          }
 126  
 127          if ($flags & self::DECODE_UNRESERVED_CHARACTERS) {
 128              $uri = self::decodeUnreservedCharacters($uri);
 129          }
 130  
 131          if ($flags & self::CONVERT_EMPTY_PATH && $uri->getPath() === '' &&
 132              ($uri->getScheme() === 'http' || $uri->getScheme() === 'https')
 133          ) {
 134              $uri = $uri->withPath('/');
 135          }
 136  
 137          if ($flags & self::REMOVE_DEFAULT_HOST && $uri->getScheme() === 'file' && $uri->getHost() === 'localhost') {
 138              $uri = $uri->withHost('');
 139          }
 140  
 141          if ($flags & self::REMOVE_DEFAULT_PORT && $uri->getPort() !== null && Uri::isDefaultPort($uri)) {
 142              $uri = $uri->withPort(null);
 143          }
 144  
 145          if ($flags & self::REMOVE_DOT_SEGMENTS && !Uri::isRelativePathReference($uri)) {
 146              $uri = $uri->withPath(UriResolver::removeDotSegments($uri->getPath()));
 147          }
 148  
 149          if ($flags & self::REMOVE_DUPLICATE_SLASHES) {
 150              $uri = $uri->withPath(preg_replace('#//++#', '/', $uri->getPath()));
 151          }
 152  
 153          if ($flags & self::SORT_QUERY_PARAMETERS && $uri->getQuery() !== '') {
 154              $queryKeyValues = explode('&', $uri->getQuery());
 155              sort($queryKeyValues);
 156              $uri = $uri->withQuery(implode('&', $queryKeyValues));
 157          }
 158  
 159          return $uri;
 160      }
 161  
 162      /**
 163       * Whether two URIs can be considered equivalent.
 164       *
 165       * Both URIs are normalized automatically before comparison with the given $normalizations bitmask. The method also
 166       * accepts relative URI references and returns true when they are equivalent. This of course assumes they will be
 167       * resolved against the same base URI. If this is not the case, determination of equivalence or difference of
 168       * relative references does not mean anything.
 169       *
 170       * @param UriInterface $uri1           An URI to compare
 171       * @param UriInterface $uri2           An URI to compare
 172       * @param int          $normalizations A bitmask of normalizations to apply, see constants
 173       *
 174       * @return bool
 175       *
 176       * @link https://tools.ietf.org/html/rfc3986#section-6.1
 177       */
 178      public static function isEquivalent(UriInterface $uri1, UriInterface $uri2, $normalizations = self::PRESERVING_NORMALIZATIONS)
 179      {
 180          return (string) self::normalize($uri1, $normalizations) === (string) self::normalize($uri2, $normalizations);
 181      }
 182  
 183      private static function capitalizePercentEncoding(UriInterface $uri)
 184      {
 185          $regex = '/(?:%[A-Fa-f0-9]{2})++/';
 186  
 187          $callback = function (array $match) {
 188              return strtoupper($match[0]);
 189          };
 190  
 191          return
 192              $uri->withPath(
 193                  preg_replace_callback($regex, $callback, $uri->getPath())
 194              )->withQuery(
 195                  preg_replace_callback($regex, $callback, $uri->getQuery())
 196              );
 197      }
 198  
 199      private static function decodeUnreservedCharacters(UriInterface $uri)
 200      {
 201          $regex = '/%(?:2D|2E|5F|7E|3[0-9]|[46][1-9A-F]|[57][0-9A])/i';
 202  
 203          $callback = function (array $match) {
 204              return rawurldecode($match[0]);
 205          };
 206  
 207          return
 208              $uri->withPath(
 209                  preg_replace_callback($regex, $callback, $uri->getPath())
 210              )->withQuery(
 211                  preg_replace_callback($regex, $callback, $uri->getQuery())
 212              );
 213      }
 214  
 215      private function __construct()
 216      {
 217          // cannot be instantiated
 218      }
 219  }


Generated: Thu Mar 24 21:31:15 2022 Cross-referenced by PHPXref 0.7.1