rusteerio 0.0.0-stage → 0.1.0

package/native/vendor/html5ever-0.35.0/examples/print-tree-actions.rs

@@ -0,0 +1,185 @@
+// Copyright 2014-2017 The html5ever Project Developers. See the
+// COPYRIGHT file at the top-level directory of this distribution.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[macro_use]
+extern crate html5ever;
+
+use std::borrow::Cow;
+use std::cell::{Cell, Ref, RefCell};
+use std::collections::HashMap;
+use std::io;
+
+use html5ever::parse_document;
+use html5ever::tendril::*;
+use html5ever::tree_builder::{
+    AppendNode, AppendText, ElementFlags, NodeOrText, QuirksMode, TreeSink,
+};
+use html5ever::{Attribute, QualName};
+
+struct Sink {
+    next_id: Cell<usize>,
+    names: RefCell<HashMap<usize, &'static QualName>>,
+}
+
+impl Sink {
+    fn get_id(&self) -> usize {
+        let id = self.next_id.get();
+        self.next_id.set(id + 2);
+        id
+    }
+}
+
+impl TreeSink for Sink {
+    type Handle = usize;
+    type Output = Self;
+    type ElemName<'a> = Ref<'a, QualName>;
+    fn finish(self) -> Self {
+        self
+    }
+
+    fn parse_error(&self, msg: Cow<'static, str>) {
+        println!("Parse error: {msg}");
+    }
+
+    fn get_document(&self) -> usize {
+        0
+    }
+
+    fn get_template_contents(&self, target: &usize) -> usize {
+        if let Some(expanded_name!(html "template")) =
+            self.names.borrow().get(target).map(|n| n.expanded())
+        {
+            target + 1
+        } else {
+            panic!("not a template element")
+        }
+    }
+
+    fn set_quirks_mode(&self, mode: QuirksMode) {
+        println!("Set quirks mode to {mode:?}");
+    }
+
+    fn same_node(&self, x: &usize, y: &usize) -> bool {
+        x == y
+    }
+
+    fn elem_name(&self, target: &usize) -> Self::ElemName<'_> {
+        Ref::map(self.names.borrow(), |map| {
+            *map.get(target).expect("not an element")
+        })
+    }
+
+    fn create_element(&self, name: QualName, _: Vec<Attribute>, _: ElementFlags) -> usize {
+        let id = self.get_id();
+        println!("Created {name:?} as {id}");
+        // N.B. We intentionally leak memory here to minimize the implementation complexity
+        //      of this example code. A real implementation would either want to use a real
+        //      real DOM tree implentation, or else use an arena as the backing store for
+        //      memory used by the parser.
+        self.names
+            .borrow_mut()
+            .insert(id, Box::leak(Box::new(name)));
+        id
+    }
+
+    fn create_comment(&self, text: StrTendril) -> usize {
+        let id = self.get_id();
+        println!("Created comment \"{}\" as {}", text.escape_default(), id);
+        id
+    }
+
+    #[allow(unused_variables)]
+    fn create_pi(&self, target: StrTendril, value: StrTendril) -> usize {
+        unimplemented!()
+    }
+
+    fn append(&self, parent: &usize, child: NodeOrText<usize>) {
+        match child {
+            AppendNode(n) => println!("Append node {n} to {parent}"),
+            AppendText(t) => println!("Append text to {}: \"{}\"", parent, t.escape_default()),
+        }
+    }
+
+    fn append_before_sibling(&self, sibling: &usize, new_node: NodeOrText<usize>) {
+        match new_node {
+            AppendNode(n) => println!("Append node {n} before {sibling}"),
+            AppendText(t) => println!("Append text before {}: \"{}\"", sibling, t.escape_default()),
+        }
+    }
+
+    fn append_based_on_parent_node(
+        &self,
+        element: &Self::Handle,
+        _prev_element: &Self::Handle,
+        child: NodeOrText<Self::Handle>,
+    ) {
+        self.append_before_sibling(element, child);
+    }
+
+    fn append_doctype_to_document(
+        &self,
+        name: StrTendril,
+        public_id: StrTendril,
+        system_id: StrTendril,
+    ) {
+        println!("Append doctype: {name} {public_id} {system_id}");
+    }
+
+    fn add_attrs_if_missing(&self, target: &usize, attrs: Vec<Attribute>) {
+        assert!(self.names.borrow().contains_key(target), "not an element");
+        println!("Add missing attributes to {target}:");
+        for attr in attrs.into_iter() {
+            println!("    {:?} = {}", attr.name, attr.value);
+        }
+    }
+
+    fn associate_with_form(
+        &self,
+        _target: &usize,
+        _form: &usize,
+        _nodes: (&usize, Option<&usize>),
+    ) {
+        // No form owner support.
+    }
+
+    fn remove_from_parent(&self, target: &usize) {
+        println!("Remove {target} from parent");
+    }
+
+    fn reparent_children(&self, node: &usize, new_parent: &usize) {
+        println!("Move children from {node} to {new_parent}");
+    }
+
+    fn mark_script_already_started(&self, node: &usize) {
+        println!("Mark script {node} as already started");
+    }
+
+    fn set_current_line(&self, line_number: u64) {
+        println!("Set current line to {line_number}");
+    }
+
+    fn pop(&self, elem: &usize) {
+        println!("Popped element {elem}");
+    }
+}
+
+/// Same example as the "noop-tree-builder", but this time every function implemented in our
+/// Sink object prints a log, so it's easier to get an understating of when each function is
+/// called.
+fn main() {
+    let sink = Sink {
+        next_id: Cell::new(1),
+        names: RefCell::new(HashMap::new()),
+    };
+    let stdin = io::stdin();
+    parse_document(sink, Default::default())
+        .from_utf8()
+        .read_from(&mut stdin.lock())
+        .unwrap();
+}

package/native/vendor/html5ever-0.35.0/examples/tokenize.rs

@@ -0,0 +1,111 @@
+// Copyright 2014-2017 The html5ever Project Developers. See the
+// COPYRIGHT file at the top-level directory of this distribution.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+extern crate html5ever;
+
+use std::cell::Cell;
+use std::io;
+
+use html5ever::tendril::*;
+use html5ever::tokenizer::BufferQueue;
+use html5ever::tokenizer::{CharacterTokens, EndTag, NullCharacterToken, StartTag, TagToken};
+use html5ever::tokenizer::{
+    ParseError, Token, TokenSink, TokenSinkResult, Tokenizer, TokenizerOpts,
+};
+
+#[derive(Clone)]
+struct TokenPrinter {
+    in_char_run: Cell<bool>,
+}
+
+impl TokenPrinter {
+    fn is_char(&self, is_char: bool) {
+        match (self.in_char_run.get(), is_char) {
+            (false, true) => print!("CHAR : \""),
+            (true, false) => println!("\""),
+            _ => (),
+        }
+        self.in_char_run.set(is_char);
+    }
+
+    fn do_char(&self, c: char) {
+        self.is_char(true);
+        print!("{}", c.escape_default().collect::<String>());
+    }
+}
+
+impl TokenSink for TokenPrinter {
+    type Handle = ();
+
+    fn process_token(&self, token: Token, _line_number: u64) -> TokenSinkResult<()> {
+        match token {
+            CharacterTokens(b) => {
+                for c in b.chars() {
+                    self.do_char(c);
+                }
+            },
+            NullCharacterToken => self.do_char('\0'),
+            TagToken(tag) => {
+                self.is_char(false);
+                // This is not proper HTML serialization, of course.
+                match tag.kind {
+                    StartTag => print!("TAG  : <\x1b[32m{}\x1b[0m", tag.name),
+                    EndTag => print!("TAG  : <\x1b[31m/{}\x1b[0m", tag.name),
+                }
+                for attr in tag.attrs.iter() {
+                    print!(
+                        " \x1b[36m{}\x1b[0m='\x1b[34m{}\x1b[0m'",
+                        attr.name.local, attr.value
+                    );
+                }
+                if tag.self_closing {
+                    print!(" \x1b[31m/\x1b[0m");
+                }
+                println!(">");
+            },
+            ParseError(err) => {
+                self.is_char(false);
+                println!("ERROR: {err}");
+            },
+            _ => {
+                self.is_char(false);
+                println!("OTHER: {token:?}");
+            },
+        }
+        TokenSinkResult::Continue
+    }
+}
+
+/// In this example we implement the TokenSink trait in such a way that each token is printed.
+/// If a there's an error while processing a token it is printed as well.
+fn main() {
+    let sink = TokenPrinter {
+        in_char_run: Cell::new(false),
+    };
+
+    // Read HTML from standard input
+    let mut chunk = ByteTendril::new();
+    io::stdin().read_to_tendril(&mut chunk).unwrap();
+
+    let input = BufferQueue::default();
+    input.push_back(chunk.try_reinterpret().unwrap());
+
+    let tok = Tokenizer::new(
+        sink,
+        TokenizerOpts {
+            profile: true,
+            ..Default::default()
+        },
+    );
+    let _ = tok.feed(&input);
+
+    assert!(input.is_empty());
+    tok.end();
+    tok.sink.is_char(false);
+}

package/native/vendor/html5ever-0.35.0/src/driver.rs

@@ -0,0 +1,148 @@
+// Copyright 2014-2017 The html5ever Project Developers. See the
+// COPYRIGHT file at the top-level directory of this distribution.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! High-level interface to the parser.
+
+use crate::buffer_queue::BufferQueue;
+use crate::tokenizer::{Tokenizer, TokenizerOpts};
+use crate::tree_builder::{create_element, TreeBuilder, TreeBuilderOpts, TreeSink};
+use crate::{Attribute, QualName};
+use markup5ever::TokenizerResult;
+use std::borrow::Cow;
+
+use crate::tendril;
+use crate::tendril::stream::{TendrilSink, Utf8LossyDecoder};
+use crate::tendril::StrTendril;
+
+/// All-encompassing options struct for the parser.
+#[derive(Clone, Default)]
+pub struct ParseOpts {
+    /// Tokenizer options.
+    pub tokenizer: TokenizerOpts,
+
+    /// Tree builder options.
+    pub tree_builder: TreeBuilderOpts,
+}
+
+/// Parse an HTML document
+///
+/// The returned value implements `tendril::TendrilSink`
+/// so that Unicode input may be provided incrementally,
+/// or all at once with the `one` method.
+///
+/// If your input is bytes, use `Parser::from_utf8`.
+pub fn parse_document<Sink>(sink: Sink, opts: ParseOpts) -> Parser<Sink>
+where
+    Sink: TreeSink,
+{
+    let tb = TreeBuilder::new(sink, opts.tree_builder);
+    let tok = Tokenizer::new(tb, opts.tokenizer);
+    Parser {
+        tokenizer: tok,
+        input_buffer: BufferQueue::default(),
+    }
+}
+
+/// Parse an HTML fragment
+///
+/// The returned value implements `tendril::TendrilSink`
+/// so that Unicode input may be provided incrementally,
+/// or all at once with the `one` method.
+///
+/// If your input is bytes, use `Parser::from_utf8`.
+pub fn parse_fragment<Sink>(
+    sink: Sink,
+    opts: ParseOpts,
+    context_name: QualName,
+    context_attrs: Vec<Attribute>,
+    context_element_allows_scripting: bool,
+) -> Parser<Sink>
+where
+    Sink: TreeSink,
+{
+    let context_elem = create_element(&sink, context_name, context_attrs);
+    parse_fragment_for_element(
+        sink,
+        opts,
+        context_elem,
+        context_element_allows_scripting,
+        None,
+    )
+}
+
+/// Like `parse_fragment`, but with an existing context element
+/// and optionally a form element.
+pub fn parse_fragment_for_element<Sink>(
+    sink: Sink,
+    opts: ParseOpts,
+    context_element: Sink::Handle,
+    context_element_allows_scripting: bool,
+    form_element: Option<Sink::Handle>,
+) -> Parser<Sink>
+where
+    Sink: TreeSink,
+{
+    let tree_builder =
+        TreeBuilder::new_for_fragment(sink, context_element, form_element, opts.tree_builder);
+    let tokenizer_options = TokenizerOpts {
+        initial_state: Some(
+            tree_builder.tokenizer_state_for_context_elem(context_element_allows_scripting),
+        ),
+        ..opts.tokenizer
+    };
+    let tokenizer = Tokenizer::new(tree_builder, tokenizer_options);
+    Parser {
+        tokenizer,
+        input_buffer: BufferQueue::default(),
+    }
+}
+
+/// An HTML parser,
+/// ready to receive Unicode input through the `tendril::TendrilSink` trait’s methods.
+pub struct Parser<Sink>
+where
+    Sink: TreeSink,
+{
+    pub tokenizer: Tokenizer<TreeBuilder<Sink::Handle, Sink>>,
+    pub input_buffer: BufferQueue,
+}
+
+impl<Sink: TreeSink> TendrilSink<tendril::fmt::UTF8> for Parser<Sink> {
+    fn process(&mut self, t: StrTendril) {
+        self.input_buffer.push_back(t);
+        // FIXME: Properly support </script> somehow.
+        while let TokenizerResult::Script(_) = self.tokenizer.feed(&self.input_buffer) {}
+    }
+
+    // FIXME: Is it too noisy to report every character decoding error?
+    fn error(&mut self, desc: Cow<'static, str>) {
+        self.tokenizer.sink.sink.parse_error(desc)
+    }
+
+    type Output = Sink::Output;
+
+    fn finish(self) -> Self::Output {
+        // FIXME: Properly support </script> somehow.
+        while let TokenizerResult::Script(_) = self.tokenizer.feed(&self.input_buffer) {}
+        assert!(self.input_buffer.is_empty());
+        self.tokenizer.end();
+        self.tokenizer.sink.sink.finish()
+    }
+}
+
+impl<Sink: TreeSink> Parser<Sink> {
+    /// Wrap this parser into a `TendrilSink` that accepts UTF-8 bytes.
+    ///
+    /// Use this when your input is bytes that are known to be in the UTF-8 encoding.
+    /// Decoding is lossy, like `String::from_utf8_lossy`.
+    #[allow(clippy::wrong_self_convention)]
+    pub fn from_utf8(self) -> Utf8LossyDecoder<Self> {
+        Utf8LossyDecoder::new(self)
+    }
+}

package/native/vendor/html5ever-0.35.0/src/lib.rs

@@ -0,0 +1,30 @@
+// Copyright 2014-2017 The html5ever Project Developers. See the
+// COPYRIGHT file at the top-level directory of this distribution.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![crate_name = "html5ever"]
+#![crate_type = "dylib"]
+#![cfg_attr(test, deny(warnings))]
+#![allow(unused_parens)]
+#![warn(unreachable_pub)]
+
+pub use driver::{parse_document, parse_fragment, ParseOpts, Parser};
+pub use markup5ever::*;
+
+pub use serialize::serialize;
+
+mod util {
+    pub(crate) mod str;
+}
+
+pub(crate) mod macros;
+
+pub mod driver;
+pub mod serialize;
+pub mod tokenizer;
+pub mod tree_builder;

package/native/vendor/html5ever-0.35.0/src/macros.rs

@@ -0,0 +1,34 @@
+// Copyright 2014-2017 The html5ever Project Developers. See the
+// COPYRIGHT file at the top-level directory of this distribution.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+macro_rules! unwrap_or_return {
+    ($opt:expr) => {{
+        let Some(x) = $opt else {
+            return;
+        };
+        x
+    }};
+    ($opt:expr, $retval:expr) => {{
+        let Some(x) = $opt else {
+            return $retval;
+        };
+        x
+    }};
+}
+pub(crate) use unwrap_or_return;
+
+macro_rules! time {
+    ($e:expr) => {{
+        let t0 = ::std::time::Instant::now();
+        let result = $e;
+        let dt = t0.elapsed().as_nanos() as u64;
+        (result, dt)
+    }};
+}
+pub(crate) use time;