html-to-markdown 2.24.6 → 2.25.0

data/rust-vendor/markup5ever_rcdom/tests/html-tree-builder.rs

@@ -1,298 +0,0 @@
-// 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 markup5ever_rcdom as rcdom;
-#[macro_use]
-extern crate html5ever;
-
-mod foreach_html5lib_test;
-use foreach_html5lib_test::foreach_html5lib_test;
-
-use std::collections::{HashMap, HashSet};
-use std::ffi::OsStr;
-use std::io::BufRead;
-use std::path::Path;
-use std::{fs, io, iter, mem};
-
-use html5ever::tendril::{StrTendril, TendrilSink};
-use html5ever::{parse_document, parse_fragment, ParseOpts};
-use html5ever::{LocalName, QualName};
-use rcdom::{Handle, NodeData, RcDom};
-use util::runner::{run_all, Test};
-
-mod util {
-    pub mod runner;
-}
-
-fn parse_tests<It: Iterator<Item = String>>(mut lines: It) -> Vec<HashMap<String, String>> {
-    let mut tests = vec![];
-    let mut test = HashMap::new();
-    let mut key: Option<String> = None;
-    let mut val = String::new();
-
-    macro_rules! finish_val ( () => (
-        match key.take() {
-            None => (),
-            Some(key) => {
-                assert!(test.insert(key, mem::take(&mut val)).is_none());
-            }
-        }
-    ));
-
-    macro_rules! finish_test ( () => (
-        if !test.is_empty() {
-            tests.push(mem::take(&mut test));
-        }
-    ));
-
-    loop {
-        match lines.next() {
-            None => break,
-            Some(line) => {
-                if let Some(rest) = line.strip_prefix('#') {
-                    finish_val!();
-                    if line == "#data" {
-                        finish_test!();
-                    }
-                    key = Some(rest.to_owned());
-                } else {
-                    val.push_str(&line);
-                    val.push('\n');
-                }
-            },
-        }
-    }
-
-    finish_val!();
-    finish_test!();
-    tests
-}
-
-fn serialize(buf: &mut String, indent: usize, handle: Handle) {
-    buf.push('|');
-    buf.extend(iter::repeat_n(" ", indent));
-
-    let node = handle;
-    match node.data {
-        NodeData::Document => panic!("should not reach Document"),
-
-        NodeData::Doctype {
-            ref name,
-            ref public_id,
-            ref system_id,
-        } => {
-            buf.push_str("<!DOCTYPE ");
-            buf.push_str(name);
-            if !public_id.is_empty() || !system_id.is_empty() {
-                buf.push_str(&format!(" \"{public_id}\" \"{system_id}\""));
-            }
-            buf.push_str(">\n");
-        },
-
-        NodeData::Text { ref contents } => {
-            buf.push('"');
-            buf.push_str(&contents.borrow());
-            buf.push_str("\"\n");
-        },
-
-        NodeData::Comment { ref contents } => {
-            buf.push_str("<!-- ");
-            buf.push_str(contents);
-            buf.push_str(" -->\n");
-        },
-
-        NodeData::Element {
-            ref name,
-            ref attrs,
-            ..
-        } => {
-            buf.push('<');
-            match name.ns {
-                ns!(svg) => buf.push_str("svg "),
-                ns!(mathml) => buf.push_str("math "),
-                _ => (),
-            }
-            buf.push_str(&name.local);
-            buf.push_str(">\n");
-
-            let mut attrs = attrs.borrow().clone();
-            attrs.sort_by(|x, y| x.name.local.cmp(&y.name.local));
-            // FIXME: sort by UTF-16 code unit
-
-            for attr in attrs.into_iter() {
-                buf.push('|');
-                buf.extend(iter::repeat_n(" ", indent + 2));
-                match attr.name.ns {
-                    ns!(xlink) => buf.push_str("xlink "),
-                    ns!(xml) => buf.push_str("xml "),
-                    ns!(xmlns) => buf.push_str("xmlns "),
-                    _ => (),
-                }
-                buf.push_str(&format!("{}=\"{}\"\n", attr.name.local, attr.value));
-            }
-        },
-
-        NodeData::ProcessingInstruction { .. } => unreachable!(),
-    }
-
-    for child in node.children.borrow().iter() {
-        serialize(buf, indent + 2, child.clone());
-    }
-
-    if let NodeData::Element {
-        ref template_contents,
-        ..
-    } = node.data
-    {
-        if let Some(ref content) = &*template_contents.borrow() {
-            buf.push('|');
-            buf.extend(iter::repeat_n(" ", indent + 2));
-            buf.push_str("content\n");
-            for child in content.children.borrow().iter() {
-                serialize(buf, indent + 4, child.clone());
-            }
-        }
-    }
-}
-
-fn make_test(
-    tests: &mut Vec<Test>,
-    ignores: &HashSet<String>,
-    filename: &str,
-    idx: usize,
-    fields: HashMap<String, String>,
-) {
-    let scripting_flags = &[false, true];
-    let scripting_flags = if fields.contains_key("script-off") {
-        &scripting_flags[0..1]
-    } else if fields.contains_key("script-on") {
-        &scripting_flags[1..2]
-    } else {
-        &scripting_flags[0..2]
-    };
-    let name = format!("tb: {filename}-{idx}");
-    for scripting_enabled in scripting_flags {
-        let test = make_test_desc_with_scripting_flag(ignores, &name, &fields, *scripting_enabled);
-        tests.push(test);
-    }
-}
-
-fn make_test_desc_with_scripting_flag(
-    ignores: &HashSet<String>,
-    name: &str,
-    fields: &HashMap<String, String>,
-    scripting_enabled: bool,
-) -> Test {
-    let get_field = |key| {
-        let field = fields.get(key).expect("missing field");
-        field.trim_end_matches('\n').to_string()
-    };
-
-    let mut data = fields.get("data").expect("missing data").to_string();
-    data.pop();
-    let expected = get_field("document");
-    let context = fields
-        .get("document-fragment")
-        .map(|field| context_name(field.trim_end_matches('\n')));
-    let skip = ignores.contains(name);
-    let mut name = name.to_owned();
-    if scripting_enabled {
-        name.push_str(" (scripting enabled)");
-    } else {
-        name.push_str(" (scripting disabled)");
-    };
-
-    Test {
-        name,
-        skip,
-        test: Box::new(move || {
-            // Do this here because Tendril isn't Send.
-            let data = StrTendril::from_slice(&data);
-            let mut opts: ParseOpts = Default::default();
-            opts.tree_builder.scripting_enabled = scripting_enabled;
-            let mut result = String::new();
-            match context {
-                None => {
-                    let dom = parse_document(RcDom::default(), opts).one(data.clone());
-                    for child in dom.document.children.borrow().iter() {
-                        serialize(&mut result, 1, child.clone());
-                    }
-                },
-                Some(ref context) => {
-                    let dom = parse_fragment(RcDom::default(), opts, context.clone(), vec![], true)
-                        .one(data.clone());
-                    // fragment case: serialize children of the html element
-                    // rather than children of the document
-                    let doc = &dom.document;
-                    let root = &doc.children.borrow()[0];
-                    for child in root.children.borrow().iter() {
-                        serialize(&mut result, 1, child.clone());
-                    }
-                },
-            };
-            let len = result.len();
-            result.truncate(len - 1); // drop the trailing newline
-
-            if result != expected {
-                panic!("\ninput: {data}\ngot:\n{result}\nexpected:\n{expected}\n");
-            }
-        }),
-    }
-}
-
-fn context_name(context: &str) -> QualName {
-    if let Some(cx) = context.strip_prefix("svg ") {
-        QualName::new(None, ns!(svg), LocalName::from(cx))
-    } else if let Some(cx) = context.strip_prefix("math ") {
-        QualName::new(None, ns!(mathml), LocalName::from(cx))
-    } else {
-        QualName::new(None, ns!(html), LocalName::from(context))
-    }
-}
-
-fn tests(src_dir: &Path, ignores: &HashSet<String>) -> Vec<Test> {
-    let mut tests = vec![];
-
-    foreach_html5lib_test(
-        src_dir,
-        "html5lib-tests/tree-construction",
-        OsStr::new("dat"),
-        |path, file| {
-            let buf = io::BufReader::new(file);
-            let lines = buf.lines().map(|res| res.expect("couldn't read"));
-            let data = parse_tests(lines);
-
-            for (i, test) in data.into_iter().enumerate() {
-                make_test(
-                    &mut tests,
-                    ignores,
-                    path.file_name().unwrap().to_str().unwrap(),
-                    i,
-                    test,
-                );
-            }
-        },
-    );
-
-    tests
-}
-
-fn main() {
-    let src_dir = Path::new("./");
-    let mut ignores = HashSet::new();
-    {
-        let f = fs::File::open(src_dir.join("data/test/ignore")).unwrap();
-        let r = io::BufReader::new(f);
-        for ln in r.lines() {
-            ignores.insert(ln.unwrap().trim_end().to_string());
-        }
-    }
-
-    run_all(tests(src_dir, &ignores));
-}

data/rust-vendor/markup5ever_rcdom/tests/html-tree-sink.rs

@@ -1,141 +0,0 @@
-use html5ever::driver;
-use html5ever::tendril::stream::TendrilSink;
-use html5ever::tendril::StrTendril;
-use html5ever::ExpandedName;
-use html5ever::QualName;
-use markup5ever::interface::{ElementFlags, NodeOrText, QuirksMode, TreeSink};
-use markup5ever::{local_name, ns, Attribute};
-use markup5ever_rcdom::{Handle, RcDom};
-use std::borrow::Cow;
-use std::cell::{Cell, RefCell};
-
-pub struct LineCountingDOM {
-    pub line_vec: RefCell<Vec<(QualName, u64)>>,
-    pub current_line: Cell<u64>,
-    pub rcdom: RcDom,
-}
-
-impl TreeSink for LineCountingDOM {
-    type Output = Self;
-    type ElemName<'a> = ExpandedName<'a>;
-
-    fn finish(self) -> Self {
-        self
-    }
-
-    type Handle = Handle;
-
-    fn parse_error(&self, msg: Cow<'static, str>) {
-        self.rcdom.parse_error(msg);
-    }
-
-    fn get_document(&self) -> Handle {
-        self.rcdom.get_document()
-    }
-
-    fn get_template_contents(&self, target: &Handle) -> Handle {
-        self.rcdom.get_template_contents(target)
-    }
-
-    fn set_quirks_mode(&self, mode: QuirksMode) {
-        self.rcdom.set_quirks_mode(mode)
-    }
-
-    fn same_node(&self, x: &Handle, y: &Handle) -> bool {
-        self.rcdom.same_node(x, y)
-    }
-
-    fn elem_name<'a>(&'a self, target: &'a Handle) -> ExpandedName<'a> {
-        self.rcdom.elem_name(target)
-    }
-
-    fn create_element(&self, name: QualName, attrs: Vec<Attribute>, flags: ElementFlags) -> Handle {
-        self.line_vec
-            .borrow_mut()
-            .push((name.clone(), self.current_line.get()));
-        self.rcdom.create_element(name, attrs, flags)
-    }
-
-    fn create_comment(&self, text: StrTendril) -> Handle {
-        self.rcdom.create_comment(text)
-    }
-
-    fn create_pi(&self, target: StrTendril, content: StrTendril) -> Handle {
-        self.rcdom.create_pi(target, content)
-    }
-
-    fn append(&self, parent: &Handle, child: NodeOrText<Handle>) {
-        self.rcdom.append(parent, child)
-    }
-
-    fn append_before_sibling(&self, sibling: &Handle, child: NodeOrText<Handle>) {
-        self.rcdom.append_before_sibling(sibling, child)
-    }
-
-    fn append_based_on_parent_node(
-        &self,
-        element: &Handle,
-        prev_element: &Handle,
-        child: NodeOrText<Handle>,
-    ) {
-        self.rcdom
-            .append_based_on_parent_node(element, prev_element, child)
-    }
-
-    fn append_doctype_to_document(
-        &self,
-        name: StrTendril,
-        public_id: StrTendril,
-        system_id: StrTendril,
-    ) {
-        self.rcdom
-            .append_doctype_to_document(name, public_id, system_id);
-    }
-
-    fn add_attrs_if_missing(&self, target: &Handle, attrs: Vec<Attribute>) {
-        self.rcdom.add_attrs_if_missing(target, attrs);
-    }
-
-    fn remove_from_parent(&self, target: &Handle) {
-        self.rcdom.remove_from_parent(target);
-    }
-
-    fn reparent_children(&self, node: &Handle, new_parent: &Handle) {
-        self.rcdom.reparent_children(node, new_parent);
-    }
-
-    fn mark_script_already_started(&self, target: &Handle) {
-        self.rcdom.mark_script_already_started(target);
-    }
-
-    fn set_current_line(&self, line_number: u64) {
-        self.current_line.set(line_number);
-    }
-}
-
-#[test]
-fn check_four_lines() {
-    // Input
-    let sink = LineCountingDOM {
-        line_vec: RefCell::new(vec![]),
-        current_line: Cell::new(1),
-        rcdom: RcDom::default(),
-    };
-    let mut result_tok = driver::parse_document(sink, Default::default());
-    result_tok.process(StrTendril::from("<a>\n"));
-    result_tok.process(StrTendril::from("</a>\n"));
-    result_tok.process(StrTendril::from("<b>\n"));
-    result_tok.process(StrTendril::from("</b>"));
-    // Actual Output
-    let actual = result_tok.finish();
-    // Expected Output
-    let expected = vec![
-        (QualName::new(None, ns!(html), local_name!("html")), 1),
-        (QualName::new(None, ns!(html), local_name!("head")), 1),
-        (QualName::new(None, ns!(html), local_name!("body")), 1),
-        (QualName::new(None, ns!(html), local_name!("a")), 1),
-        (QualName::new(None, ns!(html), local_name!("b")), 3),
-    ];
-    // Assertion
-    assert_eq!(*actual.line_vec.borrow(), expected);
-}

data/rust-vendor/markup5ever_rcdom/tests/util/find_tests.rs

@@ -1,34 +0,0 @@
-// 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.
-
-use std::ffi::OsStr;
-use std::fs;
-use std::path::Path;
-
-pub fn foreach_xml5lib_test<Mk>(
-    src_dir: &Path,
-    subdir: &'static str,
-    ext: &'static OsStr,
-    mut mk: Mk,
-) where
-    Mk: FnMut(&Path, fs::File),
-{
-    let mut test_dir_path = src_dir.to_path_buf();
-    test_dir_path.push("xml5lib-tests");
-    test_dir_path.push(subdir);
-
-    let test_files = fs::read_dir(&test_dir_path).unwrap();
-    for entry in test_files {
-        let path = entry.unwrap().path();
-        if path.extension() == Some(ext) {
-            let file = fs::File::open(&path).unwrap();
-            mk(&path, file);
-        }
-    }
-}

data/rust-vendor/markup5ever_rcdom/tests/util/runner.rs

@@ -1,48 +0,0 @@
-// Copyright 2024 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.
-
-use libtest_mimic::{Arguments, Trial};
-
-/// Simple container for storing tests for later execution
-pub struct Test {
-    pub name: String,
-    pub skip: bool,
-    pub test: Box<dyn Fn() + Send + Sync>,
-}
-
-impl Test {
-    /// Invoke the stored test function
-    ///
-    /// A status message is printed if the wrapped closure completes
-    /// or is marked as skipped. The test should panic to report
-    /// failure.
-    pub fn run(&self) {
-        print!("test {} ...", self.name);
-        if self.skip {
-            println!(" SKIPPED");
-        } else {
-            (self.test)();
-            println!(" ok");
-        }
-    }
-}
-
-pub fn run_all(tests: Vec<Test>) {
-    let mut harness_tests = Vec::new();
-
-    for test in tests {
-        let harness_test = Trial::test(test.name.clone(), move || {
-            test.run();
-            Ok(())
-        });
-        harness_tests.push(harness_test);
-    }
-    let args = Arguments::from_args();
-    libtest_mimic::run(&args, harness_tests).exit();
-}

data/rust-vendor/markup5ever_rcdom/tests/xml-driver.rs

@@ -1,101 +0,0 @@
-use markup5ever_rcdom::{RcDom, SerializableHandle};
-use xml5ever::driver;
-use xml5ever::serialize;
-use xml5ever::tendril::TendrilSink;
-
-#[test]
-fn el_ns_serialize() {
-    assert_eq_serialization(
-        "<a:title xmlns:a=\"http://www.foo.org/\" value=\"test\">Test</a:title>",
-        driver::parse_document(RcDom::default(), Default::default())
-            .from_utf8()
-            .one("<a:title xmlns:a=\"http://www.foo.org/\" value=\"test\">Test</title>".as_bytes()),
-    );
-}
-
-#[test]
-fn nested_ns_serialize() {
-    assert_eq_serialization("<a:x xmlns:a=\"http://www.foo.org/\" xmlns:b=\"http://www.bar.org/\" value=\"test\"><b:y/></a:x>",
-        driver::parse_document(RcDom::default(), Default::default())
-            .from_utf8()
-            .one("<a:x xmlns:a=\"http://www.foo.org/\" xmlns:b=\"http://www.bar.org/\" value=\"test\"><b:y/></a:x>".as_bytes()));
-}
-
-#[test]
-fn def_ns_serialize() {
-    assert_eq_serialization(
-        "<table xmlns=\"html4\"><td></td></table>",
-        driver::parse_document(RcDom::default(), Default::default())
-            .from_utf8()
-            .one("<table xmlns=\"html4\"><td></td></table>".as_bytes()),
-    );
-}
-
-#[test]
-fn undefine_ns_serialize() {
-    assert_eq_serialization(
-        "<a:x xmlns:a=\"http://www.foo.org\"><a:y xmlns:a=\"\"><a:z/></a:y</a:x>",
-        driver::parse_document(RcDom::default(), Default::default())
-            .from_utf8()
-            .one(
-                "<a:x xmlns:a=\"http://www.foo.org\"><a:y xmlns:a=\"\"><a:z/></a:y</a:x>"
-                    .as_bytes(),
-            ),
-    );
-}
-
-#[test]
-fn redefine_default_ns_serialize() {
-    assert_eq_serialization(
-        "<x xmlns=\"http://www.foo.org\"><y xmlns=\"\"><z/></y</x>",
-        driver::parse_document(RcDom::default(), Default::default())
-            .from_utf8()
-            .one("<x xmlns=\"http://www.foo.org\"><y xmlns=\"\"><z/></y</x>".as_bytes()),
-    );
-}
-
-#[test]
-fn attr_serialize() {
-    assert_serialization(
-        "<title value=\"test\">Test</title>",
-        driver::parse_document(RcDom::default(), Default::default())
-            .from_utf8()
-            .one("<title value='test'>Test".as_bytes()),
-    );
-}
-
-#[test]
-fn from_utf8() {
-    assert_serialization(
-        "<title>Test</title>",
-        driver::parse_document(RcDom::default(), Default::default())
-            .from_utf8()
-            .one("<title>Test".as_bytes()),
-    );
-}
-
-fn assert_eq_serialization(text: &'static str, dom: RcDom) {
-    let mut serialized = Vec::new();
-    let document: SerializableHandle = dom.document.clone().into();
-    serialize::serialize(&mut serialized, &document, Default::default()).unwrap();
-
-    let dom_from_text = driver::parse_document(RcDom::default(), Default::default())
-        .from_utf8()
-        .one(text.as_bytes());
-
-    let mut reserialized = Vec::new();
-    let document: SerializableHandle = dom_from_text.document.clone().into();
-    serialize::serialize(&mut reserialized, &document, Default::default()).unwrap();
-
-    assert_eq!(
-        String::from_utf8(serialized).unwrap(),
-        String::from_utf8(reserialized).unwrap()
-    );
-}
-
-fn assert_serialization(text: &'static str, dom: RcDom) {
-    let mut serialized = Vec::new();
-    let document: SerializableHandle = dom.document.clone().into();
-    serialize::serialize(&mut serialized, &document, Default::default()).unwrap();
-    assert_eq!(String::from_utf8(serialized).unwrap(), text);
-}