html-to-markdown 3.4.0 → 3.6.0.pre.rc.24

data/vendor/html-to-markdown-rs/tests/issue_127_regressions.rs

@@ -1,58 +0,0 @@
-#![allow(missing_docs)]
-
-fn convert(
-    html: &str,
-    opts: Option<html_to_markdown_rs::ConversionOptions>,
-) -> html_to_markdown_rs::error::Result<String> {
-    html_to_markdown_rs::convert(html, opts).map(|r| r.content.unwrap_or_default())
-}
-
-use std::fs;
-use std::path::PathBuf;
-
-use html_to_markdown_rs::{
-    CodeBlockStyle, ConversionOptions, HeadingStyle, HighlightStyle, ListIndentType, PreprocessingOptions,
-    PreprocessingPreset, WhitespaceMode,
-};
-
-fn fixture_path(name: &str) -> PathBuf {
-    [env!("CARGO_MANIFEST_DIR"), "../../test_documents/html/issues", name]
-        .iter()
-        .collect()
-}
-
-fn issue_127_options() -> ConversionOptions {
-    ConversionOptions {
-        heading_style: HeadingStyle::Atx,
-        bullets: "-".to_string(),
-        list_indent_type: ListIndentType::Spaces,
-        list_indent_width: 2,
-        whitespace_mode: WhitespaceMode::Normalized,
-        highlight_style: HighlightStyle::DoubleEqual,
-        wrap: false,
-        br_in_tables: true,
-        code_block_style: CodeBlockStyle::Backticks,
-        strip_newlines: true,
-        extract_metadata: false,
-        preprocessing: PreprocessingOptions {
-            enabled: true,
-            preset: PreprocessingPreset::Minimal,
-            remove_navigation: true,
-            remove_forms: true,
-        },
-        ..Default::default()
-    }
-}
-
-#[test]
-fn converts_multilingual_fixture_without_utf8_boundary_panic() {
-    let html = fs::read_to_string(fixture_path("gh-127-issue.html")).expect("read issue fixture");
-
-    let markdown = convert(&html, Some(issue_127_options())).expect("convert should not panic on utf-8 boundaries");
-
-    assert!(!markdown.is_empty(), "converted output should contain content");
-    assert!(
-        markdown.contains("MW841") && markdown.contains("كريب"),
-        "converted output should preserve multilingual product content"
-    );
-}

data/vendor/html-to-markdown-rs/tests/issue_128_regressions.rs

@@ -1,17 +0,0 @@
-#![allow(missing_docs)]
-
-fn convert(
-    html: &str,
-    opts: Option<html_to_markdown_rs::ConversionOptions>,
-) -> html_to_markdown_rs::error::Result<String> {
-    html_to_markdown_rs::convert(html, opts).map(|r| r.content.unwrap_or_default())
-}
-
-#[test]
-fn images_with_dimensions_render_as_markdown_links() {
-    let html = r#"<img src="data:image/png;base64,xyz==" alt="Pixel" width="100" height="100"/>"#;
-
-    let markdown = convert(html, None).expect("image conversion should succeed");
-
-    assert_eq!(markdown.trim(), "![Pixel](data:image/png;base64,xyz==)");
-}

data/vendor/html-to-markdown-rs/tests/issue_131_regressions.rs

@@ -1,41 +0,0 @@
-#![allow(missing_docs)]
-
-fn convert(
-    html: &str,
-    opts: Option<html_to_markdown_rs::ConversionOptions>,
-) -> html_to_markdown_rs::error::Result<String> {
-    html_to_markdown_rs::convert(html, opts).map(|r| r.content.unwrap_or_default())
-}
-
-use html_to_markdown_rs::ConversionOptions;
-use html_to_markdown_rs::options::WhitespaceMode;
-
-#[test]
-fn link_flattens_block_children_issue_131() {
-    let html = r#"<a href="https://www.google.com">
-              <h3>MWD08 - الابيض</h3>
-              <p><span class="money" data-cbb-price-processed="true" style="display: none;">70.00 SAR</span><span class="currency-converter-wrapper-amount-box" style="display: inline-block; white-space: nowrap; margin: 0px; padding: 0px; text-decoration: inherit;"><span class="currency-converter-amount-box" style="display: inline-block; white-space: nowrap; padding: 0px; line-height: initial; color: rgb(28, 28, 28); font-size: 14px; font-style: normal; font-weight: 400; text-decoration: rgb(28, 28, 28);"><span style="text-decoration: inherit; display: inline-block; margin-right: 3px; font-family: Nunito, sans-serif; font-size: 14px; font-weight: 400; color: inherit; float: none;" class="currency-converter-amount cbb-price-currency-USD"><span class="cbb-price-symbol" style="padding: 0px 1px; color: inherit; float: none; margin-right: 0px;">$</span><span class="cbb-price-digits" style="padding: 0px 1px; color: inherit; float: none;">18.66</span><span class="cbb-price-code" style="margin-left: 3px; padding: 0px 1px; color: inherit; float: none;">USD</span></span></span></span></p>
-            </a>"#;
-
-    let options = ConversionOptions {
-        whitespace_mode: WhitespaceMode::Normalized,
-        ..Default::default()
-    };
-
-    let result = convert(html, Some(options)).unwrap();
-    assert_eq!(result, "[MWD08 - الابيض 70.00 SAR$18.66USD](https://www.google.com)\n");
-}
-
-#[test]
-fn link_label_newlines_are_collapsed() {
-    let html = r#"<p><a href="https://example.com">line 1
-line 2</a></p>"#;
-
-    let options = ConversionOptions {
-        whitespace_mode: WhitespaceMode::Normalized,
-        ..Default::default()
-    };
-
-    let result = convert(html, Some(options)).unwrap();
-    assert_eq!(result, "[line 1 line 2](https://example.com)\n");
-}

data/vendor/html-to-markdown-rs/tests/issue_134_regressions.rs

@@ -1,40 +0,0 @@
-#![allow(missing_docs)]
-
-fn convert(
-    html: &str,
-    opts: Option<html_to_markdown_rs::ConversionOptions>,
-) -> html_to_markdown_rs::error::Result<String> {
-    html_to_markdown_rs::convert(html, opts).map(|r| r.content.unwrap_or_default())
-}
-
-use std::fs;
-use std::path::PathBuf;
-
-use html_to_markdown_rs::ConversionOptions;
-
-fn fixture_path(name: &str) -> PathBuf {
-    [env!("CARGO_MANIFEST_DIR"), "../../test_documents/html/issues", name]
-        .iter()
-        .collect()
-}
-
-fn default_options() -> ConversionOptions {
-    ConversionOptions {
-        extract_metadata: false,
-        autolinks: false,
-        ..Default::default()
-    }
-}
-
-fn normalize_newlines(input: &str) -> String {
-    input.replace("\r\n", "\n").replace('\r', "\n")
-}
-
-#[test]
-fn converts_pre_code_fixture() {
-    let html = fs::read_to_string(fixture_path("gh-134-pre-code.html")).unwrap();
-    let expected = fs::read_to_string(fixture_path("gh-134-pre-code.md")).unwrap();
-
-    let result = convert(&html, Some(default_options())).unwrap();
-    assert_eq!(normalize_newlines(&result), normalize_newlines(&expected));
-}

data/vendor/html-to-markdown-rs/tests/issue_139_regressions.rs

@@ -1,26 +0,0 @@
-#![allow(missing_docs)]
-
-fn convert(
-    html: &str,
-    opts: Option<html_to_markdown_rs::ConversionOptions>,
-) -> html_to_markdown_rs::error::Result<String> {
-    html_to_markdown_rs::convert(html, opts).map(|r| r.content.unwrap_or_default())
-}
-
-use html_to_markdown_rs::ConversionOptions;
-
-#[test]
-fn long_multibyte_link_label_does_not_panic() {
-    let mut html = String::from("<a href=\"https://example.com/article\">");
-    html.push_str(&"a".repeat(511));
-    html.push('👍');
-    html.push_str("</a>");
-
-    let markdown = convert(&html, Some(ConversionOptions::default())).unwrap();
-    let expected_label = format!("{}👍", "a".repeat(511));
-
-    assert!(
-        markdown.contains(&format!("[{expected_label}]")),
-        "expected full label to appear in markdown output; got: {markdown}"
-    );
-}

data/vendor/html-to-markdown-rs/tests/issue_140_regressions.rs

@@ -1,185 +0,0 @@
-#![allow(missing_docs)]
-
-fn convert(
-    html: &str,
-    opts: Option<html_to_markdown_rs::ConversionOptions>,
-) -> html_to_markdown_rs::error::Result<String> {
-    html_to_markdown_rs::convert(html, opts).map(|r| r.content.unwrap_or_default())
-}
-
-use std::fs;
-use std::path::PathBuf;
-
-use html_to_markdown_rs::ConversionOptions;
-
-fn fixture_path(name: &str) -> PathBuf {
-    [env!("CARGO_MANIFEST_DIR"), "../../test_documents/html/issues", name]
-        .iter()
-        .collect()
-}
-
-fn default_options() -> ConversionOptions {
-    ConversionOptions {
-        extract_metadata: false,
-        autolinks: false,
-        ..Default::default()
-    }
-}
-
-fn escape_misc_options() -> ConversionOptions {
-    ConversionOptions {
-        extract_metadata: false,
-        autolinks: false,
-        escape_misc: true,
-        ..Default::default()
-    }
-}
-
-fn normalize_newlines(input: &str) -> String {
-    input.replace("\r\n", "\n").replace('\r', "\n")
-}
-
-#[test]
-fn converts_should_not_escape_in_pre_or_code_fixture() {
-    let pre_html = r"<pre>This pipe | should not be escaped.<pre/>";
-
-    let pre_markdown_without_misc = convert(pre_html, Some(default_options())).expect("conversion should succeed");
-    assert_eq!(
-        pre_markdown_without_misc.trim(),
-        "```\nThis pipe | should not be escaped.\n```"
-    );
-
-    let pre_markdown_with_misc = convert(pre_html, Some(escape_misc_options())).expect("conversion should succeed");
-    assert_eq!(
-        pre_markdown_with_misc.trim(),
-        "```\nThis pipe | should not be escaped.\n```"
-    );
-
-    let code_html = r"<code>This pipe | should not be escaped.<code/>";
-
-    let code_markdown_without_misc = convert(code_html, None).expect("conversion should succeed");
-    assert_eq!(
-        code_markdown_without_misc.trim(),
-        "`This pipe | should not be escaped.`"
-    );
-
-    let code_markdown_with_misc = convert(code_html, Some(escape_misc_options())).expect("conversion should succeed");
-    assert_eq!(code_markdown_with_misc.trim(), "`This pipe | should not be escaped.`");
-}
-
-#[test]
-fn converts_table_cell_pipe_fixture() {
-    let html = fs::read_to_string(fixture_path("gh-140-table-cell-pipe.html")).unwrap();
-    let expected_without_misc = fs::read_to_string(fixture_path("gh-140-table-cell-pipe.md")).unwrap();
-    let expected_with_misc = fs::read_to_string(fixture_path("gh-140-table-cell-pipe-with-escape-misc.md")).unwrap();
-
-    let result_without_misc = convert(&html, Some(default_options())).expect("conversion should succeed");
-    assert_eq!(
-        normalize_newlines(&result_without_misc),
-        normalize_newlines(&expected_without_misc)
-    );
-
-    let result_with_misc = convert(&html, Some(escape_misc_options())).expect("conversion should succeed");
-    assert_eq!(
-        normalize_newlines(&result_with_misc),
-        normalize_newlines(&expected_with_misc)
-    );
-}
-
-#[test]
-fn escapes_only_literal_pipes_in_table_cells() {
-    let html = r"
-        <table>
-            <thead><tr><th>Type</th><th>Span</th><th>Block</th></tr></thead>
-            <tbody>
-                <tr>
-                    <td>text | content</td>
-                    <td><code>code | span</code></td>
-                    <td><pre>block | content</pre></td>
-                </tr>
-            </tbody>
-        </table>
-    ";
-
-    let markdown = convert(html, Some(default_options())).expect("conversion should succeed");
-    assert!(
-        markdown.contains("text \\| content"),
-        "literal pipe in text cell should be escaped"
-    );
-    assert!(
-        markdown.contains("`code | span`"),
-        "pipe inside code span should not be escaped"
-    );
-    assert!(
-        !markdown.contains("`code \\| span`"),
-        "code spans must not receive backslash escaping"
-    );
-    assert!(
-        markdown.contains("block | content"),
-        "pre/code blocks should retain literal pipe characters"
-    );
-    assert!(
-        !markdown.contains("block \\| content"),
-        "pre/code block content should not be escaped"
-    );
-
-    let markdown_with_misc = convert(html, Some(escape_misc_options())).expect("conversion should succeed");
-    assert!(
-        markdown_with_misc.contains("text \\| content"),
-        "literal pipe in text cell should be escaped when escape_misc=true"
-    );
-    assert!(
-        markdown_with_misc.contains("`code | span`"),
-        "code span pipe should remain unescaped when escape_misc=true"
-    );
-    assert!(
-        !markdown_with_misc.contains("`code \\| span`"),
-        "code spans must not be escaped when escape_misc=true"
-    );
-}
-
-#[test]
-fn nested_tables_do_not_double_escape_pipes() {
-    let html = r"
-        <table>
-            <thead><tr><th>Outer A</th><th>Outer B</th></tr></thead>
-            <tbody>
-                <tr>
-                    <td>
-                        <table>
-                            <thead><tr><th>Inner A</th><th>Inner B</th></tr></thead>
-                            <tbody>
-                                <tr><td>Inner | pipe</td><td>B</td></tr>
-                            </tbody>
-                        </table>
-                    </td>
-                    <td>Outer | pipe</td>
-                </tr>
-            </tbody>
-        </table>
-    ";
-
-    let markdown = convert(html, Some(default_options())).expect("conversion should succeed");
-    assert!(
-        markdown
-            .lines()
-            .any(|line| line.contains("Inner A") && line.contains("Inner B")),
-        "nested table structure should be preserved: {markdown}"
-    );
-    assert!(
-        markdown.contains("Inner \\| pipe"),
-        "literal pipe text inside nested table should be escaped once"
-    );
-    assert!(
-        !markdown.contains("Inner \\\\| pipe"),
-        "nested table text should not be double-escaped"
-    );
-    assert!(
-        markdown.contains("Outer \\| pipe"),
-        "outer cell literal pipe should be escaped"
-    );
-    assert!(
-        !markdown.contains("Outer \\\\| pipe"),
-        "outer cell text should only be escaped once"
-    );
-}

data/vendor/html-to-markdown-rs/tests/issue_143_regressions.rs

@@ -1,100 +0,0 @@
-#![allow(missing_docs)]
-
-fn convert(
-    html: &str,
-    opts: Option<html_to_markdown_rs::ConversionOptions>,
-) -> html_to_markdown_rs::error::Result<String> {
-    html_to_markdown_rs::convert(html, opts).map(|r| r.content.unwrap_or_default())
-}
-
-use std::fs;
-use std::path::PathBuf;
-
-use html_to_markdown_rs::ConversionOptions;
-
-fn fixture_path(name: &str) -> PathBuf {
-    [env!("CARGO_MANIFEST_DIR"), "../../test_documents/html/issues", name]
-        .iter()
-        .collect()
-}
-
-fn options_with_wrap() -> ConversionOptions {
-    ConversionOptions {
-        wrap: true,
-        wrap_width: 80,
-        extract_metadata: false,
-        autolinks: false,
-        ..Default::default()
-    }
-}
-
-fn normalize_newlines(input: &str) -> String {
-    input.replace("\r\n", "\n").replace('\r', "\n")
-}
-
-#[test]
-fn split_closing_tag_does_not_merge_nested_list() {
-    // Regression: tl parser mishandles </tag\n> (closing bracket on next line).
-    // The <a> element absorbs the nested <ul> because the closing </a\n> isn't
-    // recognised, so all nested items end up inside the link text.
-    // Note: the `>` closing the opening <a> and the `>` closing </a are on
-    // separate lines (JSX-style formatting). tl must still parse this correctly.
-    let html = r##"<ul>
-  <li>
-    <a href="#beyond"
-      >Beyond triads</a
-    >
-    <ul>
-      <li><a href="#c">Child</a></li>
-    </ul>
-  </li>
-  <li>
-    <a href="#sibling"
-      >Sibling item</a
-    >
-    <ul>
-      <li><a href="#d">Deep child</a></li>
-    </ul>
-  </li>
-</ul>"##;
-    let opts = ConversionOptions {
-        wrap: false,
-        extract_metadata: false,
-        autolinks: false,
-        ..Default::default()
-    };
-    let result = convert(html, Some(opts)).expect("conversion should succeed");
-    // The nested list items must appear on their own lines, not merged into the
-    // parent link text.
-    assert!(
-        result.contains("Child"),
-        "nested item 'Child' should be present: got {result:?}"
-    );
-    assert!(
-        result.contains("Sibling item"),
-        "sibling list item should be present: got {result:?}"
-    );
-    assert!(
-        result.contains("Deep child"),
-        "deep nested item should be present: got {result:?}"
-    );
-    // None of the nested items should appear inside the link text of the parent item.
-    assert!(
-        !result.contains("triads * [") && !result.contains("triads - [Child"),
-        "nested items must not be merged into parent link text: got {result:?}"
-    );
-}
-
-#[test]
-fn wrap_preserves_link_only_list_items() {
-    let html = fs::read_to_string(fixture_path("gh-143-links-wordwrap.html")).unwrap();
-    let expected = fs::read_to_string(fixture_path("gh-143-links-wordwrap.md")).unwrap();
-
-    let result = convert(&html, Some(options_with_wrap())).expect("conversion should succeed");
-
-    assert_eq!(
-        normalize_newlines(&result).trim(),
-        normalize_newlines(&expected).trim(),
-        "word wrapping should not merge nested link-only list items"
-    );
-}

data/vendor/html-to-markdown-rs/tests/issue_145_regressions.rs

@@ -1,133 +0,0 @@
-#![allow(missing_docs)]
-
-use html_to_markdown_rs::ConversionOptions;
-
-#[test]
-fn test_strip_newlines_preserves_block_spacing() {
-    let html = r"<section>
-    <h1>Heading</h1>
-    <p>Paragraph one.</p>
-    <p>Paragraph two.</p>
-</section>";
-
-    let options = ConversionOptions {
-        strip_newlines: true,
-        extract_metadata: false,
-        ..Default::default()
-    };
-    let result = convert(html, Some(options)).unwrap();
-
-    let lines: Vec<&str> = result.lines().collect();
-
-    let mut max_consecutive_blank = 0;
-    let mut current_blank_count = 0;
-    for line in &lines {
-        if line.trim().is_empty() {
-            current_blank_count += 1;
-            max_consecutive_blank = max_consecutive_blank.max(current_blank_count);
-        } else {
-            current_blank_count = 0;
-        }
-    }
-
-    assert!(
-        max_consecutive_blank <= 1,
-        "excessive blank lines detected: {max_consecutive_blank} consecutive blanks in:\n{result}"
-    );
-
-    assert!(result.contains("Heading"), "heading missing from: {result}");
-    assert!(result.contains("Paragraph one"), "paragraph one missing from: {result}");
-    assert!(result.contains("Paragraph two"), "paragraph two missing from: {result}");
-}
-
-#[test]
-fn test_strip_newlines_removes_inline_newlines() {
-    let html = r"<p>This is a paragraph
-with line breaks
-in the middle</p>";
-
-    let options = ConversionOptions {
-        strip_newlines: true,
-        extract_metadata: false,
-        ..Default::default()
-    };
-    let result = convert(html, Some(options)).unwrap();
-
-    let text = result.trim();
-
-    let content_lines: Vec<&str> = text.lines().collect();
-
-    let has_paragraph_line = content_lines.iter().any(|line| {
-        let trimmed = line.trim();
-        trimmed.contains("This is a paragraph")
-            && trimmed.contains("with line breaks")
-            && trimmed.contains("in the middle")
-    });
-
-    assert!(
-        has_paragraph_line,
-        "paragraph should have inline newlines converted to spaces in: {result}"
-    );
-}
-
-#[test]
-fn test_strip_newlines_handles_nested_blocks() {
-    let html = r"<section>
-    <div>
-        <h2>Nested Heading</h2>
-        <p>Content inside nested div.</p>
-    </div>
-    <div>
-        <h2>Another Section</h2>
-        <p>More content here.</p>
-    </div>
-</section>";
-
-    let options = ConversionOptions {
-        strip_newlines: true,
-        extract_metadata: false,
-        ..Default::default()
-    };
-    let result = convert(html, Some(options)).unwrap();
-
-    assert!(
-        result.contains("Nested Heading"),
-        "nested heading missing from: {result}"
-    );
-    assert!(
-        result.contains("Content inside nested div"),
-        "nested content missing from: {result}"
-    );
-    assert!(
-        result.contains("Another Section"),
-        "another section heading missing from: {result}"
-    );
-    assert!(
-        result.contains("More content here"),
-        "more content missing from: {result}"
-    );
-
-    let lines: Vec<&str> = result.lines().collect();
-    let mut max_consecutive_blank = 0;
-    let mut current_blank_count = 0;
-    for line in &lines {
-        if line.trim().is_empty() {
-            current_blank_count += 1;
-            max_consecutive_blank = max_consecutive_blank.max(current_blank_count);
-        } else {
-            current_blank_count = 0;
-        }
-    }
-
-    assert!(
-        max_consecutive_blank <= 1,
-        "excessive blank lines in nested blocks: {max_consecutive_blank} consecutive blanks in:\n{result}"
-    );
-}
-
-fn convert(
-    html: &str,
-    opts: Option<html_to_markdown_rs::ConversionOptions>,
-) -> html_to_markdown_rs::error::Result<String> {
-    html_to_markdown_rs::convert(html, opts).map(|r| r.content.unwrap_or_default())
-}