Fix tests and examples.

Author: jdm

html5ever/examples/arena.rs

@@ -24,7 +24,7 @@ fn html5ever_parse_slice_into_arena<'a>(bytes: &[u8], arena: Arena<'a>) -> Ref<'
     let sink = Sink {
         arena,
         document: arena.alloc(Node::new(NodeData::Document)),
-        quirks_mode: QuirksMode::NoQuirks,
+        quirks_mode: Cell::new(QuirksMode::NoQuirks),
     };
 
     parse_document(sink, Default::default())
@@ -41,7 +41,7 @@ type Link<'arena> = Cell<Option<Ref<'arena>>>;
 struct Sink<'arena> {
     arena: Arena<'arena>,
     document: Ref<'arena>,
-    quirks_mode: QuirksMode,
+    quirks_mode: Cell<QuirksMode>,
 }
 
 /// DOM node which contains links to other nodes in the tree.
@@ -188,14 +188,14 @@ impl<'arena> TreeSink for Sink<'arena> {
         self.document
     }
 
-    fn parse_error(&mut self, _: Cow<'static, str>) {}
+    fn parse_error(&self, _: Cow<'static, str>) {}
 
-    fn get_document(&mut self) -> Ref<'arena> {
+    fn get_document(&self) -> Ref<'arena> {
         self.document
     }
 
-    fn set_quirks_mode(&mut self, mode: QuirksMode) {
-        self.quirks_mode = mode;
+    fn set_quirks_mode(&self, mode: QuirksMode) {
+        self.quirks_mode.set(mode);
     }
 
     fn same_node(&self, x: &Ref<'arena>, y: &Ref<'arena>) -> bool {
@@ -209,7 +209,7 @@ impl<'arena> TreeSink for Sink<'arena> {
         }
     }
 
-    fn get_template_contents(&mut self, target: &Ref<'arena>) -> Ref<'arena> {
+    fn get_template_contents(&self, target: &Ref<'arena>) -> Ref<'arena> {
         if let NodeData::Element {
             template_contents: Some(contents),
             ..
@@ -234,7 +234,7 @@ impl<'arena> TreeSink for Sink<'arena> {
     }
 
     fn create_element(
-        &mut self,
+        &self,
         name: QualName,
         attrs: Vec<Attribute>,
         flags: ElementFlags,
@@ -251,26 +251,26 @@ impl<'arena> TreeSink for Sink<'arena> {
         })
     }
 
-    fn create_comment(&mut self, text: StrTendril) -> Ref<'arena> {
+    fn create_comment(&self, text: StrTendril) -> Ref<'arena> {
         self.new_node(NodeData::Comment { contents: text })
     }
 
-    fn create_pi(&mut self, target: StrTendril, data: StrTendril) -> Ref<'arena> {
+    fn create_pi(&self, target: StrTendril, data: StrTendril) -> Ref<'arena> {
         self.new_node(NodeData::ProcessingInstruction {
             target,
             contents: data,
         })
     }
 
-    fn append(&mut self, parent: &Ref<'arena>, child: NodeOrText<Ref<'arena>>) {
+    fn append(&self, parent: &Ref<'arena>, child: NodeOrText<Ref<'arena>>) {
         self.append_common(
             child,
             || parent.last_child.get(),
             |new_node| parent.append(new_node),
         )
     }
 
-    fn append_before_sibling(&mut self, sibling: &Ref<'arena>, child: NodeOrText<Ref<'arena>>) {
+    fn append_before_sibling(&self, sibling: &Ref<'arena>, child: NodeOrText<Ref<'arena>>) {
         self.append_common(
             child,
             || sibling.previous_sibling.get(),
@@ -279,7 +279,7 @@ impl<'arena> TreeSink for Sink<'arena> {
     }
 
     fn append_based_on_parent_node(
-        &mut self,
+        &self,
         element: &Ref<'arena>,
         prev_element: &Ref<'arena>,
         child: NodeOrText<Ref<'arena>>,
@@ -292,7 +292,7 @@ impl<'arena> TreeSink for Sink<'arena> {
     }
 
     fn append_doctype_to_document(
-        &mut self,
+        &self,
         name: StrTendril,
         public_id: StrTendril,
         system_id: StrTendril,
@@ -304,7 +304,7 @@ impl<'arena> TreeSink for Sink<'arena> {
         }))
     }
 
-    fn add_attrs_if_missing(&mut self, target: &Ref<'arena>, attrs: Vec<Attribute>) {
+    fn add_attrs_if_missing(&self, target: &Ref<'arena>, attrs: Vec<Attribute>) {
         let mut existing = if let NodeData::Element { ref attrs, .. } = target.data {
             attrs.borrow_mut()
         } else {
@@ -322,11 +322,11 @@ impl<'arena> TreeSink for Sink<'arena> {
         );
     }
 
-    fn remove_from_parent(&mut self, target: &Ref<'arena>) {
+    fn remove_from_parent(&self, target: &Ref<'arena>) {
         target.detach()
     }
 
-    fn reparent_children(&mut self, node: &Ref<'arena>, new_parent: &Ref<'arena>) {
+    fn reparent_children(&self, node: &Ref<'arena>, new_parent: &Ref<'arena>) {
         let mut next_child = node.first_child.get();
         while let Some(child) = next_child {
             debug_assert!(ptr::eq::<Node>(child.parent.get().unwrap(), *node));

html5ever/examples/noop-tokenize.rs

@@ -11,20 +11,21 @@
 
 extern crate html5ever;
 
+use std::cell::RefCell;
 use std::io;
 
 use html5ever::tendril::*;
 use html5ever::tokenizer::{BufferQueue, Token, TokenSink, TokenSinkResult, Tokenizer};
 
 /// In our case, our sink only contains a tokens vector
-struct Sink(Vec<Token>);
+struct Sink(RefCell<Vec<Token>>);
 
 impl TokenSink for Sink {
     type Handle = ();
 
     /// Each processed token will be handled by this method
-    fn process_token(&mut self, token: Token, _line_number: u64) -> TokenSinkResult<()> {
-        self.0.push(token);
+    fn process_token(&self, token: Token, _line_number: u64) -> TokenSinkResult<()> {
+        self.0.borrow_mut().push(token);
         TokenSinkResult::Continue
     }
 }
@@ -39,7 +40,7 @@ fn main() {
     let input = BufferQueue::default();
     input.push_back(chunk.try_reinterpret().unwrap());
 
-    let mut tok = Tokenizer::new(Sink(Vec::new()), Default::default());
+    let tok = Tokenizer::new(Sink(RefCell::new(Vec::new())), Default::default());
     let _ = tok.feed(&input);
     assert!(input.is_empty());
     tok.end();

html5ever/examples/noop-tree-builder.rs

@@ -11,6 +11,7 @@
 extern crate html5ever;
 
 use std::borrow::Cow;
+use std::cell::{Cell, RefCell, Ref};
 use std::collections::HashMap;
 use std::io;
 
@@ -19,15 +20,15 @@ use html5ever::tendril::*;
 use html5ever::tree_builder::{ElementFlags, NodeOrText, QuirksMode, TreeSink};
 use html5ever::{Attribute, ExpandedName, QualName};
 
-struct Sink {
-    next_id: usize,
-    names: HashMap<usize, QualName>,
+struct Sink<'a> {
+    next_id: Cell<usize>,
+    names: &'a mut HashMap<usize, QualName>,
 }
 
-impl Sink {
-    fn get_id(&mut self) -> usize {
-        let id = self.next_id;
-        self.next_id += 2;
+impl <'a> Sink<'a> {
+    fn get_id(&self) -> usize {
+        let id = self.next_id.get();
+        self.next_id.set(id + 2);
         id
     }
 }
@@ -36,18 +37,18 @@ impl Sink {
 /// is processed. In this case the DOM elements are written into the "names" hashmap.
 ///
 /// For deeper understating of each function go to the TreeSink declaration.
-impl TreeSink for Sink {
+impl <'a> TreeSink for Sink<'a> {
     type Handle = usize;
     type Output = Self;
     fn finish(self) -> Self {
         self
     }
 
-    fn get_document(&mut self) -> usize {
+    fn get_document(&self) -> usize {
         0
     }
 
-    fn get_template_contents(&mut self, target: &usize) -> usize {
+    fn get_template_contents(&self, target: &usize) -> usize {
         if let Some(expanded_name!(html "template")) = self.names.get(target).map(|n| n.expanded())
         {
             target + 1
@@ -61,53 +62,57 @@ impl TreeSink for Sink {
     }
 
     fn elem_name(&self, target: &usize) -> ExpandedName {
-        self.names.get(target).expect("not an element").expanded()
+        //let names = self.names.borrow();
+        //Ref::map(names, |names| names.get(target).expect("not an element").expanded())
+        //self.names.get(target).expect("not an element").expanded()
+        todo!()
     }
 
-    fn create_element(&mut self, name: QualName, _: Vec<Attribute>, _: ElementFlags) -> usize {
+    fn create_element(&self, name: QualName, _: Vec<Attribute>, _: ElementFlags) -> usize {
         let id = self.get_id();
-        self.names.insert(id, name);
+        //self.names.insert(id, name);
         id
     }
 
-    fn create_comment(&mut self, _text: StrTendril) -> usize {
+    fn create_comment(&self, _text: StrTendril) -> usize {
         self.get_id()
     }
 
     #[allow(unused_variables)]
-    fn create_pi(&mut self, target: StrTendril, value: StrTendril) -> usize {
+    fn create_pi(&self, target: StrTendril, value: StrTendril) -> usize {
         unimplemented!()
     }
 
-    fn append_before_sibling(&mut self, _sibling: &usize, _new_node: NodeOrText<usize>) {}
+    fn append_before_sibling(&self, _sibling: &usize, _new_node: NodeOrText<usize>) {}
 
     fn append_based_on_parent_node(
-        &mut self,
+        &self,
         _element: &usize,
         _prev_element: &usize,
         _new_node: NodeOrText<usize>,
     ) {
     }
 
-    fn parse_error(&mut self, _msg: Cow<'static, str>) {}
-    fn set_quirks_mode(&mut self, _mode: QuirksMode) {}
-    fn append(&mut self, _parent: &usize, _child: NodeOrText<usize>) {}
+    fn parse_error(&self, _msg: Cow<'static, str>) {}
+    fn set_quirks_mode(&self, _mode: QuirksMode) {}
+    fn append(&self, _parent: &usize, _child: NodeOrText<usize>) {}
 
-    fn append_doctype_to_document(&mut self, _: StrTendril, _: StrTendril, _: StrTendril) {}
-    fn add_attrs_if_missing(&mut self, target: &usize, _attrs: Vec<Attribute>) {
+    fn append_doctype_to_document(&self, _: StrTendril, _: StrTendril, _: StrTendril) {}
+    fn add_attrs_if_missing(&self, target: &usize, _attrs: Vec<Attribute>) {
         assert!(self.names.contains_key(target), "not an element");
     }
-    fn remove_from_parent(&mut self, _target: &usize) {}
-    fn reparent_children(&mut self, _node: &usize, _new_parent: &usize) {}
-    fn mark_script_already_started(&mut self, _node: &usize) {}
+    fn remove_from_parent(&self, _target: &usize) {}
+    fn reparent_children(&self, _node: &usize, _new_parent: &usize) {}
+    fn mark_script_already_started(&self, _node: &usize) {}
 }
 
 /// In this example we implement the TreeSink trait which takes each parsed elements and insert
 /// it to a hashmap, while each element is given a numeric id.
 fn main() {
+    let mut names = HashMap::new();
     let sink = Sink {
-        next_id: 1,
-        names: HashMap::new(),
+        next_id: Cell::new(1),
+        names: &mut names,
     };
 
     // Read HTML from the standard input and parse it