Remove idna dependency on wasm32, and fix test

Author: micolous

url/Cargo.toml

@@ -26,10 +26,15 @@ wasm-bindgen-test = "0.3"
 
 [dependencies]
 form_urlencoded = { version = "1.2.1", path = "../form_urlencoded" }
-idna = { version = "0.5.0", path = "../idna" }
 percent-encoding = { version = "2.3.1", path = "../percent_encoding" }
 serde = { version = "1.0", optional = true, features = ["derive"] }
 
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+idna = { version = "0.5.0", path = "../idna" }
+
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+web-sys = { version = "0.3.65", features = ["Url"] }
+
 [features]
 default = []
 # Enable to use the #[debugger_visualizer] attribute. This feature requires Rust >= 1.71.

url/src/host.rs

@@ -89,29 +89,7 @@ impl Host<String> {
             return Err(ParseError::EmptyHost);
         }
 
-        let is_invalid_domain_char = |c| {
-            matches!(
-                c,
-                '\0'..='\u{001F}'
-                    | ' '
-                    | '#'
-                    | '%'
-                    | '/'
-                    | ':'
-                    | '<'
-                    | '>'
-                    | '?'
-                    | '@'
-                    | '['
-                    | '\\'
-                    | ']'
-                    | '^'
-                    | '\u{007F}'
-                    | '|'
-            )
-        };
-
-        if domain.find(is_invalid_domain_char).is_some() {
+        if domain.find(Self::is_invalid_domain_char).is_some() {
             Err(ParseError::InvalidDomainCharacter)
         } else if ends_in_a_number(&domain) {
             let address = parse_ipv4addr(&domain)?;
@@ -161,10 +139,50 @@ impl Host<String> {
         }
     }
 
+    #[cfg(not(target_arch="wasm32"))]
     /// convert domain with idna
     fn domain_to_ascii(domain: &str) -> Result<String, ParseError> {
         idna::domain_to_ascii(domain).map_err(Into::into)
     }
+
+    #[cfg(target_arch="wasm32")]
+    /// convert domain with idna
+    fn domain_to_ascii(domain: &str) -> Result<String, ParseError> {
+        // Url throws an error on empty hostnames
+        if domain.is_empty() {
+            return Err(ParseError::EmptyHost);
+        }
+        // Url returns strange results for invalid domain chars
+        if domain.contains(Self::is_invalid_domain_char) {
+            return Err(ParseError::InvalidDomainCharacter);
+        }
+        let u = web_sys::Url::new(&format!("http://{domain}")).map_err(|_| {
+            ParseError::IdnaError
+        })?;
+        Ok(u.host())
+    }
+
+    fn is_invalid_domain_char(c: char) -> bool {
+        matches!(
+            c,
+            '\0'..='\u{001F}'
+                | ' '
+                | '#'
+                | '%'
+                | '/'
+                | ':'
+                | '<'
+                | '>'
+                | '?'
+                | '@'
+                | '['
+                | '\\'
+                | ']'
+                | '^'
+                | '\u{007F}'
+                | '|'
+        )
+    }
 }
 
 impl<S: AsRef<str>> fmt::Display for Host<S> {

url/src/lib.rs

@@ -1228,6 +1228,7 @@ impl Url {
         self.port.or_else(|| parser::default_port(self.scheme()))
     }
 
+    #[cfg(not(target_arch = "wasm32"))]
     /// Resolve a URL’s host and port number to `SocketAddr`.
     ///
     /// If the URL has the default port number of a scheme that is unknown to this library,
@@ -1237,6 +1238,8 @@ impl Url {
     ///
     /// If the host is a domain, it is resolved using the standard library’s DNS support.
     ///
+    /// **Note:** this feature is not available on `target_arch = "wasm32"`.
+    ///
     /// # Examples
     ///
     /// ```no_run

url/src/origin.rs

@@ -85,6 +85,8 @@ impl Origin {
         }
     }
 
+    #[cfg(not(target_arch = "wasm32"))]
+    // FIXME: "There used to also be a Unicode serialization of an origin. However, it was never widely adopted."
     /// <https://html.spec.whatwg.org/multipage/#unicode-serialisation-of-an-origin>
     pub fn unicode_serialization(&self) -> String {
         match *self {

url/src/parser.rs

@@ -87,6 +87,7 @@ simple_enum_error! {
     Overflow => "URLs more than 4 GB are not supported",
 }
 
+#[cfg(not(target_arch = "wasm32"))]
 impl From<::idna::Errors> for ParseError {
     fn from(_: ::idna::Errors) -> ParseError {
         ParseError::IdnaError

url/src/quirks.rs

@@ -65,6 +65,7 @@ pub fn domain_to_ascii(domain: &str) -> String {
     }
 }
 
+#[cfg(not(target_arch = "wasm32"))]
 /// https://url.spec.whatwg.org/#dom-url-domaintounicode
 pub fn domain_to_unicode(domain: &str) -> String {
     match Host::parse(domain) {

url/tests/unit.rs

@@ -597,6 +597,7 @@ fn test_origin_opaque() {
 }
 
 #[test]
+#[cfg(not(target_arch = "wasm32"))]
 fn test_origin_unicode_serialization() {
     let data = [
         ("http://😅.com", "http://😅.com"),
@@ -771,7 +772,9 @@ fn test_set_href() {
 
 #[test]
 fn test_domain_encoding_quirks() {
-    use url::quirks::{domain_to_ascii, domain_to_unicode};
+    use url::quirks::domain_to_ascii;
+    #[cfg(not(target_arch = "wasm32"))]
+    use url::quirks::domain_to_unicode;
 
     let data = [
         ("http://example.com", "", ""),
@@ -782,6 +785,7 @@ fn test_domain_encoding_quirks() {
 
     for url in &data {
         assert_eq!(domain_to_ascii(url.0), url.1);
+        #[cfg(not(target_arch = "wasm32"))]
         assert_eq!(domain_to_unicode(url.0), url.2);
     }
 }