Update for lol-html version 0.3.0

Author: mrbbot

src/comment.rs

@@ -9,8 +9,13 @@ impl_mutations!(Comment);
 
 #[wasm_bindgen]
 impl Comment {
-    #[wasm_bindgen(method, getter)]
+    #[wasm_bindgen(method, getter=text)]
     pub fn text(&self) -> JsResult<String> {
         self.0.get().map(|c| c.text().into())
     }
+
+    #[wasm_bindgen(method, setter=text)]
+    pub fn set_text(&mut self, text: &str) -> JsResult<()> {
+        self.0.get_mut()?.set_text(text).into_js_result()
+    }
 }

src/doctype.rs

@@ -9,17 +9,23 @@ impl_from_native!(NativeDoctype --> Doctype);
 #[wasm_bindgen]
 impl Doctype {
     #[wasm_bindgen(method, getter)]
-    pub fn name(&self) -> JsResult<Option<String>> {
-        self.0.get().map(|d| d.name())
+    pub fn name(&self) -> JsResult<JsValue> {
+        self.0
+            .get()
+            .map(|d| d.name().map(JsValue::from).unwrap_or(JsValue::null()))
     }
 
     #[wasm_bindgen(method, getter=publicId)]
-    pub fn public_id(&self) -> JsResult<Option<String>> {
-        self.0.get().map(|d| d.public_id())
+    pub fn public_id(&self) -> JsResult<JsValue> {
+        self.0
+            .get()
+            .map(|d| d.public_id().map(JsValue::from).unwrap_or(JsValue::null()))
     }
 
     #[wasm_bindgen(method, getter=systemId)]
-    pub fn system_id(&self) -> JsResult<Option<String>> {
-        self.0.get().map(|d| d.system_id())
+    pub fn system_id(&self) -> JsResult<JsValue> {
+        self.0
+            .get()
+            .map(|d| d.system_id().map(JsValue::from).unwrap_or(JsValue::null()))
     }
 }

src/element.rs

@@ -1,23 +1,7 @@
 use super::*;
-use lol_html::html_content::{Attribute as NativeAttribute, Element as NativeElement};
-use serde::Serialize;
+use lol_html::html_content::Element as NativeElement;
 use serde_wasm_bindgen::to_value as to_js_value;
 
-#[derive(Serialize)]
-pub struct Attribute {
-    pub name: String,
-    pub value: String,
-}
-
-impl From<&NativeAttribute<'_>> for Attribute {
-    fn from(native: &NativeAttribute) -> Self {
-        Attribute {
-            name: native.name(),
-            value: native.value(),
-        }
-    }
-}
-
 #[wasm_bindgen]
 pub struct Element(NativeRefWrap<NativeElement<'static, 'static>>);
 
@@ -48,15 +32,19 @@ impl Element {
             .map(|e| {
                 e.attributes()
                     .iter()
-                    .map(Attribute::from)
+                    .map(|a| vec![a.name(), a.value()])
                     .collect::<Vec<_>>()
             })
             .and_then(|a| to_js_value(&a).into_js_result())
     }
 
     #[wasm_bindgen(method, js_name=getAttribute)]
-    pub fn get_attribute(&self, name: &str) -> JsResult<Option<String>> {
-        self.0.get().map(|e| e.get_attribute(name))
+    pub fn get_attribute(&self, name: &str) -> JsResult<JsValue> {
+        self.0.get().map(|e| {
+            e.get_attribute(name)
+                .map(JsValue::from)
+                .unwrap_or(JsValue::null())
+        })
     }
 
     #[wasm_bindgen(method, js_name=hasAttribute)]

src/html_rewriter.rs

@@ -7,6 +7,7 @@ use lol_html::{
     ElementContentHandlers as NativeElementContentHandlers, HtmlRewriter as NativeHTMLRewriter,
     OutputSink, Selector, Settings,
 };
+use std::borrow::Cow;
 
 struct JsOutputSink(JsFunction);
 
@@ -27,6 +28,7 @@ impl OutputSink for JsOutputSink {
     }
 }
 
+//noinspection RsTypeCheck
 fn rewriting_error_to_js(err: RewritingError) -> JsValue {
     match err {
         RewritingError::ContentHandlerError(err) => err.downcast::<HandlerJsErrorWrap>().unwrap().0,
@@ -41,23 +43,22 @@ pub struct HTMLRewriter {
     element_content_handlers: Vec<NativeElementContentHandlers<'static>>,
     document_content_handlers: Vec<NativeDocumentContentHandlers<'static>>,
     output_sink: Option<JsOutputSink>,
-    encoding: String,
     inner: Option<NativeHTMLRewriter<'static, JsOutputSink>>,
+    inner_constructed: bool,
 }
 
 #[wasm_bindgen]
 impl HTMLRewriter {
     #[wasm_bindgen(constructor)]
-    pub fn new(encoding: String, output_sink: &JsFunction) -> Self {
+    pub fn new(output_sink: &JsFunction) -> Self {
         HTMLRewriter {
             output_sink: Some(JsOutputSink::new(output_sink)),
-            encoding,
             ..Self::default()
         }
     }
 
     fn assert_not_fully_constructed(&self) -> JsResult<()> {
-        if self.inner.is_some() {
+        if self.inner_constructed {
             Err("Handlers can't be added after write.".into())
         } else {
             Ok(())
@@ -69,28 +70,23 @@ impl HTMLRewriter {
             Some(ref mut inner) => inner,
             None => {
                 let output_sink = self.output_sink.take().unwrap();
-                // NOTE: selector are passed by reference to the rewriter ctor, though they
-                // are not stored in the rewriter, so we need their references to be valid
-                // only during the rewriter invocation.
-                let selectors: Vec<_> = self.selectors.drain(..).collect();
 
                 let settings = Settings {
                     element_content_handlers: self
-                        .element_content_handlers
+                        .selectors
                         .drain(..)
-                        .enumerate()
-                        .map(|(i, h)| (&selectors[i], h))
+                        .zip(self.element_content_handlers.drain(..))
+                        .map(|(selector, h)| (Cow::Owned(selector), h))
                         .collect(),
 
                     document_content_handlers: self.document_content_handlers.drain(..).collect(),
-                    encoding: &self.encoding,
                     ..Settings::default()
                 };
 
-                let rewriter =
-                    NativeHTMLRewriter::try_new(settings, output_sink).into_js_result()?;
+                let rewriter = NativeHTMLRewriter::new(settings, output_sink);
 
                 self.inner = Some(rewriter);
+                self.inner_constructed = true;
 
                 self.inner.as_mut().unwrap()
             }
@@ -123,6 +119,12 @@ impl HTMLRewriter {
     }
 
     pub fn end(&mut self) -> JsResult<()> {
-        self.inner_mut()?.end().map_err(rewriting_error_to_js)
+        self.inner_mut()?;
+        // Rewriter must be constructed by self.inner_mut()
+        self.inner
+            .take()
+            .unwrap()
+            .end()
+            .map_err(rewriting_error_to_js)
     }
 }