Implement URLPattern::{text, exec} (#37044)

With this change the URLPattern API is fully implemented. I'll look into
the remaining failures and then enable the preference by default.

Testing: Covered by web platform tests

Depends on https://github.com/servo/servo/pull/37042

---------

Signed-off-by: Simon Wülker <simon.wuelker@arcor.de>

components/script/dom/urlpattern.rs

@@ -4,6 +4,7 @@
 
 use dom_struct::dom_struct;
 use js::rust::HandleObject;
+use script_bindings::codegen::GenericBindings::URLPatternBinding::URLPatternResult;
 use script_bindings::codegen::GenericUnionTypes::USVStringOrURLPatternInit;
 use script_bindings::error::{Error, Fallible};
 use script_bindings::reflector::Reflector;
@@ -46,7 +47,7 @@ impl URLPattern {
     ) -> Fallible<DomRoot<URLPattern>> {
         // The section below converts from servos types to the types used in the urlpattern crate
         let base_url = base_url.map(|usv_string| usv_string.0);
-        let input = bindings_to_third_party::map_urlpattern_input(input, base_url.clone());
+        let input = bindings_to_third_party::map_urlpattern_input(input);
         let options = urlpattern::UrlPatternOptions {
             ignore_case: options.ignoreCase,
         };
@@ -94,6 +95,50 @@ impl URLPatternMethods<crate::DomTypeHolder> for URLPattern {
         URLPattern::initialize(global, proto, input, None, options, can_gc)
     }
 
+    /// <https://urlpattern.spec.whatwg.org/#dom-urlpattern-test>
+    fn Test(
+        &self,
+        input: USVStringOrURLPatternInit,
+        base_url: Option<USVString>,
+    ) -> Fallible<bool> {
+        let input = bindings_to_third_party::map_urlpattern_input(input);
+        let inputs = urlpattern::quirks::process_match_input(input, base_url.as_deref())
+            .map_err(|error| Error::Type(format!("{error}")))?;
+        let Some((match_input, _)) = inputs else {
+            return Ok(false);
+        };
+
+        self.associated_url_pattern
+            .test(match_input)
+            .map_err(|error| Error::Type(format!("{error}")))
+    }
+
+    /// <https://urlpattern.spec.whatwg.org/#dom-urlpattern-exec>
+    fn Exec(
+        &self,
+        input: USVStringOrURLPatternInit,
+        base_url: Option<USVString>,
+    ) -> Fallible<Option<URLPatternResult>> {
+        let input = bindings_to_third_party::map_urlpattern_input(input);
+        let inputs = urlpattern::quirks::process_match_input(input, base_url.as_deref())
+            .map_err(|error| Error::Type(format!("{error}")))?;
+        let Some((match_input, inputs)) = inputs else {
+            return Ok(None);
+        };
+
+        let result = self
+            .associated_url_pattern
+            .exec(match_input)
+            .map_err(|error| Error::Type(format!("{error}")))?;
+        let Some(result) = result else {
+            return Ok(None);
+        };
+
+        Ok(Some(third_party_to_bindings::map_urlpattern_result(
+            result, inputs,
+        )))
+    }
+
     /// <https://urlpattern.spec.whatwg.org/#dom-urlpattern-protocol>
     fn Protocol(&self) -> USVString {
         // Step 1. Return this’s associated URL pattern’s protocol component’s pattern string.
@@ -151,54 +196,115 @@ impl URLPatternMethods<crate::DomTypeHolder> for URLPattern {
 }
 
 mod bindings_to_third_party {
+    use script_bindings::codegen::GenericBindings::URLPatternBinding::URLPatternInit;
+
     use crate::dom::urlpattern::USVStringOrURLPatternInit;
 
+    fn map_urlpatterninit(pattern_init: URLPatternInit) -> urlpattern::quirks::UrlPatternInit {
+        urlpattern::quirks::UrlPatternInit {
+            protocol: pattern_init.protocol.map(|protocol| protocol.0),
+            username: pattern_init.username.map(|username| username.0),
+            password: pattern_init.password.map(|password| password.0),
+            hostname: pattern_init.hostname.map(|hostname| hostname.0),
+            port: pattern_init.port.map(|hash| hash.0),
+            pathname: pattern_init
+                .pathname
+                .as_ref()
+                .map(|usv_string| usv_string.to_string()),
+            search: pattern_init.search.map(|search| search.0),
+            hash: pattern_init.hash.map(|hash| hash.0),
+            base_url: pattern_init.baseURL.map(|base_url| base_url.0),
+        }
+    }
+
     pub(super) fn map_urlpattern_input(
         input: USVStringOrURLPatternInit,
-        base_url: Option<String>,
     ) -> urlpattern::quirks::StringOrInit {
         match input {
             USVStringOrURLPatternInit::USVString(usv_string) => {
                 urlpattern::quirks::StringOrInit::String(usv_string.0)
             },
             USVStringOrURLPatternInit::URLPatternInit(pattern_init) => {
-                let pattern_init = urlpattern::quirks::UrlPatternInit {
+                urlpattern::quirks::StringOrInit::Init(map_urlpatterninit(pattern_init))
-                    protocol: pattern_init
-                        .protocol
-                        .as_ref()
-                        .map(|usv_string| usv_string.to_string()),
-                    username: pattern_init
-                        .username
-                        .as_ref()
-                        .map(|usv_string| usv_string.to_string()),
-                    password: pattern_init
-                        .password
-                        .as_ref()
-                        .map(|usv_string| usv_string.to_string()),
-                    hostname: pattern_init
-                        .hostname
-                        .as_ref()
-                        .map(|usv_string| usv_string.to_string()),
-                    port: pattern_init
-                        .port
-                        .as_ref()
-                        .map(|usv_string| usv_string.to_string()),
-                    pathname: pattern_init
-                        .pathname
-                        .as_ref()
-                        .map(|usv_string| usv_string.to_string()),
-                    search: pattern_init
-                        .search
-                        .as_ref()
-                        .map(|usv_string| usv_string.to_string()),
-                    hash: pattern_init
-                        .hash
-                        .as_ref()
-                        .map(|usv_string| usv_string.to_string()),
-                    base_url,
-                };
-                urlpattern::quirks::StringOrInit::Init(pattern_init)
             },
         }
     }
 }
+
+mod third_party_to_bindings {
+    use script_bindings::codegen::GenericBindings::URLPatternBinding::{
+        URLPatternComponentResult, URLPatternInit, URLPatternResult,
+    };
+    use script_bindings::codegen::GenericUnionTypes::USVStringOrUndefined;
+    use script_bindings::record::Record;
+    use script_bindings::str::USVString;
+
+    use crate::dom::bindings::codegen::UnionTypes::USVStringOrURLPatternInit;
+
+    // FIXME: For some reason codegen puts a lot of options into these types that don't make sense
+
+    fn map_component_result(
+        component_result: urlpattern::UrlPatternComponentResult,
+    ) -> URLPatternComponentResult {
+        let mut groups = Record::new();
+        for (key, value) in component_result.groups.iter() {
+            let value = match value {
+                Some(value) => USVStringOrUndefined::USVString(USVString(value.to_owned())),
+                None => USVStringOrUndefined::Undefined(()),
+            };
+
+            groups.insert(USVString(key.to_owned()), value);
+        }
+
+        URLPatternComponentResult {
+            input: Some(component_result.input.into()),
+            groups: Some(groups),
+        }
+    }
+
+    fn map_urlpatterninit(pattern_init: urlpattern::quirks::UrlPatternInit) -> URLPatternInit {
+        URLPatternInit {
+            baseURL: pattern_init.base_url.map(USVString),
+            protocol: pattern_init.protocol.map(USVString),
+            username: pattern_init.username.map(USVString),
+            password: pattern_init.password.map(USVString),
+            hostname: pattern_init.hostname.map(USVString),
+            port: pattern_init.port.map(USVString),
+            pathname: pattern_init.pathname.map(USVString),
+            search: pattern_init.search.map(USVString),
+            hash: pattern_init.hash.map(USVString),
+        }
+    }
+
+    pub(super) fn map_urlpattern_result(
+        result: urlpattern::UrlPatternResult,
+        (string_or_init, base_url): urlpattern::quirks::Inputs,
+    ) -> URLPatternResult {
+        let string_or_init = match string_or_init {
+            urlpattern::quirks::StringOrInit::String(string) => {
+                USVStringOrURLPatternInit::USVString(USVString(string))
+            },
+            urlpattern::quirks::StringOrInit::Init(pattern_init) => {
+                USVStringOrURLPatternInit::URLPatternInit(map_urlpatterninit(pattern_init))
+            },
+        };
+
+        let mut inputs = vec![string_or_init];
+
+        if let Some(base_url) = base_url {
+            inputs.push(USVStringOrURLPatternInit::USVString(USVString(base_url)));
+        }
+
+        URLPatternResult {
+            inputs: Some(inputs),
+            protocol: Some(map_component_result(result.protocol)),
+            username: Some(map_component_result(result.username)),
+            password: Some(map_component_result(result.password)),
+            hostname: Some(map_component_result(result.hostname)),
+            port: Some(map_component_result(result.port)),
+            pathname: Some(map_component_result(result.pathname)),
+            search: Some(map_component_result(result.search)),
+            hash: Some(map_component_result(result.hash)),
+        }
+    }
+}

components/script_bindings/record.rs

@@ -7,7 +7,7 @@
 use std::cmp::Eq;
 use std::hash::Hash;
 use std::marker::Sized;
-use std::ops::Deref;
+use std::ops::{Deref, DerefMut};
 
 use indexmap::IndexMap;
 use js::conversions::{ConversionResult, FromJSValConvertible, ToJSValConvertible};
@@ -94,11 +94,17 @@ impl<K: RecordKey, V> Record<K, V> {
 impl<K: RecordKey, V> Deref for Record<K, V> {
     type Target = IndexMap<K, V>;
 
-    fn deref(&self) -> &IndexMap<K, V> {
+    fn deref(&self) -> &Self::Target {
         &self.map
     }
 }
 
+impl<K: RecordKey, V> DerefMut for Record<K, V> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.map
+    }
+}
+
 impl<K, V, C> FromJSValConvertible for Record<K, V>
 where
     K: RecordKey,

components/script_bindings/webidls/URLPattern.webidl

@@ -11,9 +11,9 @@ interface URLPattern {
   [Throws] constructor(URLPatternInput input, USVString baseURL, optional URLPatternOptions options = {});
   [Throws] constructor(optional URLPatternInput input = {}, optional URLPatternOptions options = {});
 
-  // [Throws] boolean test(optional URLPatternInput input = {}, optional USVString baseURL);
+  [Throws] boolean test(optional URLPatternInput input = {}, optional USVString baseURL);
 
-  // [Throws] URLPatternResult? exec(optional URLPatternInput input = {}, optional USVString baseURL);
+  [Throws] URLPatternResult? exec(optional URLPatternInput input = {}, optional USVString baseURL);
 
   readonly attribute USVString protocol;
   readonly attribute USVString username;
@@ -43,20 +43,20 @@ dictionary URLPatternOptions {
   boolean ignoreCase = false;
 };
 
-// dictionary URLPatternResult {
+dictionary URLPatternResult {
-//   sequence<URLPatternInput> inputs;
+  sequence<URLPatternInput> inputs;
 
-//   URLPatternComponentResult protocol;
+  URLPatternComponentResult protocol;
-//   URLPatternComponentResult username;
+  URLPatternComponentResult username;
-//   URLPatternComponentResult password;
+  URLPatternComponentResult password;
-//   URLPatternComponentResult hostname;
+  URLPatternComponentResult hostname;
-//   URLPatternComponentResult port;
+  URLPatternComponentResult port;
-//   URLPatternComponentResult pathname;
+  URLPatternComponentResult pathname;
-//   URLPatternComponentResult search;
+  URLPatternComponentResult search;
-//   URLPatternComponentResult hash;
+  URLPatternComponentResult hash;
-// };
+};
 
-// dictionary URLPatternComponentResult {
+dictionary URLPatternComponentResult {
-//   USVString input;
+  USVString input;
-//   record<USVString, (USVString or undefined)> groups;
+  record<USVString, (USVString or undefined)> groups;
-// };
+};