uri.h

#ifndef SOURCEMETA_CORE_URI_H_
#define SOURCEMETA_CORE_URI_H_
 
#ifndef SOURCEMETA_CORE_URI_EXPORT
#include <sourcemeta/core/uri_export.h>
#endif
 
#include <sourcemeta/core/text.h>
 
// NOLINTBEGIN(misc-include-cleaner)
#include <sourcemeta/core/uri_error.h>
// NOLINTEND(misc-include-cleaner)
 
#include <array>       // std::array
#include <concepts>    // std::convertible_to, std::same_as
#include <cstddef>     // std::size_t, std::ptrdiff_t
#include <cstdint>     // std::uint8_t, std::uint32_t
#include <filesystem>  // std::filesystem
#include <istream>     // std::istream
#include <iterator>    // std::forward_iterator_tag
#include <memory>      // std::unique_ptr
#include <optional>    // std::optional
#include <span>        // std::span
#include <string>      // std::string
#include <string_view> // std::string_view
#include <type_traits> // std::is_same_v, std::remove_cvref_t
#include <utility>     // std::pair, std::forward
#include <vector>      // std::vector

 
namespace sourcemeta::core {

class SOURCEMETA_CORE_URI_EXPORT URI {
public:
  URI() = default;

  URI(const URI &) = default;

  URI(URI &&) noexcept = default;

  auto operator=(const URI &) -> URI & = default;

  auto operator=(URI &&) noexcept -> URI & = default;

  template <typename T>
    requires std::convertible_to<T, std::string_view> &&
             (!std::is_same_v<std::decay_t<T>, URI>)
  explicit URI(T &&input) {
    this->parse(std::string_view{std::forward<T>(input)});
  }

  URI(std::istream &input);

  [[nodiscard]] auto is_absolute() const noexcept -> bool;

  [[nodiscard]] auto is_urn() const -> bool;

  [[nodiscard]] auto is_tag() const -> bool;

  [[nodiscard]] auto is_mailto() const -> bool;

  [[nodiscard]] auto is_file() const -> bool;

  [[nodiscard]] auto is_http() const -> bool;

  [[nodiscard]] auto is_https() const -> bool;

  [[nodiscard]] auto is_fragment_only() const -> bool;

  [[nodiscard]] auto is_relative() const -> bool;

  [[nodiscard]] auto is_ipv4() const -> bool;

  [[nodiscard]] auto is_ipv6() const -> bool;

  [[nodiscard]] auto is_loopback() const -> bool;

  [[nodiscard]] auto is_localhost() const -> bool;

  [[nodiscard]] auto empty() const -> bool;

  [[nodiscard]] auto scheme() const -> std::optional<std::string_view>;

  [[nodiscard]] auto host() const -> std::optional<std::string_view>;

  [[nodiscard]] auto port() const -> std::optional<std::uint32_t>;

  [[nodiscard]] auto authority() const -> std::optional<std::string>;

  [[nodiscard]] auto path() const -> std::optional<std::string_view>;

  auto path(const std::string &path) -> URI &;

  auto path(std::string &&path) -> URI &;

  auto append_path(std::string_view path) -> URI &;

  auto append_path(const URI &reference) -> URI &;

  auto append_path(URI &&reference) -> URI &;

  auto extension(std::string &&extension) -> URI &;

  [[nodiscard]] auto fragment() const -> std::optional<std::string_view>;

  auto fragment(const std::string_view fragment) -> URI &;

  auto unescaped_fragment(const std::string_view fragment) -> URI &;

  class SOURCEMETA_CORE_URI_EXPORT Query {
  public:
    explicit Query(const std::string_view raw);

    [[nodiscard]] auto raw() const -> std::string_view;

    [[nodiscard]] auto at(const std::string_view name) const
        -> std::optional<std::string_view>;

    class SOURCEMETA_CORE_URI_EXPORT const_iterator {
    public:
      using iterator_category = std::forward_iterator_tag;
      using value_type = std::pair<std::string_view, std::string_view>;
      using difference_type = std::ptrdiff_t;
      using reference = const value_type &;
      using pointer = const value_type *;
 
      const_iterator() = default;
      const_iterator(const std::string_view raw, const std::size_t pair_start);
 
      [[nodiscard]] auto operator*() const -> reference;
      [[nodiscard]] auto operator->() const -> pointer;
      auto operator++() -> const_iterator &;
      auto operator++(int) -> const_iterator;
      [[nodiscard]] auto operator==(const const_iterator &other) const -> bool;
      [[nodiscard]] auto operator!=(const const_iterator &other) const -> bool;
 
    private:
#if defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable : 4251)
#endif
      std::string_view raw_{};
      std::size_t pair_start_{std::string_view::npos};
      value_type current_{};
#if defined(_MSC_VER)
#pragma warning(pop)
#endif
    };

    [[nodiscard]] auto begin() const -> const_iterator;

    [[nodiscard]] auto end() const -> const_iterator;
 
  private:
#if defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable : 4251)
#endif
    std::string_view raw_;
#if defined(_MSC_VER)
#pragma warning(pop)
#endif
  };

  [[nodiscard]] auto query() const -> std::optional<Query>;

  auto query(const std::string_view query) -> URI &;

  [[nodiscard]] auto recompose() const -> std::string;

  [[nodiscard]] auto recompose_relative() const -> std::string;

  [[nodiscard]] auto recompose_without_fragment() const
      -> std::optional<std::string>;

  auto canonicalize() -> URI &;

  [[nodiscard]] auto to_path() const -> std::filesystem::path;

  auto resolve_from(const URI &base) -> URI &;

  auto relative_to(const URI &base) -> URI &;

  auto rebase(const URI &base, const URI &new_base) -> URI &;

  auto rebase(const URI &base, URI &&new_base) -> URI &;

  [[nodiscard]] auto has_same_authority(const URI &other) const noexcept
      -> bool;

  [[nodiscard]] auto userinfo() const -> std::optional<std::string_view>;

  auto userinfo(const std::string_view userinfo) -> URI &;

  auto operator==(const URI &other) const noexcept -> bool;

  auto operator<(const URI &other) const noexcept -> bool;

  static auto from_fragment(const std::string_view fragment) -> URI;

  static auto from_unescaped_fragment(const std::string_view fragment) -> URI;

  static auto from_path(const std::filesystem::path &path) -> URI;

  static auto from_iri(std::string_view input) -> URI;

  [[nodiscard]] auto is_internationalized() const noexcept -> bool;

  static auto canonicalize(std::string_view input) -> std::string;

  [[nodiscard]] static auto escape(std::string_view input,
                                   bool maybe_encoded = false) -> std::string;

  template <typename Output>
  static auto escape(const std::string_view input, Output &output,
                     const bool maybe_encoded = false) -> void {
    output.reserve(output.size() + (input.size() * 3));
    for (std::size_t position = 0; position < input.size();) {
      auto byte{static_cast<unsigned char>(input[position])};
      std::size_t advance{1};
      // Treat the input as possibly already encoded by decoding each valid
      // escape before re-encoding, so a valid escape survives and a needlessly
      // encoded unreserved octet is decoded
      if (maybe_encoded && input[position] == '%' &&
          position + 2 < input.size()) {
        const auto high{hex_digit_value(input[position + 1])};
        const auto low{high < 0 ? static_cast<std::int8_t>(-1)
                                : hex_digit_value(input[position + 2])};
        if (low >= 0) {
          byte = static_cast<unsigned char>((high << 4) | low);
          advance = 3;
        }
      }
 
      position += advance;
      // RFC 3986 Section 2.3: the unreserved set passes through unescaped
      if (is_alphanum(static_cast<char>(byte)) || byte == '-' || byte == '.' ||
          byte == '_' || byte == '~') {
        output.push_back(static_cast<char>(byte));
      } else {
        // RFC 3986 Section 2.1: percent-encode with uppercase hexadecimal
        const auto high{static_cast<unsigned char>((byte >> 4U) & 0x0FU)};
        const auto low{static_cast<unsigned char>(byte & 0x0FU)};
        output.push_back('%');
        output.push_back(
            static_cast<char>(high < 10 ? '0' + high : 'A' + high - 10));
        output.push_back(
            static_cast<char>(low < 10 ? '0' + low : 'A' + low - 10));
      }
    }
  }

  template <typename Output>
  static auto escape_reference(const std::string_view input, Output &output)
      -> void {
    // RFC 3986 Section 2.2 and Section 2.3: the unreserved characters, the
    // sub-delims, and the gen-delims other than the square brackets and the
    // number sign
    static constexpr std::array<std::uint8_t, 256> PASS_THROUGH{{
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x00
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x10
        0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x20
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, // 0x30
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x40
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, // 0x50
        0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x60
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, // 0x70
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x80
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x90
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0xA0
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0xB0
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0xC0
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0xD0
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0xE0
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0  // 0xF0
    }};
 
    bool in_fragment{false};
    // The square brackets are rare, so the IP literal is only located once
    // one of them shows up
    bool literal_located{false};
    std::pair<std::size_t, std::size_t> literal{std::string_view::npos,
                                                std::string_view::npos};
    std::size_t run_start{0};
    for (std::size_t position = 0; position < input.size(); position += 1) {
      const auto byte{static_cast<unsigned char>(input[position])};
      // RFC 3986 Section 2.1: pct-encoded = "%" HEXDIG HEXDIG
      if (PASS_THROUGH[byte] != 0 ||
          (byte == '%' && is_percent_triplet(input, position))) {
        continue;
      }
 
      // RFC 3986 Section 3.5: "A fragment identifier component is indicated
      // by the presence of a number sign ("#") character and terminated by
      // the end of the URI", where fragment = *( pchar / "/" / "?" ) leaves no
      // room for another number sign
      if (byte == '#' && !in_fragment) {
        in_fragment = true;
        continue;
      }
 
      if (byte == '[' || byte == ']') [[unlikely]] {
        if (!literal_located) {
          literal = ip_literal_brackets(input);
          literal_located = true;
        }
 
        if (position == literal.first || position == literal.second) {
          continue;
        }
      }
 
      // The characters that pass through are appended in runs
      output.append(input.substr(run_start, position - run_start));
      // RFC 3986 Section 2.1: percent-encode with uppercase hexadecimal
      const auto high{static_cast<unsigned char>((byte >> 4U) & 0x0FU)};
      const auto low{static_cast<unsigned char>(byte & 0x0FU)};
      const std::array<char, 3> encoded{
          {'%', static_cast<char>(high < 10 ? '0' + high : 'A' + high - 10),
           static_cast<char>(low < 10 ? '0' + low : 'A' + low - 10)}};
      output.append(std::string_view{encoded.data(), encoded.size()});
      run_start = position + 1;
    }
 
    output.append(input.substr(run_start));
  }

  template <typename Output>
  static auto append_query_parameter(Output &sink, const std::string_view name,
                                     const std::string_view value,
                                     const char opener = '?') -> void {
    if (!sink.empty() && sink.back() != opener && sink.back() != '&') {
      sink.push_back('&');
    }
 
    URI::escape(name, sink);
    sink.push_back('=');
    URI::escape(value, sink);
  }

  [[nodiscard]] static auto unescape(std::string_view input) -> std::string;

  template <typename Output>
  [[nodiscard]] static auto unescape_form(const std::string_view input,
                                          Output &output) -> bool {
    const auto base{output.size()};
    output.reserve(base + input.size());
    for (std::size_t position = 0; position < input.size();) {
      const auto character{input[position]};
      if (character == '+') {
        output.push_back(' ');
        position += 1;
      } else if (character == '%') {
        const auto high{position + 2 < input.size()
                            ? hex_digit_value(input[position + 1])
                            : static_cast<std::int8_t>(-1)};
        const auto low{high < 0 ? static_cast<std::int8_t>(-1)
                                : hex_digit_value(input[position + 2])};
        if (low < 0) {
          output.resize(base, '\0');
          return false;
        }
 
        output.push_back(static_cast<char>((high << 4) | low));
        position += 3;
      } else {
        output.push_back(character);
        position += 1;
      }
    }
 
    return true;
  }

  template <typename Output>
  static auto escape_form(const std::string_view input, Output &output)
      -> void {
    output.reserve(output.size() + (input.size() * 3));
    for (const auto character : input) {
      const auto byte{static_cast<unsigned char>(character)};
      // WHATWG URL Section 5.2 percent-encodes with the space as plus flag set
      if (byte == ' ') {
        output.push_back('+');
        continue;
      }
 
      // WHATWG URL Section 1.3: "The application/x-www-form-urlencoded
      // percent-encode set contains all code points, except the ASCII
      // alphanumeric, U+002A (*), U+002D (-), U+002E (.), and U+005F (_)"
      if (is_alphanum(character) || byte == '*' || byte == '-' || byte == '.' ||
          byte == '_') {
        output.push_back(character);
        continue;
      }
 
      // RFC 3986 Section 2.1: percent-encode with uppercase hexadecimal
      const auto high{static_cast<unsigned char>((byte >> 4U) & 0x0FU)};
      const auto low{static_cast<unsigned char>(byte & 0x0FU)};
      output.push_back('%');
      output.push_back(
          static_cast<char>(high < 10 ? '0' + high : 'A' + high - 10));
      output.push_back(
          static_cast<char>(low < 10 ? '0' + low : 'A' + low - 10));
    }
  }

  template <typename Output>
  static auto append_form_parameter(Output &sink, const std::string_view name,
                                    const std::string_view value) -> void {
    // WHATWG URL Section 5.2: "If output is not the empty string, then append
    // U+0026 (&) to output"
    if (!sink.empty()) {
      sink.push_back('&');
    }
 
    URI::escape_form(name, sink);
    sink.push_back('=');
    URI::escape_form(value, sink);
  }

  template <typename Container>
    requires requires(Container container, Container::value_type entry) {
      container.emplace_back();
      entry.first.push_back('\0');
      entry.second.push_back('\0');
    }
  static auto parse_form(const std::string_view input, Container &output)
      -> void {
    std::size_t position{0};
    while (position <= input.size()) {
      const auto separator{input.find('&', position)};
      const auto end{separator == std::string_view::npos ? input.size()
                                                         : separator};
      const auto sequence{input.substr(position, end - position)};
      position = end + 1;
 
      // WHATWG URL Section 5.1: "If bytes is the empty byte sequence, then
      // continue"
      if (sequence.empty()) {
        continue;
      }
 
      // WHATWG URL Section 5.1: "If bytes contains a 0x3D (=), then let name
      // be the bytes from the start of bytes up to but excluding its first
      // 0x3D (=), and let value be the bytes, if any, after the first 0x3D
      // (=) up to the end of bytes"
      const auto equals{sequence.find('=')};
      auto &entry{output.emplace_back()};
      if (equals == std::string_view::npos) {
        URI::decode_form_component(sequence, entry.first);
      } else {
        URI::decode_form_component(sequence.substr(0, equals), entry.first);
        URI::decode_form_component(sequence.substr(equals + 1), entry.second);
      }
    }
  }

  [[nodiscard]] static auto normalize_path(std::string_view path)
      -> std::string;

  [[nodiscard]] static auto is_scheme(std::string_view input) noexcept -> bool;

  [[nodiscard]] static auto is_gen_delim(char character) noexcept -> bool;

  [[nodiscard]] static auto is_pchar(char character) noexcept -> bool;

  [[nodiscard]] static auto is_uri(std::string_view input) noexcept -> bool;

  [[nodiscard]] static auto is_uri_reference(std::string_view input) noexcept
      -> bool;

  [[nodiscard]] static auto
  is_absolute_path_reference(std::string_view input) noexcept -> bool;

  [[nodiscard]] static auto is_iri(std::string_view input) noexcept -> bool;

  [[nodiscard]] static auto is_iri_reference(std::string_view input) noexcept
      -> bool;

  [[nodiscard]] static auto strip_path_prefix(std::string_view path,
                                              std::string_view prefix)
      -> std::optional<std::string>;

  [[nodiscard]] static auto rebase_path(std::string_view path,
                                        std::string_view old_prefix,
                                        std::string_view new_prefix)
      -> std::optional<std::string>;
 
private:
  auto parse(std::string_view input) -> void;
 
  // The positions of the square brackets around the IP literal host of a URI
  // reference, if it has one
  [[nodiscard]] static auto ip_literal_brackets(std::string_view input) noexcept
      -> std::pair<std::size_t, std::size_t>;
 
  // WHATWG URL Section 5.1: "Replace any 0x2B (+) in name and value with 0x20
  // (SP)" and then percent-decode, which Section 1.3 defines to append a "%"
  // that is not followed by two hexadecimal digits as it appears rather than
  // to fail
  template <typename Output>
  static auto decode_form_component(const std::string_view input,
                                    Output &output) -> void {
    output.reserve(output.size() + input.size());
    for (std::size_t position = 0; position < input.size();) {
      const auto character{input[position]};
      if (character == '+') {
        output.push_back(' ');
        position += 1;
        continue;
      }
 
      if (character == '%' && position + 2 < input.size()) {
        const auto high{hex_digit_value(input[position + 1])};
        const auto low{high < 0 ? static_cast<std::int8_t>(-1)
                                : hex_digit_value(input[position + 2])};
        if (low >= 0) {
          output.push_back(static_cast<char>((high << 4) | low));
          position += 3;
          continue;
        }
      }
 
      output.push_back(character);
      position += 1;
    }
  }
 
// Exporting symbols that depends on the standard C++ library is considered
// safe.
// https://learn.microsoft.com/en-us/cpp/error-messages/compiler-warnings/compiler-warning-level-2-c4275?view=msvc-170&redirectedfrom=MSDN
#if defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable : 4251)
#endif
  std::optional<std::string> path_{};
  std::optional<std::string> userinfo_{};
  std::optional<std::string> host_{};
  std::optional<std::uint32_t> port_{};
  std::optional<std::string> scheme_{};
  std::optional<std::string> fragment_{};
  std::optional<std::string> query_{};
  bool ip_literal_{false};
  // Whether this object was parsed as an IRI (RFC 3987) rather than a URI
  // (RFC 3986)
  bool iri_{false};
#if defined(_MSC_VER)
#pragma warning(pop)
#endif
};
 
} // namespace sourcemeta::core
 
#endif