update html5ever version, narrow version requirements

hansihe · hansihe · commit 2095b900b06e · 2017-05-14T16:56:03.000+02:00
diff --git a/native/html5ever_nif/Cargo.toml b/native/html5ever_nif/Cargo.toml
@@ -12,7 +12,7 @@ crate-type = ["dylib"]
 rustler = "^0.14"
 rustler_codegen = "^0.14"
 
-html5ever = "*"
-tendril = "*"
-lazy_static = "*"
-scoped-pool = "*"
+html5ever = "0.16"
+tendril = "0.2"
+lazy_static = "0.2"
+scoped-pool = "1"
diff --git a/native/html5ever_nif/src/lib.rs b/native/html5ever_nif/src/lib.rs
@@ -10,24 +10,19 @@ extern crate scoped_pool;
 
 use std::panic;
 
-use rustler::{
-    NifEnv,
-    NifTerm,
-    NifResult,
-    NifError,
-    NifEncoder,
-    NifDecoder,
-};
+use rustler::{NifEnv, NifTerm, NifResult, NifError, NifEncoder, NifDecoder};
 use rustler::types::binary::NifBinary;
 use rustler::env::OwnedEnv;
 
-use html5ever::{ QualName };
-use html5ever::rcdom::{ RcDom, Handle, NodeEnum };
+use html5ever::rcdom::RcDom;
 use html5ever::driver::ParseOpts;
 use html5ever::tokenizer::TokenizerOpts;
 use html5ever::tree_builder::TreeBuilderOpts;
-use html5ever::tree_builder::interface::QuirksMode;
-use tendril::{ TendrilSink, StrTendril };
+use html5ever::tree_builder::QuirksMode;
+use tendril::TendrilSink;
+
+mod rc_dom;
+use rc_dom::handle_to_term;
 
 mod atoms {
     rustler_atoms! {
@@ -41,11 +36,11 @@ mod atoms {
         atom doctype;
         atom comment;
 
-        atom error_level;
         atom discard_bom;
         atom scripting_enabled;
         atom iframe_srcdoc;
         atom drop_doctype;
+        atom error_level;
 
         atom none;
         atom some;
@@ -61,10 +56,15 @@ enum ErrorLevel {
 }
 impl<'a> NifDecoder<'a> for ErrorLevel {
     fn decode(term: NifTerm<'a>) -> NifResult<ErrorLevel> {
-        if atoms::none() == term { Ok(ErrorLevel::None) }
-        else if atoms::some() == term { Ok(ErrorLevel::Some) }
-        else if atoms::all() == term { Ok(ErrorLevel::All) }
-        else { Err(NifError::BadArg) }
+        if atoms::none() == term {
+            Ok(ErrorLevel::None)
+        } else if atoms::some() == term {
+            Ok(ErrorLevel::Some)
+        } else if atoms::all() == term {
+            Ok(ErrorLevel::All)
+        } else {
+            Err(NifError::BadArg)
+        }
     }
 }
 
@@ -74,17 +74,13 @@ fn term_to_configs(term: NifTerm) -> NifResult<ParseOpts> {
     } else {
         let env = term.get_env();
 
-        let errors: ErrorLevel =
-            term.map_get(atoms::error_level().to_term(env))?.decode()?;
+        let errors: ErrorLevel = term.map_get(atoms::error_level().to_term(env))?.decode()?;
 
-        let discard_bom: bool =
-            term.map_get(atoms::discard_bom().to_term(env))?.decode()?;
-        let scripting_enabled: bool =
-            term.map_get(atoms::scripting_enabled().to_term(env))?.decode()?;
-        let iframe_srcdoc: bool =
-            term.map_get(atoms::iframe_srcdoc().to_term(env))?.decode()?;
-        let drop_doctype: bool =
-            term.map_get(atoms::drop_doctype().to_term(env))?.decode()?;
+        let discard_bom: bool = term.map_get(atoms::discard_bom().to_term(env))?.decode()?;
+        let scripting_enabled: bool = term.map_get(atoms::scripting_enabled().to_term(env))?
+            .decode()?;
+        let iframe_srcdoc: bool = term.map_get(atoms::iframe_srcdoc().to_term(env))?.decode()?;
+        let drop_doctype: bool = term.map_get(atoms::drop_doctype().to_term(env))?.decode()?;
 
         Ok(ParseOpts {
             tokenizer: TokenizerOpts {
@@ -106,69 +102,6 @@ fn term_to_configs(term: NifTerm) -> NifResult<ParseOpts> {
     }
 }
 
-// Zero-cost wrapper types which makes it possible to implement
-// NifEncoder for these externally defined types.
-// Unsure if this is a great way of doing it, but it's the way
-// that produced the cleanest and least noisy code.
-struct QNW<'a>(&'a QualName);
-struct STW<'a>(&'a StrTendril);
-
-impl<'b> NifEncoder for QNW<'b> {
-    fn encode<'a>(&self, env: NifEnv<'a>) -> NifTerm<'a> {
-        let data: &str = &*self.0.local;
-        data.encode(env)
-    }
-}
-impl<'b> NifEncoder for STW<'b> {
-    fn encode<'a>(&self, env: NifEnv<'a>) -> NifTerm<'a> {
-        let data: &str = &*self.0;
-        data.encode(env)
-    }
-}
-
-/// Takes a Handle from a RcDom, encodes it into a NifTerm.
-/// This follows the mochiweb encoding scheme with two exceptions:
-/// * A `{:doctype, name, pubid, sysid}` node.
-/// * Always returns a list as it's root node.
-fn handle_to_term<'a>(env: NifEnv<'a>, handle: &Handle) -> NifTerm<'a> {
-    let node = handle.borrow();
-
-    // Closure so that we don't encode this when we don't need to return
-    // it to the user.
-    let children = || {
-        // Encodes a Vec<Handle> to a Vec<NifTerm>
-        let res: Vec<NifTerm<'a>> =
-            node.children.iter().map(|h| handle_to_term(env, h)).collect();
-        // Encodes to erlang list term.
-        res.encode(env)
-    };
-
-    match node.node {
-        // Root document node. As far as I know, this is only located in the
-        // root of the DOM.
-        NodeEnum::Document =>
-            children(),
-
-        NodeEnum::Doctype(ref name, ref pubid, ref sysid) =>
-            (atoms::doctype(), STW(name), STW(pubid), STW(sysid)).encode(env),
-
-        NodeEnum::Text(ref text) =>
-            STW(text).encode(env),
-
-        NodeEnum::Comment(ref text) =>
-            (atoms::comment(), STW(text)).encode(env),
-
-        NodeEnum::Element(ref name, ref _elem_type, ref attributes) => {
-            let attribute_terms: Vec<NifTerm<'a>> =
-                attributes.iter()
-                .map(|a| (QNW(&a.name), STW(&a.value)).encode(env))
-                .collect();
-
-            (QNW(name), attribute_terms, children()).encode(env)
-        },
-    }
-}
-
 // Thread pool for `parse_async`.
 // TODO: How do we decide on pool size?
 lazy_static! {
@@ -185,7 +118,7 @@ fn parse_async<'a>(env: NifEnv<'a>, args: &[NifTerm<'a>]) -> NifResult<NifTerm<'
 
     let return_pid = env.pid();
 
-    //let config = term_to_configs(args[1]);
+    // let config = term_to_configs(args[1]);
 
     POOL.spawn(move || {
         owned_env.send_and_clear(&return_pid, |inner_env| {
@@ -201,28 +134,24 @@ fn parse_async<'a>(env: NifEnv<'a>, args: &[NifTerm<'a>]) -> NifResult<NifTerm<'
 
                 // TODO: Use Parser.from_bytes instead?
                 let parser = html5ever::parse_document(sink, Default::default());
-                let result = parser.one(
-                    std::str::from_utf8(binary.as_slice()).unwrap());
+                let result = parser.one(std::str::from_utf8(binary.as_slice()).unwrap());
 
                 let result_term = handle_to_term(inner_env, &result.document);
-                (atoms::html5ever_nif_result(), atoms::ok(), result_term)
-                    .encode(inner_env)
+                (atoms::html5ever_nif_result(), atoms::ok(), result_term.unwrap()).encode(inner_env)
             }) {
                 Ok(term) => term,
                 Err(err) => {
                     // Try to extract a panic reason and return that. If this
                     // fails, fail generically.
-                    let reason =
-                        if let Some(s) = err.downcast_ref::<String>() {
-                            s.encode(inner_env)
-                        } else if let Some(&s) = err.downcast_ref::<&'static str>() {
-                            s.encode(inner_env)
-                        } else {
-                            atoms::nif_panic().encode(inner_env)
-                        };
-                    (atoms::html5ever_nif_result(), atoms::error(), reason)
-                        .encode(inner_env)
-                },
+                    let reason = if let Some(s) = err.downcast_ref::<String>() {
+                        s.encode(inner_env)
+                    } else if let Some(&s) = err.downcast_ref::<&'static str>() {
+                        s.encode(inner_env)
+                    } else {
+                        atoms::nif_panic().encode(inner_env)
+                    };
+                    (atoms::html5ever_nif_result(), atoms::error(), reason).encode(inner_env)
+                }
             }
         });
     });
@@ -236,24 +165,19 @@ fn parse_sync<'a>(env: NifEnv<'a>, args: &[NifTerm<'a>]) -> NifResult<NifTerm<'a
 
     // TODO: Use Parser.from_bytes instead?
     let parser = html5ever::parse_document(sink, Default::default());
-    let result = parser.one(
-        std::str::from_utf8(binary.as_slice()).unwrap());
+    let result = parser.one(std::str::from_utf8(binary.as_slice()).unwrap());
 
-    //std::thread::sleep(std::time::Duration::from_millis(10));
+    // std::thread::sleep(std::time::Duration::from_millis(10));
 
     let result_term = handle_to_term(env, &result.document);
 
-    Ok((atoms::html5ever_nif_result(), atoms::ok(), result_term)
-        .encode(env))
+    Ok((atoms::html5ever_nif_result(), atoms::ok(), result_term.unwrap()).encode(env))
 
 }
 
-rustler_export_nifs!(
-    "Elixir.Html5ever.Native",
-    [("parse_async", 1, parse_async),
-     ("parse_sync", 1, parse_sync)],
-    Some(on_load)
-);
+rustler_export_nifs!("Elixir.Html5ever.Native",
+                     [("parse_async", 1, parse_async), ("parse_sync", 1, parse_sync)],
+                     Some(on_load));
 
 
 fn on_load<'a>(_env: NifEnv<'a>, _load_info: NifTerm<'a>) -> bool {
diff --git a/native/html5ever_nif/src/rc_dom.rs b/native/html5ever_nif/src/rc_dom.rs
@@ -0,0 +1,65 @@
+use ::rustler::{NifEnv, NifTerm, NifEncoder};
+use ::html5ever::rcdom::{Handle, NodeData};
+use ::html5ever::QualName;
+use ::tendril::StrTendril;
+
+// Zero-cost wrapper types which makes it possible to implement
+// NifEncoder for these externally defined types.
+// Unsure if this is a great way of doing it, but it's the way
+// that produced the cleanest and least noisy code.
+struct QNW<'a>(&'a QualName);
+struct STW<'a>(&'a StrTendril);
+
+impl<'b> NifEncoder for QNW<'b> {
+    fn encode<'a>(&self, env: NifEnv<'a>) -> NifTerm<'a> {
+        let data: &str = &*self.0.local;
+        data.encode(env)
+    }
+}
+impl<'b> NifEncoder for STW<'b> {
+    fn encode<'a>(&self, env: NifEnv<'a>) -> NifTerm<'a> {
+        let data: &str = &*self.0;
+        data.encode(env)
+    }
+}
+
+/// Takes a Handle from a RcDom, encodes it into a NifTerm.
+/// This follows the mochiweb encoding scheme with two exceptions:
+/// * A `{:doctype, name, pubid, sysid}` node.
+/// * Always returns a list as it's root node.
+pub fn handle_to_term<'a>(env: NifEnv<'a>, handle: &Handle) -> Option<NifTerm<'a>> {
+    let node = handle;
+
+    // Closure so that we don't encode this when we don't need to return
+    // it to the user.
+    let children = || {
+        // Encodes a Vec<Handle> to a Vec<NifTerm>
+        let res: Vec<NifTerm<'a>> = node.children.borrow().iter().filter_map(|h| handle_to_term(env, h)).collect();
+        // Encodes to erlang list term.
+        res.encode(env)
+    };
+
+    match node.data {
+        // Root document node. As far as I know, this is only located in the
+        // root of the DOM.
+        NodeData::Document => Some(children()),
+
+        NodeData::Doctype { ref name, ref public_id, ref system_id } => {
+            Some((::atoms::doctype(), STW(name), STW(public_id), STW(system_id)).encode(env))
+        }
+
+        NodeData::Text { ref contents } => Some(STW(&*contents.borrow()).encode(env)),
+
+        NodeData::Comment { ref contents } => Some((::atoms::comment(), STW(contents)).encode(env)),
+
+        NodeData::Element { ref name, ref attrs, .. } => {
+            let attribute_terms: Vec<NifTerm<'a>> = attrs.borrow().iter()
+                .map(|a| (QNW(&a.name), STW(&a.value)).encode(env))
+                .collect();
+
+            Some((QNW(name), attribute_terms, children()).encode(env))
+        }
+
+        _ => None,
+    }
+}
