Move the URL class to using the boa_class macro (#4294)

Instead of the js_class one which was weird to use. This is much
cleaner and takes less space.

Please note we cannot move Console, since it is not a class.

Author: hansl

core/runtime/src/url.rs

@@ -10,15 +10,15 @@
 //! [spec]: https://url.spec.whatwg.org/
 //! [mdn]: https://developer.mozilla.org/en-US/docs/Web/API/URL
 #![cfg(feature = "url")]
+#![allow(clippy::needless_pass_by_value)]
 
 #[cfg(test)]
 mod tests;
 
+use boa_engine::class::Class;
 use boa_engine::value::Convert;
-use boa_engine::{
-    js_error, js_string, Context, Finalize, JsData, JsResult, JsString, JsValue, Trace,
-};
-use boa_interop::{js_class, IntoJsFunctionCopied, JsClass};
+use boa_engine::{js_error, Context, Finalize, JsData, JsResult, JsString, JsValue, Trace};
+use boa_interop::boa_macros::boa_class;
 use std::fmt::Display;
 
 /// The `URL` class represents a (properly parsed) Uniform Resource Locator.
@@ -35,13 +35,36 @@ impl Url {
         context.register_global_class::<Self>()?;
         Ok(())
     }
+}
+
+impl Display for Url {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+impl From<url::Url> for Url {
+    fn from(url: url::Url) -> Self {
+        Self(url)
+    }
+}
+
+impl From<Url> for url::Url {
+    fn from(url: Url) -> url::Url {
+        url.0
+    }
+}
 
+#[boa_class(rename = "URL")]
+#[boa(rename_all = "camelCase")]
+impl Url {
     /// Create a new `URL` object. Meant to be called from the JavaScript constructor.
     ///
     /// # Errors
     /// Any errors that might occur during URL parsing.
-    fn js_new(Convert(ref url): Convert<String>, base: Option<&Convert<String>>) -> JsResult<Self> {
-        if let Some(Convert(base)) = base {
+    #[boa(constructor)]
+    pub fn new(Convert(ref url): Convert<String>, base: Option<Convert<String>>) -> JsResult<Self> {
+        if let Some(Convert(ref base)) = base {
             let base_url = url::Url::parse(base)
                 .map_err(|e| js_error!(TypeError: "Failed to parse base URL: {}", e))?;
             if base_url.cannot_be_a_base() {
@@ -58,179 +81,159 @@ impl Url {
             Ok(Self(url))
         }
     }
-}
 
-impl Display for Url {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.0)
+    #[boa(getter)]
+    fn hash(&self) -> JsString {
+        JsString::from(url::quirks::hash(&self.0))
     }
-}
 
-impl From<url::Url> for Url {
-    fn from(url: url::Url) -> Self {
-        Self(url)
+    #[boa(setter)]
+    #[boa(rename = "hash")]
+    fn set_hash(&mut self, value: Convert<String>) {
+        url::quirks::set_hash(&mut self.0, &value.0);
     }
-}
 
-impl From<Url> for url::Url {
-    fn from(url: Url) -> url::Url {
-        url.0
+    #[boa(getter)]
+    fn hostname(&self) -> JsString {
+        JsString::from(url::quirks::hostname(&self.0))
     }
-}
 
-js_class! {
-    class Url as "URL" {
-        property hash {
-            fn get(this: JsClass<Url>) -> JsString {
-                JsString::from(url::quirks::hash(&this.borrow().0))
-            }
-
-            fn set(this: JsClass<Url>, value: Convert<String>) {
-                url::quirks::set_hash(&mut this.borrow_mut().0, &value.0);
-            }
-        }
+    #[boa(setter)]
+    #[boa(rename = "hostname")]
+    fn set_hostname(&mut self, value: Convert<String>) {
+        let _ = url::quirks::set_hostname(&mut self.0, &value.0);
+    }
 
-        property hostname {
-            fn get(this: JsClass<Url>) -> JsString {
-                JsString::from(url::quirks::hostname(&this.borrow().0))
-            }
+    #[boa(getter)]
+    fn host(&self) -> JsString {
+        JsString::from(url::quirks::host(&self.0))
+    }
 
-            fn set(this: JsClass<Url>, value: Convert<String>) {
-                let _ = url::quirks::set_hostname(&mut this.borrow_mut().0, &value.0);
-            }
-        }
+    #[boa(setter)]
+    #[boa(rename = "host")]
+    fn set_host(&mut self, value: Convert<String>) {
+        let _ = url::quirks::set_host(&mut self.0, &value.0);
+    }
 
-        property host {
-            fn get(this: JsClass<Url>) -> JsString {
-                JsString::from(url::quirks::host(&this.borrow().0))
-            }
+    #[boa(getter)]
+    fn href(&self) -> JsString {
+        JsString::from(url::quirks::href(&self.0))
+    }
 
-            fn set(this: JsClass<Url>, value: Convert<String>) {
-                let _ = url::quirks::set_host(&mut this.borrow_mut().0, &value.0);
-            }
-        }
+    #[boa(setter)]
+    #[boa(rename = "href")]
+    fn set_href(&mut self, value: Convert<String>) -> JsResult<()> {
+        url::quirks::set_href(&mut self.0, &value.0)
+            .map_err(|e| js_error!(TypeError: "Failed to set href: {}", e))
+    }
 
-        property href {
-            fn get(this: JsClass<Url>) -> JsString {
-                JsString::from(url::quirks::href(&this.borrow().0))
-            }
+    #[boa(getter)]
+    fn origin(&self) -> JsString {
+        JsString::from(url::quirks::origin(&self.0))
+    }
 
-            fn set(this: JsClass<Url>, value: Convert<String>) -> JsResult<()> {
-                url::quirks::set_href(&mut this.borrow_mut().0, &value.0)
-                    .map_err(|e| js_error!(TypeError: "Failed to set href: {}", e))
-            }
-        }
+    #[boa(getter)]
+    fn password(&self) -> JsString {
+        JsString::from(url::quirks::password(&self.0))
+    }
 
-        property origin {
-            fn get(this: JsClass<Url>) -> JsString {
-                JsString::from(url::quirks::origin(&this.borrow().0))
-            }
-        }
+    #[boa(setter)]
+    #[boa(rename = "password")]
+    fn set_password(&mut self, value: Convert<String>) {
+        let _ = url::quirks::set_password(&mut self.0, &value.0);
+    }
 
-        property password {
-            fn get(this: JsClass<Url>) -> JsString {
-                JsString::from(url::quirks::password(&this.borrow().0))
-            }
+    #[boa(getter)]
+    fn pathname(&self) -> JsString {
+        JsString::from(url::quirks::pathname(&self.0))
+    }
 
-            fn set(this: JsClass<Url>, value: Convert<String>) {
-                let _ = url::quirks::set_password(&mut this.borrow_mut().0, &value.0);
-            }
-        }
+    #[boa(setter)]
+    #[boa(rename = "pathname")]
+    fn set_pathname(&mut self, value: Convert<String>) {
+        let () = url::quirks::set_pathname(&mut self.0, &value.0);
+    }
 
-        property pathname {
-            fn get(this: JsClass<Url>) -> JsString {
-                JsString::from(url::quirks::pathname(&this.borrow().0))
-            }
+    #[boa(getter)]
+    fn port(&self) -> JsString {
+        JsString::from(url::quirks::port(&self.0))
+    }
 
-            fn set(this: JsClass<Url>, value: Convert<String>) {
-                let () = url::quirks::set_pathname(&mut this.borrow_mut().0, &value.0);
-            }
-        }
+    #[boa(setter)]
+    #[boa(rename = "port")]
+    fn set_port(&mut self, value: Convert<JsString>) {
+        let _ = url::quirks::set_port(&mut self.0, &value.0.to_std_string_lossy());
+    }
 
-        property port {
-            fn get(this: JsClass<Url>) -> JsString {
-                JsString::from(url::quirks::port(&this.borrow().0))
-            }
+    #[boa(getter)]
+    fn protocol(&self) -> JsString {
+        JsString::from(url::quirks::protocol(&self.0))
+    }
 
-            fn set(this: JsClass<Url>, value: Convert<JsString>) {
-                let _ = url::quirks::set_port(&mut this.borrow_mut().0, &value.0.to_std_string_lossy());
-            }
-        }
+    #[boa(setter)]
+    #[boa(rename = "protocol")]
+    fn set_protocol(&mut self, value: Convert<String>) {
+        let _ = url::quirks::set_protocol(&mut self.0, &value.0);
+    }
 
-        property protocol {
-            fn get(this: JsClass<Url>) -> JsString {
-                JsString::from(url::quirks::protocol(&this.borrow().0))
-            }
+    #[boa(getter)]
+    fn search(&self) -> JsString {
+        JsString::from(url::quirks::search(&self.0))
+    }
 
-            fn set(this: JsClass<Url>, value: Convert<String>) {
-                let _ = url::quirks::set_protocol(&mut this.borrow_mut().0, &value.0);
-            }
-        }
+    #[boa(setter)]
+    #[boa(rename = "search")]
+    fn set_search(&mut self, value: Convert<String>) {
+        url::quirks::set_search(&mut self.0, &value.0);
+    }
 
-        property search {
-            fn get(this: JsClass<Url>) -> JsString {
-                JsString::from(url::quirks::search(&this.borrow().0))
-            }
+    #[boa(getter)]
+    fn search_params() -> JsResult<()> {
+        Err(js_error!(Error: "URL.searchParams is not implemented"))
+    }
 
-            fn set(this: JsClass<Url>, value: Convert<String>) {
-                url::quirks::set_search(&mut this.borrow_mut().0, &value.0);
-            }
-        }
+    #[boa(getter)]
+    fn username(&self) -> JsString {
+        JsString::from(self.0.username())
+    }
 
-        property search_params as "searchParams" {
-            fn get() -> JsResult<()> {
-                Err(js_error!(Error: "URL.searchParams is not implemented"))
-            }
-        }
+    #[boa(setter)]
+    #[boa(rename = "username")]
+    fn set_username(&mut self, value: Convert<String>) {
+        let _ = self.0.set_username(&value.0);
+    }
 
-        property username {
-            fn get(this: JsClass<Url>) -> JsString {
-                JsString::from(this.borrow().0.username())
-            }
+    fn to_string(&self) -> JsString {
+        JsString::from(format!("{}", self.0))
+    }
 
-            fn set(this: JsClass<Url>, value: Convert<String>) {
-                let _ = this.borrow_mut().0.set_username(&value.0);
-            }
-        }
+    fn to_json(&self) -> JsString {
+        JsString::from(format!("{}", self.0))
+    }
 
-        constructor(url: Convert<String>, base: Option<Convert<String>>) {
-            Self::js_new(url, base.as_ref())
-        }
+    #[boa(static)]
+    fn create_object_url() -> JsResult<()> {
+        Err(js_error!(Error: "URL.createObjectURL is not implemented"))
+    }
 
-        init(class: &mut ClassBuilder) -> JsResult<()> {
-            let create_object_url = (|| -> JsResult<()> {
-                    Err(js_error!(Error: "URL.createObjectURL is not implemented"))
-                })
-                .into_js_function_copied(class.context());
-            let can_parse = (|url: Convert<String>, base: Option<Convert<String>>| {
-                    Url::js_new(url, base.as_ref()).is_ok()
-                })
-                .into_js_function_copied(class.context());
-            let parse = (|url: Convert<String>, base: Option<Convert<String>>, context: &mut Context| {
-                    Url::js_new(url, base.as_ref())
-                        .map_or(Ok(JsValue::null()), |u| Url::from_data(u, context).map(JsValue::from))
-                })
-                .into_js_function_copied(class.context());
-            let revoke_object_url = (|| -> JsResult<()> {
-                    Err(js_error!(Error: "URL.revokeObjectURL is not implemented"))
-                })
-                .into_js_function_copied(class.context());
-
-            class
-                .static_method(js_string!("createObjectURL"), 1, create_object_url)
-                .static_method(js_string!("canParse"), 2, can_parse)
-                .static_method(js_string!("parse"), 2, parse)
-                .static_method(js_string!("revokeObjectUrl"), 1, revoke_object_url);
-
-            Ok(())
-        }
+    #[boa(static)]
+    fn can_parse(url: Convert<String>, base: Option<Convert<String>>) -> bool {
+        Url::new(url, base).is_ok()
+    }
 
-        fn to_string as "toString"(this: JsClass<Url>) -> JsString {
-            JsString::from(format!("{}", this.borrow().0))
-        }
+    #[boa(static)]
+    fn parse(
+        url: Convert<String>,
+        base: Option<Convert<String>>,
+        context: &mut Context,
+    ) -> JsResult<JsValue> {
+        Url::new(url, base).map_or(Ok(JsValue::null()), |u| {
+            Url::from_data(u, context).map(JsValue::from)
+        })
+    }
 
-        fn to_json as "toJSON"(this: JsClass<Url>) -> JsString {
-            JsString::from(format!("{}", this.borrow().0))
-        }
+    #[boa(static)]
+    fn revoke_object_url() -> JsResult<()> {
+        Err(js_error!(Error: "URL.revokeObjectURL is not implemented"))
     }
 }