semi-implement match

include/ada/url_pattern-inl.h

@@ -27,6 +27,31 @@ url_pattern_component::get_group_name_list() const noexcept ada_lifetime_bound {
   return group_name_list;
 }
 
+inline url_pattern_component_result
+url_pattern_component::create_component_match_result(
+    std::string_view input, const std::vector<std::string>& exec_result) {
+  // Let result be a new URLPatternComponentResult.
+  auto result = url_pattern_component_result{};
+  // Set result["input"] to input.
+  result.input = std::string(input);
+  // Let groups be a record<USVString, (USVString or undefined)>.
+  result.groups = {};
+  // Let index be 1.
+  size_t index = 1;
+  // While index is less than Get(execResult, "length"):
+  while (index < exec_result.size()) {
+    // Let name be component’s group name list[index − 1].
+    auto name = group_name_list[index - 1];
+    // Let value be Get(execResult, ToString(index)).
+    auto value = exec_result.at(index);
+    // Set groups[name] to value.
+    result.groups.insert({name, value});
+    // Increment index by 1.
+    index++;
+  }
+  return result;
+}
+
 inline std::string_view url_pattern::get_protocol() const ada_lifetime_bound {
   // Return this's associated URL pattern's protocol component's pattern string.
   return protocol_component.get_pattern();

include/ada/url_pattern.h

@@ -164,6 +164,16 @@ struct url_pattern_compile_component_options {
   static url_pattern_compile_component_options PATHNAME;
 };
 
+// A struct providing the URLPattern matching results for a single
+// URL component. The URLPatternComponentResult is only ever used
+// as a member attribute of a URLPatternResult struct. The
+// URLPatternComponentResult API is defined as part of the URLPattern
+// specification.
+struct url_pattern_component_result {
+  std::string input;
+  std::unordered_map<std::string, std::string> groups;
+};
+
 class url_pattern_component {
  public:
   url_pattern_component() = default;
@@ -184,6 +194,10 @@ class url_pattern_component {
       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;
   const std::vector<std::string>& get_group_name_list() const noexcept
@@ -201,16 +215,6 @@ class url_pattern_component {
   bool has_regexp_groups_ = false;
 };
 
-// A struct providing the URLPattern matching results for a single
-// URL component. The URLPatternComponentResult is only ever used
-// as a member attribute of a URLPatternResult struct. The
-// URLPatternComponentResult API is defined as part of the URLPattern
-// specification.
-struct url_pattern_component_result {
-  std::string input;
-  std::unordered_map<std::string, std::string> groups;
-};
-
 using url_pattern_input = std::variant<std::string_view, url_pattern_init>;
 
 // A struct providing the URLPattern matching results for all
@@ -245,15 +249,15 @@ class url_pattern {
                        std::optional<url_pattern_options> options);
 
   // @see https://urlpattern.spec.whatwg.org/#dom-urlpattern-exec
-  tl::expected<url_pattern_result, url_pattern_errors> exec(
+  tl::expected<std::optional<url_pattern_result>, url_pattern_errors> exec(
       std::variant<url_pattern_init, url_aggregator> input,
       std::string_view* base_url);
   // @see https://urlpattern.spec.whatwg.org/#dom-urlpattern-test
   bool test(std::variant<url_pattern_init, url_aggregator> input,
             std::string_view* base_url);
 
   // @see https://urlpattern.spec.whatwg.org/#url-pattern-match
-  tl::expected<url_pattern_result, url_pattern_errors> match(
+  tl::expected<std::optional<url_pattern_result>, url_pattern_errors> match(
       std::variant<url_pattern_init, url_aggregator> input,
       std::string_view* base_url_string);
 

src/url_pattern.cpp

@@ -1605,9 +1605,9 @@ bool protocol_component_matches_special_scheme(std::string_view input) {
 
 // TODO: This function argument should bve url_pattern_input but the spec is
 // vague.
-tl::expected<url_pattern_result, url_pattern_errors> url_pattern::exec(
-    std::variant<url_pattern_init, url_aggregator> input,
-    std::string_view* base_url = nullptr) {
+tl::expected<std::optional<url_pattern_result>, url_pattern_errors>
+url_pattern::exec(std::variant<url_pattern_init, url_aggregator> input,
+                  std::string_view* base_url = nullptr) {
   // Return the result of match given this's associated URL pattern, input, and
   // baseURL if given.
   return match(input, base_url);
@@ -1621,15 +1621,16 @@ bool url_pattern::test(std::variant<url_pattern_init, url_aggregator> input,
   // Implement a fast path just like `can_parse()` in ada_url.
   // Let result be the result of match given this's associated URL pattern,
   // input, and baseURL if given.
-  auto result = match(input, base_url);
   // If result is null, return false.
-  // Return true.
-  return result.has_value();
+  if (auto result = match(input, base_url); result.has_value()) {
+    return result->has_value();
+  }
+  return false;
 }
 
-tl::expected<url_pattern_result, url_pattern_errors> url_pattern::match(
-    std::variant<url_pattern_init, url_aggregator> input,
-    std::string_view* base_url_string) {
+tl::expected<std::optional<url_pattern_result>, url_pattern_errors>
+url_pattern::match(std::variant<url_pattern_init, url_aggregator> input,
+                   std::string_view* base_url_string) {
   std::string protocol{};
   std::string username{};
   std::string password{};
@@ -1657,10 +1658,190 @@ tl::expected<url_pattern_result, url_pattern_errors> url_pattern::match(
     auto apply_result = url_pattern_init::process(
         std::get<url_pattern_init>(input), "url", protocol, username, password,
         hostname, port, pathname, search, hash);
+
+    // Set protocol to applyResult["protocol"].
+    ADA_ASSERT_TRUE(apply_result->protocol.has_value());
+    protocol = apply_result->protocol.value();
+
+    // Set username to applyResult["username"].
+    ADA_ASSERT_TRUE(apply_result->username.has_value());
+    username = apply_result->username.value();
+
+    // Set password to applyResult["password"].
+    ADA_ASSERT_TRUE(apply_result->password.has_value());
+    password = apply_result->password.value();
+
+    // Set hostname to applyResult["hostname"].
+    ADA_ASSERT_TRUE(apply_result->hostname.has_value());
+    hostname = apply_result->hostname.value();
+
+    // Set port to applyResult["port"].
+    ADA_ASSERT_TRUE(apply_result->port.has_value());
+    port = apply_result->port.value();
+
+    // Set pathname to applyResult["pathname"].
+    ADA_ASSERT_TRUE(apply_result->pathname.has_value());
+    pathname = apply_result->pathname.value();
+
+    // Set search to applyResult["search"].
+    ADA_ASSERT_TRUE(apply_result->search.has_value());
+    search = apply_result->search.value();
+
+    // Set hash to applyResult["hash"].
+    ADA_ASSERT_TRUE(apply_result->hash.has_value());
+    hash = apply_result->hash.value();
+  } else {
+    // Let url be input.
+    auto url = std::get<url_aggregator>(input);
+
+    // Let baseURL be null.
+    result<url_aggregator> base_url;
+
+    // If input is a USVString:
+    // TODO: Implement this.
+    if (true) {
+      // If baseURLString was given, then:
+      if (base_url_string) {
+        // Let baseURL be the result of parsing baseURLString.
+        base_url = ada::parse<url_aggregator>(*base_url_string, nullptr);
+
+        // If baseURL is failure, return null.
+        if (!base_url) {
+          return std::nullopt;
+        }
+
+        // Append baseURLString to inputs.
+        inputs.emplace_back(*base_url);
+      }
+
+      url_aggregator* base_url_value =
+          base_url.has_value() ? &*base_url : nullptr;
+
+      // Set url to the result of parsing input given baseURL.
+      auto parsed_url =
+          ada::parse<url_aggregator>(url.get_href(), base_url_value);
+
+      // If url is failure, return null.
+      if (!parsed_url) {
+        return std::nullopt;
+      }
+
+      url = parsed_url.value();
+    }
+
+    // Set protocol to url’s scheme.
+    protocol = url.get_protocol();
+    // Set username to url’s username.
+    username = url.get_username();
+    // Set password to url’s password.
+    password = url.get_password();
+    // Set hostname to url’s host, serialized, or the empty string if the value
+    // is null.
+    hostname = url.get_hostname();
+    // Set port to url’s port, serialized, or the empty string if the value is
+    // null.
+    port = url.get_port();
+    // Set pathname to the result of URL path serializing url.
+    pathname = url.get_pathname();
+    // Set search to url’s query or the empty string if the value is null.
+    search = url.get_search();
+    // Set hash to url’s fragment or the empty string if the value is null.
+    hash = url.get_hash();
   }
 
-  // TODO: Implement this
-  return {};
+  // TODO: Make this function pluggable using a parameter.
+  // Let protocolExecResult be RegExpBuiltinExec(urlPattern’s protocol
+  // component's regular expression, protocol). auto protocol_exec_result =
+  // RegExpBuiltinExec(url_pattern.protocol.get_regexp(), protocol);
+
+  // Let usernameExecResult be RegExpBuiltinExec(urlPattern’s username
+  // component's regular expression, username). auto username_exec_result =
+  // RegExpBuiltinExec(url_pattern.username.get_regexp(), username);
+
+  // Let passwordExecResult be RegExpBuiltinExec(urlPattern’s password
+  // component's regular expression, password). auto password_exec_result =
+  // RegExpBuiltinExec(url_pattern.password.get_regexp(), password);
+
+  // Let hostnameExecResult be RegExpBuiltinExec(urlPattern’s hostname
+  // component's regular expression, hostname). auto hostname_exec_result =
+  // RegExpBuiltinExec(url_pattern.hostname.get_regexp(), hostname);
+
+  // Let portExecResult be RegExpBuiltinExec(urlPattern’s port component's
+  // regular expression, port). auto port_exec_result =
+  // RegExpBuiltinExec(url_pattern.port.get_regexp(), port);
+
+  // Let pathnameExecResult be RegExpBuiltinExec(urlPattern’s pathname
+  // component's regular expression, pathname). auto pathname_exec_result =
+  // RegExpBuiltinExec(url_pattern.pathname.get_regexp(), pathname);
+
+  // Let searchExecResult be RegExpBuiltinExec(urlPattern’s search component's
+  // regular expression, search). auto search_exec_result =
+  // RegExpBuiltinExec(url_pattern.search.get_regexp(), search);
+
+  // Let hashExecResult be RegExpBuiltinExec(urlPattern’s hash component's
+  // regular expression, hash). auto hash_exec_result =
+  // RegExpBuiltinExec(url_pattern.hash.get_regexp(), hash);
+
+  // If protocolExecResult, usernameExecResult, passwordExecResult,
+  // hostnameExecResult, portExecResult, pathnameExecResult, searchExecResult,
+  // or hashExecResult are null then return null. if
+  // (!protocol_exec_result.has_value() || !username_exec_result.has_value() ||
+  // !password_exec_result.has_value() || !hostname_exec_result.has_value() ||
+  // !port_exec_result.has_value() || !pathname_exec_result.has_value() ||
+  // !search_exec_result.has_value() || !hash_exec_result.has_value()) {
+  //   return tl::unexpected(url_pattern_errors::null);
+  // }
+
+  // Let result be a new URLPatternResult.
+  auto result = url_pattern_result{};
+  // Set result["inputs"] to inputs.
+  // result.inputs = std::move(inputs);
+  // Set result["protocol"] to the result of creating a component match result
+  // given urlPattern’s protocol component, protocol, and protocolExecResult.
+  // result.protocol =
+  // protocol_component.create_component_match_result(protocol,
+  // protocol_exec_result.value());
+
+  // Set result["username"] to the result of creating a component match result
+  // given urlPattern’s username component, username, and usernameExecResult.
+  // result.username =
+  // username_component.create_component_match_result(username,
+  // username_exec_result.value());
+
+  // Set result["password"] to the result of creating a component match result
+  // given urlPattern’s password component, password, and passwordExecResult.
+  // result.password =
+  // password_component.create_component_match_result(password,
+  // password_exec_result.value());
+
+  // Set result["hostname"] to the result of creating a component match result
+  // given urlPattern’s hostname component, hostname, and hostnameExecResult.
+  // result.hostname =
+  // hostname_component.create_component_match_result(hostname,
+  // hostname_exec_result.value());
+
+  // Set result["port"] to the result of creating a component match result given
+  // urlPattern’s port component, port, and portExecResult. result.port =
+  // port_component.create_component_match_result(port,
+  // port_exec_result.value());
+
+  // Set result["pathname"] to the result of creating a component match result
+  // given urlPattern’s pathname component, pathname, and pathnameExecResult.
+  // result.pathname =
+  // pathname_component.create_component_match_result(pathname,
+  // pathname_exec_result.value());
+
+  // Set result["search"] to the result of creating a component match result
+  // given urlPattern’s search component, search, and searchExecResult.
+  // result.search = search_component.create_component_match_result(search,
+  // search_exec_result.value());
+
+  // Set result["hash"] to the result of creating a component match result given
+  // urlPattern’s hash component, hash, and hashExecResult. result.hash =
+  // hash_component.create_component_match_result(hash,
+  // hash_exec_result.value());
+
+  return result;
 }
 
 }  // namespace ada