use url_pattern_encoding_callback

include/ada/url_pattern-inl.h

@@ -27,6 +27,11 @@ inline std::string_view url_pattern_component::get_regexp() const noexcept
   return regexp;
 }
 
+inline std::string_view url_pattern_component::get_regexp_flags() const noexcept
+    ada_lifetime_bound {
+  return flags;
+}
+
 inline const std::vector<std::string>&
 url_pattern_component::get_group_name_list() const noexcept ada_lifetime_bound {
   return group_name_list;

include/ada/url_pattern.h

@@ -8,7 +8,6 @@
 #include "ada/expected.h"
 
 #include <string>
-#include <tuple>
 #include <unordered_map>
 #include <variant>
 #include <vector>
@@ -28,13 +27,10 @@ tl::expected<result_type, url_pattern_errors> parse_url_pattern_impl(
 // Important: C++20 allows us to use concept rather than `using` or `typedef
 // and allows functions with second argument, which is optional (using either
 // std::nullopt or a parameter with default value)
-// template <typename F>
-// concept url_pattern_encoding_callback = requires(F f, std::string_view sv) {
-//   { f(sv) } -> std::same_as<tl::expected<std::string, url_pattern_errors>>;
-// } || requires(F f, std::string_view sv, std::string_view opt) {
-//   { f(sv, opt) } -> std::same_as<tl::expected<std::string,
-//   url_pattern_errors>>;
-// };
+template <typename F>
+concept url_pattern_encoding_callback = requires(F f, std::string_view sv) {
+  { f(sv) } -> std::same_as<tl::expected<std::string, url_pattern_errors>>;
+};
 
 // A structure providing matching patterns for individual components
 // of a URL. When a URLPattern is created, or when a URLPattern is
@@ -186,36 +182,41 @@ class url_pattern_component {
 
   // This function explicitly takes a std::string because it is moved.
   // To avoid unnecessary copy, move each value while calling the constructor.
-  url_pattern_component(std::string new_pattern, std::string new_regexp,
-                        std::vector<std::string> new_group_name_list,
+  url_pattern_component(std::string&& new_pattern, std::string&& new_regexp,
+                        std::string&& new_flags,
+                        std::vector<std::string>&& new_group_name_list,
                         bool new_has_regexp_groups)
       : pattern(std::move(new_pattern)),
+        flags(std::move(new_flags)),
         regexp(std::move(new_regexp)),
         group_name_list(std::move(new_group_name_list)),
         has_regexp_groups_(new_has_regexp_groups){};
 
   // @see https://urlpattern.spec.whatwg.org/#compile-a-component
-  template <typename url_pattern_encoding_callback>
+  template <url_pattern_encoding_callback F>
   static tl::expected<url_pattern_component, url_pattern_errors> compile(
-      std::string_view input, url_pattern_encoding_callback encoding_callback,
+      std::string_view input, F encoding_callback,
       url_pattern_compile_component_options& options);
 
   // @see https://urlpattern.spec.whatwg.org/#create-a-component-match-result
   url_pattern_component_result create_component_match_result(
       std::string_view input, const std::vector<std::string>& exec_result);
 
-  std::string_view get_pattern() const noexcept ada_lifetime_bound;
-  std::string_view get_regexp() const noexcept ada_lifetime_bound;
+  std::string_view get_pattern() const noexcept ada_lifetime_bound
+      ada_warn_unused;
+  std::string_view get_regexp() const noexcept ada_lifetime_bound
+      ada_warn_unused;
+  std::string_view get_regexp_flags() const noexcept ada_lifetime_bound
+      ada_warn_unused;
   const std::vector<std::string>& get_group_name_list() const noexcept
-      ada_lifetime_bound;
-  inline bool has_regexp_groups() const noexcept ada_lifetime_bound;
+      ada_lifetime_bound ada_warn_unused;
+  inline bool has_regexp_groups() const noexcept ada_lifetime_bound
+      ada_warn_unused;
 
  private:
-  // The normalized pattern for this component.
-  std::string pattern = "";
-  // The generated JavaScript regular expression for this component.
-  std::string regexp = "";
-  // The list of sub-component names extracted for this component.
+  std::string pattern{};
+  std::string flags{};
+  std::string regexp{};
   std::vector<std::string> group_name_list{};
 
   bool has_regexp_groups_ = false;

include/ada/url_pattern_helpers-inl.h

@@ -332,7 +332,7 @@ inline bool is_valid_name_code_point(char cp, bool first) {
   return true;
 }
 
-template <typename F>
+template <url_pattern_encoding_callback F>
 Token* url_pattern_parser<F>::try_consume_modifier_token() {
   // Let token be the result of running try to consume a token given parser and
   // "other-modifier".
@@ -346,7 +346,7 @@ Token* url_pattern_parser<F>::try_consume_modifier_token() {
   return token;
 }
 
-template <typename F>
+template <url_pattern_encoding_callback F>
 Token* url_pattern_parser<F>::try_consume_regexp_or_wildcard_token(
     Token* name_token) {
   // Let token be the result of running try to consume a token given parser and
@@ -361,7 +361,7 @@ Token* url_pattern_parser<F>::try_consume_regexp_or_wildcard_token(
   return token;
 }
 
-template <typename F>
+template <url_pattern_encoding_callback F>
 Token* url_pattern_parser<F>::try_consume_token(token_type type) {
   // Assert: parser’s index is less than parser’s token list size.
   ADA_ASSERT_TRUE(index < tokens.size());
@@ -375,7 +375,7 @@ Token* url_pattern_parser<F>::try_consume_token(token_type type) {
   return &next_token;
 }
 
-template <typename F>
+template <url_pattern_encoding_callback F>
 std::string url_pattern_parser<F>::consume_text() {
   // Let result be the empty string.
   std::string result{};
@@ -396,7 +396,7 @@ std::string url_pattern_parser<F>::consume_text() {
   return result;
 }
 
-template <typename F>
+template <url_pattern_encoding_callback F>
 tl::expected<Token, url_pattern_errors>
 url_pattern_parser<F>::consume_required_token(token_type type) {
   // Let result be the result of running try to consume a token given parser and
@@ -406,18 +406,17 @@ url_pattern_parser<F>::consume_required_token(token_type type) {
   if (!result) {
     return tl::unexpected(url_pattern_errors::type_error);
   }
-  return std::move(*result);
+  return *result;
 }
 
-template <typename F>
+template <url_pattern_encoding_callback F>
 std::optional<url_pattern_errors>
 url_pattern_parser<F>::maybe_add_part_from_the_pending_fixed_value() {
   // If parser’s pending fixed value is the empty string, then return.
   if (pending_fixed_value.empty()) return std::nullopt;
   // Let encoded value be the result of running parser’s encoding callback given
   // parser’s pending fixed value.
-  tl::expected<std::string, url_pattern_errors> encoded_value =
-      encoding_callback(pending_fixed_value);
+  auto encoded_value = encoding_callback(pending_fixed_value);
   if (!encoded_value) {
     return encoded_value.error();
   }
@@ -426,14 +425,14 @@ url_pattern_parser<F>::maybe_add_part_from_the_pending_fixed_value() {
   // Let part be a new part whose type is "fixed-text", value is encoded value,
   // and modifier is "none".
   url_pattern_part part{.type = url_pattern_part_type::FIXED_TEXT,
-                        .value = std::move(encoded_value.value()),
+                        .value = std::move(*encoded_value),
                         .modifier = url_pattern_part_modifier::NONE};
   // Append part to parser’s part list.
   parts.push_back(std::move(part));
   return std::nullopt;
 }
 
-template <typename F>
+template <url_pattern_encoding_callback F>
 std::optional<url_pattern_errors> url_pattern_parser<F>::add_part(
     std::string_view prefix, Token* name_token, Token* regexp_or_wildcard_token,
     std::string_view suffix, Token* modifier_token) {
@@ -554,7 +553,7 @@ std::optional<url_pattern_errors> url_pattern_parser<F>::add_part(
   return std::nullopt;
 }
 
-template <typename F>
+template <url_pattern_encoding_callback F>
 bool url_pattern_parser<F>::is_duplicate_name(std::string_view name) {
   // For each part of parser’s part list:
   // If part’s name is name, then return true.

include/ada/url_pattern_helpers.h

@@ -6,6 +6,7 @@
 #define ADA_URL_PATTERN_HELPERS_H
 
 #include "ada/expected.h"
+#include "ada/url_pattern.h"
 
 #include <string>
 #include <tuple>
@@ -48,10 +49,10 @@ struct Token {
 };
 
 // @see https://urlpattern.spec.whatwg.org/#pattern-parser
-template <typename url_pattern_encoding_callback>
+template <url_pattern_encoding_callback F>
 class url_pattern_parser {
  public:
-  url_pattern_parser(url_pattern_encoding_callback&& encoding_callback_,
+  url_pattern_parser(F&& encoding_callback_,
                      std::string_view segment_wildcard_regexp_)
       : encoding_callback(encoding_callback_),
         segment_wildcard_regexp(std::string(segment_wildcard_regexp_)) {}
@@ -81,7 +82,7 @@ class url_pattern_parser {
   bool is_duplicate_name(std::string_view name);
 
   std::vector<Token> tokens{};
-  url_pattern_encoding_callback encoding_callback;
+  F encoding_callback;
   std::string segment_wildcard_regexp;
   std::vector<url_pattern_part> parts{};
   std::string pending_fixed_value{};
@@ -299,11 +300,11 @@ constexpr bool is_absolute_pathname(std::string_view input,
                                     std::string_view type) noexcept;
 
 // @see https://urlpattern.spec.whatwg.org/#parse-a-pattern-string
-template <typename url_pattern_encoding_callback>
+template <url_pattern_encoding_callback F>
 tl::expected<std::vector<url_pattern_part>, url_pattern_errors>
 parse_pattern_string(std::string_view input,
                      url_pattern_compile_component_options& options,
-                     url_pattern_encoding_callback&& encoding_callback);
+                     F&& encoding_callback);
 
 // @see https://urlpattern.spec.whatwg.org/#generate-a-pattern-string
 std::string generate_pattern_string(

src/url_pattern.cpp

@@ -2,7 +2,6 @@
 
 #include <algorithm>
 #include <optional>
-#include <ranges>
 #include <regex>
 #include <string>
 
@@ -411,10 +410,9 @@ tl::expected<std::string, url_pattern_errors> url_pattern_init::process_hash(
   return url_pattern_helpers::canonicalize_hash(value);
 }
 
-template <typename url_pattern_encoding_callback>
+template <url_pattern_encoding_callback F>
 tl::expected<url_pattern_component, url_pattern_errors>
-url_pattern_component::compile(std::string_view input,
-                               url_pattern_encoding_callback encoding_callback,
+url_pattern_component::compile(std::string_view input, F encoding_callback,
                                url_pattern_compile_component_options& options) {
   // Let part list be the result of running parse a pattern string given input,
   // options, and encoding callback.
@@ -427,20 +425,19 @@ url_pattern_component::compile(std::string_view input,
 
   // Let (regular expression string, name list) be the result of running
   // generate a regular expression and name list given part list and options.
-  auto [regular_expression, name_list] =
+  auto [regular_expression_string, name_list] =
       url_pattern_helpers::generate_regular_expression_and_name_list(*part_list,
                                                                      options);
 
   // Let flags be an empty string.
   // If options’s ignore case is true then set flags to "vi".
   // Otherwise set flags to "v"
-  // TODO: Optimization opportunity: Move this to options constructor and use
-  // std::string_view to stop allocating unnecessary memory.
   std::string flags = options.ignore_case ? "vi" : "v";
 
   // Let regular expression be RegExpCreate(regular expression string, flags).
   // If this throws an exception, catch it, and throw a TypeError.
-  // TODO: Investigate how to properly support this.
+  // Note: We don't implement this, since we expect library users to use their
+  // own regular expression engine.
 
   // Let pattern string be the result of running generate a pattern string given
   // part list and options.
@@ -455,8 +452,8 @@ url_pattern_component::compile(std::string_view input,
   // Return a new component whose pattern string is pattern string, regular
   // expression is regular expression, group name list is name list, and has
   // regexp groups is has regexp groups.
-  return url_pattern_component(std::move(pattern_string),
-                               std::move(regular_expression),
+  return url_pattern_component(std::move(pattern_string), std::move(flags),
+                               std::move(regular_expression_string),
                                std::move(name_list), has_regexp_groups);
 }
 

src/url_pattern_helpers.cpp

@@ -873,23 +873,23 @@ constexpr bool is_absolute_pathname(std::string_view input,
   return false;
 }
 
-template <typename url_pattern_encoding_callback>
+template <url_pattern_encoding_callback F>
 tl::expected<std::vector<url_pattern_part>, url_pattern_errors>
 parse_pattern_string(std::string_view input,
                      url_pattern_compile_component_options& options,
-                     url_pattern_encoding_callback&& encoding_callback) {
+                     F&& encoding_callback) {
   // Let parser be a new pattern parser whose encoding callback is encoding
   // callback and segment wildcard regexp is the result of running generate a
   // segment wildcard regexp given options.
-  auto parser = url_pattern_parser<url_pattern_encoding_callback>(
+  auto parser = url_pattern_parser<F>(
       encoding_callback, generate_segment_wildcard_regexp(options));
   // Set parser’s token list to the result of running tokenize given input and
   // "strict".
   auto tokenize_result = tokenize(input, token_policy::STRICT);
   if (!tokenize_result) {
     return tl::unexpected(tokenize_result.error());
   }
-  parser.tokens = std::move(tokenize_result.value<std::vector<Token>>());
+  parser.tokens = std::move(*tokenize_result);
 
   // While parser’s index is less than parser’s token list's size:
   while (parser.index < parser.tokens.size()) {
@@ -898,13 +898,13 @@ parse_pattern_string(std::string_view input,
     auto char_token = parser.try_consume_token(token_type::CHAR);
     // Let name token be the result of running try to consume a token given
     // parser and "name".
-    auto name_token_ = parser.try_consume_token(token_type::NAME);
+    auto name_token = parser.try_consume_token(token_type::NAME);
     // Let regexp or wildcard token be the result of running try to consume a
     // regexp or wildcard token given parser and name token.
-    auto regexp_or_wildcard_token_ =
-        parser.try_consume_token(token_type::REGEXP);
+    auto regexp_or_wildcard_token =
+        parser.try_consume_regexp_or_wildcard_token(name_token);
     // If name token is not null or regexp or wildcard token is not null:
-    if (name_token_ || regexp_or_wildcard_token_) {
+    if (name_token || regexp_or_wildcard_token) {
       // Let prefix be the empty string.
       std::string prefix{};
       // If char token is not null then set prefix to char token’s value.
@@ -922,12 +922,12 @@ parse_pattern_string(std::string_view input,
       }
       // Let modifier token be the result of running try to consume a modifier
       // token given parser.
-      auto modifier_token_ = parser.try_consume_modifier_token();
+      auto modifier_token = parser.try_consume_modifier_token();
       // Run add a part given parser, prefix, name token, regexp or wildcard
       // token, the empty string, and modifier token.
       if (auto error =
-              parser.add_part(prefix, name_token_, regexp_or_wildcard_token_,
-                              {}, modifier_token_)) {
+              parser.add_part(prefix, name_token, regexp_or_wildcard_token, {},
+                              modifier_token)) {
         return tl::unexpected(*error);
       }
       // Continue.
@@ -956,26 +956,25 @@ parse_pattern_string(std::string_view input,
       auto prefix_ = parser.consume_text();
       // Set name token to the result of running try to consume a token given
       // parser and "name".
-      name_token_ = parser.try_consume_token(token_type::NAME);
+      name_token = parser.try_consume_token(token_type::NAME);
       // Set regexp or wildcard token to the result of running try to consume a
       // regexp or wildcard token given parser and name token.
-      regexp_or_wildcard_token_ =
-          parser.try_consume_regexp_or_wildcard_token(name_token_);
+      regexp_or_wildcard_token =
+          parser.try_consume_regexp_or_wildcard_token(name_token);
       // Let suffix be the result of running consume text given parser.
       auto suffix_ = parser.consume_text();
       // Run consume a required token given parser and "close".
-      auto required_token = parser.consume_required_token(token_type::CLOSE);
-      if (!required_token) {
+      if (!parser.consume_required_token(token_type::CLOSE)) {
         return tl::unexpected(url_pattern_errors::type_error);
       }
       // Set modifier token to the result of running try to consume a modifier
       // token given parser.
-      auto modifier_token_ = parser.try_consume_modifier_token();
+      auto modifier_token = parser.try_consume_modifier_token();
       // Run add a part given parser, prefix, name token, regexp or wildcard
       // token, suffix, and modifier token.
       if (auto error =
-              parser.add_part(prefix_, name_token_, regexp_or_wildcard_token_,
-                              suffix_, modifier_token_)) {
+              parser.add_part(prefix_, name_token, regexp_or_wildcard_token,
+                              suffix_, modifier_token)) {
         return tl::unexpected(*error);
       }
       // Continue.
@@ -986,8 +985,7 @@ parse_pattern_string(std::string_view input,
       return tl::unexpected(*error);
     }
     // Run consume a required token given parser and "end".
-    auto required_token = parser.consume_required_token(token_type::END);
-    if (!required_token) {
+    if (!parser.consume_required_token(token_type::END)) {
       return tl::unexpected(url_pattern_errors::type_error);
     }
   }