Formatting updates and apply ranges in url_search_parameters (#142)

* Use ranges algorithms in search parameters

* Ran clang-format on url_parser_context.cpp

Author: glynos

include/skyr/v1/url_search_parameters.hpp

@@ -13,6 +13,7 @@
 #include <optional>
 #include <algorithm>
 #include <cassert>
+#include <range/v3/algorithm/sort.hpp>
 
 namespace skyr {
 inline namespace v1 {
@@ -121,28 +122,28 @@ class url_search_parameters {
   void sort() {
     static constexpr auto less_name = [](const auto &lhs, const auto &rhs) { return lhs.first < rhs.first; };
 
-    std::sort(std::begin(parameters_), std::end(parameters_), less_name);
+    ranges::sort(parameters_, less_name);
     update();
   }
 
   /// \returns An iterator to the first element in the search parameters
-  [[nodiscard]] auto begin() const noexcept {
-    return parameters_.begin();
+  [[nodiscard]] auto cbegin() const noexcept {
+    return parameters_.cbegin();
   }
 
   /// \returns An iterator to the last element in the search parameters
-  [[nodiscard]] auto end() const noexcept {
-    return parameters_.end();
+  [[nodiscard]] auto cend() const noexcept {
+    return parameters_.cend();
   }
 
   /// \returns An iterator to the first element in the search parameters
-  [[nodiscard]] auto cbegin() const noexcept {
-    return begin();
+  [[nodiscard]] auto begin() const noexcept {
+    return cbegin();
   }
 
   /// \returns An iterator to the last element in the search parameters
-  [[nodiscard]] auto cend() const noexcept {
-    return end();
+  [[nodiscard]] auto end() const noexcept {
+    return cend();
   }
 
   /// \returns `true` if the URL search string is empty, `false`

src/v1/core/url_parser_context.cpp

@@ -11,7 +11,6 @@
 #include <skyr/v1/core/schemes.hpp>
 #include <skyr/v1/core/host.hpp>
 #include <skyr/v1/percent_encoding/percent_encoded_char.hpp>
-#include <skyr/v1/percent_encoding/percent_decode_range.hpp>
 #include <skyr/v1/string/starts_with.hpp>
 #include "url_parser_context.hpp"
 
@@ -21,14 +20,12 @@ using namespace std::string_literals;
 using namespace std::string_view_literals;
 
 namespace {
-auto contains(char byte, std::string_view view) noexcept {
-  auto first = begin(view), last = end(view);
+auto contains(std::string_view view, char byte) noexcept {
+  auto first = std::cbegin(view), last = std::cend(view);
   return last != std::find(first, last, byte);
 }
 
-auto remaining_starts_with(
-    std::string_view input,
-    std::string_view chars) noexcept {
+auto remaining_starts_with(std::string_view input, std::string_view chars) noexcept {
   return !input.empty() && starts_with(input.substr(1), chars);
 }
 
@@ -37,8 +34,8 @@ auto port_number(std::string_view port) noexcept -> tl::expected<std::uint16_t,
     return tl::make_unexpected(url_parse_errc::invalid_port);
   }
 
-  const char* port_first = port.data();
-  char* port_last = nullptr;
+  const char *port_first = port.data();
+  char *port_last = nullptr;
   auto port_value = std::strtoul(port_first, &port_last, 10);
 
   if (port_first == port_last) {
@@ -52,8 +49,7 @@ auto port_number(std::string_view port) noexcept -> tl::expected<std::uint16_t,
 }
 
 auto is_url_code_point(char byte) noexcept {
-  return
-      std::isalnum(byte, std::locale::classic()) || contains(byte, "!$&'()*+,-./:;=?@_~"sv);
+  return std::isalnum(byte, std::locale::classic()) || contains("!$&'()*+,-./:;=?@_~"sv, byte);
 }
 
 inline auto is_windows_drive_letter(std::string_view segment) noexcept {
@@ -85,37 +81,26 @@ auto is_double_dot_path_segment(std::string_view segment) noexcept {
 }
 
 void shorten_path(std::string_view scheme, std::vector<std::string> &path) {
-  if (path.empty()) {
-    return;
+  if (!path.empty() && !((scheme == "file"sv) && (path.size() == 1) && is_windows_drive_letter(path.front()))) {
+    path.pop_back();
   }
-
-  if ((scheme == "file"sv) &&
-      (path.size() == 1) &&
-      is_windows_drive_letter(path.front())) {
-    return;
-  }
-
-  path.pop_back();
 }
-} // namespace
-
-url_parser_context::url_parser_context(
-    std::string_view input,
-    bool *validation_error,
-    const url_record *base,
-    const url_record *url,
-    std::optional<url_parse_state> state_override)
-    : input(input)
-    , it(begin(input))
-    , validation_error(validation_error)
-    , base(base)
-    , url(http://github.com/url?%20*url%20:%20url_record{})
-    , state(state_override? state_override.value() : url_parse_state::scheme_start)
-    , state_override(state_override)
-    , buffer()
-    , at_flag(false)
-    , square_braces_flag(false)
-    , password_token_seen_flag(false) {}
+}  // namespace
+
+url_parser_context::url_parser_context(std::string_view input, bool *validation_error, const url_record *base,
+                                       const url_record *url, std::optional<url_parse_state> state_override)
+    : input(input),
+      it(begin(input)),
+      validation_error(validation_error),
+      base(base),
+      url(http://github.com/url%20?%20*url%20:%20url_record{}),
+      state(state_override ? state_override.value() : url_parse_state::scheme_start),
+      state_override(state_override),
+      buffer(),
+      at_flag(false),
+      square_braces_flag(false),
+      password_token_seen_flag(false) {
+}
 
 auto url_parser_context::parse_scheme_start(char byte) -> tl::expected<url_parse_action, url_parse_errc> {
   if (std::isalpha(byte, std::locale::classic())) {
@@ -135,7 +120,7 @@ auto url_parser_context::parse_scheme_start(char byte) -> tl::expected<url_parse
 }
 
 auto url_parser_context::parse_scheme(char byte) -> tl::expected<url_parse_action, url_parse_errc> {
-  if (std::isalnum(byte, std::locale::classic()) || contains(byte, "+-."sv)) {
+  if (std::isalnum(byte, std::locale::classic()) || contains("+-."sv, byte)) {
     auto lower = std::tolower(byte, std::locale::classic());
     buffer.push_back(lower);
   } else if (byte == ':') {
@@ -191,8 +176,7 @@ auto url_parser_context::parse_scheme(char byte) -> tl::expected<url_parse_actio
     state = url_parse_state::no_scheme;
     reset();
     return url_parse_action::continue_;
-  }
-  else {
+  } else {
     return tl::make_unexpected(url_parse_errc::invalid_scheme_character);
   }
 
@@ -256,8 +240,7 @@ auto url_parser_context::parse_relative(char byte) -> tl::expected<url_parse_act
     url.port = base->port;
     url.path = base->path;
     url.query = base->query;
-  }
-  else if (byte == '/') {
+  } else if (byte == '/') {
     state = url_parse_state::relative_slash;
   } else if (byte == '?') {
     url.username = base->username;
@@ -308,11 +291,9 @@ auto url_parser_context::parse_relative_slash(char byte) -> tl::expected<url_par
       *validation_error |= true;
     }
     state = url_parse_state::special_authority_ignore_slashes;
-  }
-  else if (byte == '/') {
+  } else if (byte == '/') {
     state = url_parse_state::authority;
-  }
-  else {
+  } else {
     url.username = base->username;
     url.password = base->password;
     url.host = base->host;
@@ -338,7 +319,8 @@ auto url_parser_context::parse_special_authority_slashes(char byte) -> tl::expec
   return url_parse_action::increment;
 }
 
-auto url_parser_context::parse_special_authority_ignore_slashes(char byte) -> tl::expected<url_parse_action, url_parse_errc> {
+auto url_parser_context::parse_special_authority_ignore_slashes(char byte)
+    -> tl::expected<url_parse_action, url_parse_errc> {
   if ((byte != '/') && (byte != '\\')) {
     decrement();
     state = url_parse_state::authority;
@@ -370,9 +352,7 @@ auto url_parser_context::parse_authority(char byte) -> tl::expected<url_parse_ac
       }
     }
     buffer.clear();
-  } else if (
-      ((is_eof()) || (byte == '/') || (byte == '?') || (byte == '#')) ||
-          (url.is_special() && (byte == '\\'))) {
+  } else if (((is_eof()) || (byte == '/') || (byte == '?') || (byte == '#')) || (url.is_special() && (byte == '\\'))) {
     if (at_flag && buffer.empty()) {
       *validation_error |= true;
       return tl::make_unexpected(url_parse_errc::empty_hostname);
@@ -412,21 +392,15 @@ auto url_parser_context::parse_hostname(char byte) -> tl::expected<url_parse_act
     if (state_override && (state_override.value() == url_parse_state::hostname)) {
       return url_parse_action::success;
     }
-  } else if (
-      (is_eof() || (byte == '/') || (byte == '?') || (byte == '#')) ||
-          (url.is_special() && (byte == '\\'))) {
+  } else if ((is_eof() || (byte == '/') || (byte == '?') || (byte == '#')) || (url.is_special() && (byte == '\\'))) {
     if (it != begin(input)) {
       decrement();
     }
 
     if (url.is_special() && buffer.empty()) {
       *validation_error |= true;
       return tl::make_unexpected(url_parse_errc::empty_hostname);
-    }
-    else if (
-        state_override &&
-        buffer.empty() &&
-        (url.includes_credentials() || url.port)) {
+    } else if (state_override && buffer.empty() && (url.includes_credentials() || url.port)) {
       *validation_error |= true;
       return url_parse_action::success;
     }
@@ -456,10 +430,8 @@ auto url_parser_context::parse_hostname(char byte) -> tl::expected<url_parse_act
 auto url_parser_context::parse_port(char byte) -> tl::expected<url_parse_action, url_parse_errc> {
   if (std::isdigit(byte, std::locale::classic())) {
     buffer += byte;
-  } else if (
-      ((is_eof()) || (byte == '/') || (byte == '?') || (byte == '#')) ||
-          (url.is_special() && (byte == '\\')) ||
-          state_override) {
+  } else if (((is_eof()) || (byte == '/') || (byte == '?') || (byte == '#')) || (url.is_special() && (byte == '\\')) ||
+             state_override) {
     if (!buffer.empty()) {
       auto port = port_number(buffer);
 
@@ -471,8 +443,7 @@ auto url_parser_context::parse_port(char byte) -> tl::expected<url_parse_action,
       auto dport = default_port(url.scheme);
       if (dport && (dport.value() == port.value())) {
         url.port = std::nullopt;
-      }
-      else {
+      } else {
         url.port = port.value();
       }
       buffer.clear();
@@ -505,8 +476,7 @@ auto url_parser_context::parse_file(char byte) -> tl::expected<url_parse_action,
       url.host = base->host;
       url.path = base->path;
       url.query = base->query;
-    }
-    else if (byte == '?') {
+    } else if (byte == '?') {
       url.host = base->host;
       url.path = base->path;
       url.query = std::string();
@@ -522,8 +492,7 @@ auto url_parser_context::parse_file(char byte) -> tl::expected<url_parse_action,
         url.host = base->host;
         url.path = base->path;
         shorten_path(url.scheme, url.path);
-      }
-      else {
+      } else {
         *validation_error |= true;
       }
       state = url_parse_state::path;
@@ -551,8 +520,7 @@ auto url_parser_context::parse_file_slash(char byte) -> tl::expected<url_parse_a
     state = url_parse_state::file_host;
   } else {
     auto substr = input.substr(std::distance(begin(input), it));
-    if (base &&
-            ((base->scheme == "file") && !is_windows_drive_letter(substr))) {
+    if (base && ((base->scheme == "file") && !is_windows_drive_letter(substr))) {
       if (!base->path.empty() && is_windows_drive_letter(base->path[0])) {
         url.path.push_back(base->path[0]);
       } else {
@@ -643,8 +611,7 @@ auto url_parser_context::parse_path_start(char byte) -> tl::expected<url_parse_a
 }
 
 auto url_parser_context::parse_path(char byte) -> tl::expected<url_parse_action, url_parse_errc> {
-  if (((is_eof()) || (byte == '/')) ||
-      (url.is_special() && (byte == '\\')) ||
+  if (((is_eof()) || (byte == '/')) || (url.is_special() && (byte == '\\')) ||
       (!state_override && ((byte == '?') || (byte == '#')))) {
     if (url.is_special() && (byte == '\\')) {
       *validation_error |= true;
@@ -655,13 +622,10 @@ auto url_parser_context::parse_path(char byte) -> tl::expected<url_parse_action,
       if (!((byte == '/') || (url.is_special() && (byte == '\\')))) {
         url.path.emplace_back();
       }
-    } else if (
-        is_single_dot_path_segment(buffer) &&
-            !((byte == '/') || (url.is_special() && (byte == '\\')))) {
+    } else if (is_single_dot_path_segment(buffer) && !((byte == '/') || (url.is_special() && (byte == '\\')))) {
       url.path.emplace_back();
     } else if (!is_single_dot_path_segment(buffer)) {
-      if ((url.scheme == "file") &&
-          url.path.empty() && is_windows_drive_letter(buffer)) {
+      if ((url.scheme == "file") && url.path.empty() && is_windows_drive_letter(buffer)) {
         if (!url.host || !url.host.value().is_empty()) {
           *validation_error |= true;
           url.host = skyr::host{skyr::v1::empty_host{}};
@@ -716,8 +680,7 @@ auto url_parser_context::parse_cannot_be_a_base_url(http://github.com/char%20byte) -> tl::expected<u
     auto substr = input.substr(std::distance(std::begin(input), it));
     if (!is_eof() && (!is_url_code_point(byte) && (byte != '%'))) {
       *validation_error |= true;
-    }
-    else if ((byte == '%') && !percent_encoding::is_percent_encoded(substr)) {
+    } else if ((byte == '%') && !percent_encoding::is_percent_encoded(substr)) {
       *validation_error |= true;
     }
     if (!is_eof()) {
@@ -733,10 +696,7 @@ auto url_parser_context::parse_query(char byte) -> tl::expected<url_parse_action
     url.fragment = std::string();
     state = url_parse_state::fragment;
   } else if (!is_eof()) {
-    if ((byte < '!') ||
-        (byte > '~') ||
-        (contains(byte, R"("#<>)"sv)) ||
-        ((byte == '\'') && url.is_special())) {
+    if ((byte < '!') || (byte > '~') || (contains(R"("#<>)"sv, byte)) || ((byte == '\'') && url.is_special())) {
       auto pct_encoded = percent_encode_byte(std::byte(byte), percent_encoding::encode_set::none);
       url.query.value() += pct_encoded.to_string();
     } else {