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

data/vendor/html-to-markdown-rs/src/converter/list/ordered.rs

@@ -1,201 +0,0 @@
-//! Ordered list handling (ol, li elements).
-//!
-//! Processes ordered lists with support for:
-//! - Custom start counters
-//! - Nested list handling
-//! - Loose/tight list detection
-//! - Proper indentation and numbering
-
-use super::utils::{
-    add_list_leading_separator, add_nested_list_trailing_separator, calculate_list_nesting_depth, is_loose_list,
-    process_list_children,
-};
-#[cfg(feature = "visitor")]
-use crate::converter::utility::content::collect_tag_attributes;
-use crate::options::ConversionOptions;
-#[allow(unused_imports)]
-use std::collections::BTreeMap;
-use tl;
-
-// Type aliases for Context and DomContext to avoid circular imports
-type Context = crate::converter::Context;
-type DomContext = crate::converter::DomContext;
-
-/// Handle ordered list element (<ol>).
-///
-/// Extracts the `start` attribute to set initial counter value,
-/// detects loose/tight list format, and processes list items.
-#[allow(clippy::too_many_arguments)]
-pub fn handle_ol(
-    node_handle: &tl::NodeHandle,
-    parser: &tl::Parser,
-    output: &mut String,
-    options: &ConversionOptions,
-    ctx: &Context,
-    depth: usize,
-    dom_ctx: &DomContext,
-) {
-    add_list_leading_separator(output, ctx);
-
-    let nested_depth = calculate_list_nesting_depth(ctx);
-    let is_loose = is_loose_list(*node_handle, parser, dom_ctx);
-
-    let tag = match node_handle.get(parser) {
-        Some(tl::Node::Tag(t)) => t,
-        _ => return,
-    };
-
-    let start = tag
-        .attributes()
-        .get("start")
-        .flatten()
-        .and_then(|v| v.as_utf8_str().parse::<usize>().ok())
-        .unwrap_or(1);
-
-    #[cfg(feature = "visitor")]
-    let list_output_start = output.len();
-
-    #[cfg(feature = "visitor")]
-    let mut list_start_custom: Option<String> = None;
-
-    #[cfg(feature = "visitor")]
-    if let Some(ref visitor_handle) = ctx.visitor {
-        use crate::visitor::{NodeContext, NodeType, VisitResult};
-
-        let attributes: BTreeMap<String, String> = collect_tag_attributes(tag);
-
-        let parent_tag = dom_ctx
-            .parent_of(node_handle.get_inner())
-            .and_then(|pid| dom_ctx.tag_name_for(dom_ctx.node_handle(pid).copied()?, parser))
-            .map(|s| s.to_string());
-
-        let index = dom_ctx.sibling_index(node_handle.get_inner()).unwrap_or(0);
-
-        let node_ctx = NodeContext {
-            node_type: NodeType::List,
-            tag_name: "ol".to_string(),
-            attributes,
-            depth,
-            index_in_parent: index,
-            parent_tag,
-            is_inline: false,
-        };
-
-        let visit_result = {
-            let mut visitor = visitor_handle.borrow_mut();
-            visitor.visit_list_start(&node_ctx, true)
-        };
-        match visit_result {
-            VisitResult::Continue => {}
-            VisitResult::Custom(custom) => {
-                list_start_custom = Some(custom);
-            }
-            VisitResult::Skip => {
-                return;
-            }
-            VisitResult::PreserveHtml => {
-                use crate::converter::serialize_node_to_html;
-                serialize_node_to_html(node_handle, parser, output);
-                return;
-            }
-            VisitResult::Error(err) => {
-                if ctx.visitor_error.borrow().is_none() {
-                    *ctx.visitor_error.borrow_mut() = Some(err);
-                }
-                return;
-            }
-        }
-    }
-
-    if !ctx.in_table_cell {
-        if let Some(ref sc) = ctx.structure_collector {
-            sc.borrow_mut().push_list_start(true);
-        }
-    }
-
-    process_list_children(
-        *node_handle,
-        parser,
-        output,
-        options,
-        ctx,
-        depth,
-        true,
-        is_loose,
-        nested_depth,
-        start,
-        dom_ctx,
-    );
-
-    if !ctx.in_table_cell {
-        if let Some(ref sc) = ctx.structure_collector {
-            sc.borrow_mut().push_list_end();
-        }
-    }
-
-    add_nested_list_trailing_separator(output, ctx);
-
-    #[cfg(feature = "visitor")]
-    if let Some(ref visitor_handle) = ctx.visitor {
-        use crate::visitor::{NodeContext, NodeType, VisitResult};
-
-        let attributes: BTreeMap<String, String> = collect_tag_attributes(tag);
-
-        let parent_tag = dom_ctx
-            .parent_of(node_handle.get_inner())
-            .and_then(|pid| dom_ctx.tag_name_for(dom_ctx.node_handle(pid).copied()?, parser))
-            .map(|s| s.to_string());
-
-        let index = dom_ctx.sibling_index(node_handle.get_inner()).unwrap_or(0);
-
-        let node_ctx = NodeContext {
-            node_type: NodeType::List,
-            tag_name: "ol".to_string(),
-            attributes,
-            depth,
-            index_in_parent: index,
-            parent_tag,
-            is_inline: false,
-        };
-
-        let list_content = &output[list_output_start..];
-
-        let visit_result = {
-            let mut visitor = visitor_handle.borrow_mut();
-            visitor.visit_list_end(&node_ctx, true, list_content)
-        };
-        match visit_result {
-            VisitResult::Continue => {
-                if let Some(custom_start) = list_start_custom {
-                    output.insert_str(list_output_start, &custom_start);
-                }
-            }
-            VisitResult::Custom(custom) => {
-                let children_output = output[list_output_start..].to_string();
-                output.truncate(list_output_start);
-                if let Some(custom_start) = list_start_custom {
-                    output.push_str(&custom_start);
-                }
-                output.push_str(&children_output);
-                output.push_str(&custom);
-            }
-            VisitResult::Skip => {
-                output.truncate(list_output_start);
-            }
-            VisitResult::PreserveHtml => {
-                output.truncate(list_output_start);
-                use crate::converter::serialize_node_to_html;
-                serialize_node_to_html(node_handle, parser, output);
-            }
-            VisitResult::Error(err) => {
-                if ctx.visitor_error.borrow().is_none() {
-                    *ctx.visitor_error.borrow_mut() = Some(err);
-                }
-                output.truncate(list_output_start);
-            }
-        }
-    }
-}
-
-/// Public alias for `handle_ol` to match the expected module interface.
-pub use handle_ol as handle;

data/vendor/html-to-markdown-rs/src/converter/list/unordered.rs

@@ -1,195 +0,0 @@
-//! Unordered list handling (ul, li elements).
-//!
-//! Processes unordered lists with support for:
-//! - Bullet cycling based on nesting depth
-//! - Nested list handling
-//! - Loose/tight list detection
-//! - Proper indentation
-
-use super::utils::{
-    add_list_leading_separator, add_nested_list_trailing_separator, calculate_list_nesting_depth, is_loose_list,
-    process_list_children,
-};
-#[cfg(feature = "visitor")]
-use crate::converter::utility::content::collect_tag_attributes;
-use crate::options::ConversionOptions;
-#[cfg(feature = "visitor")]
-use std::collections::BTreeMap;
-use tl;
-
-// Type aliases for Context and DomContext to avoid circular imports
-type Context = crate::converter::Context;
-type DomContext = crate::converter::DomContext;
-
-/// Handle unordered list element (<ul>).
-///
-/// Detects loose/tight list format, handles nested bullets,
-/// and processes list items with proper indentation.
-#[allow(clippy::too_many_arguments)]
-pub fn handle_ul(
-    node_handle: &tl::NodeHandle,
-    parser: &tl::Parser,
-    output: &mut String,
-    options: &ConversionOptions,
-    ctx: &Context,
-    depth: usize,
-    dom_ctx: &DomContext,
-) {
-    add_list_leading_separator(output, ctx);
-
-    let nested_depth = calculate_list_nesting_depth(ctx);
-    let is_loose = is_loose_list(*node_handle, parser, dom_ctx);
-
-    #[allow(unused_variables)]
-    let tag = match node_handle.get(parser) {
-        Some(tl::Node::Tag(t)) => t,
-        _ => return,
-    };
-
-    #[cfg(feature = "visitor")]
-    let list_output_start = output.len();
-
-    #[cfg(feature = "visitor")]
-    let mut list_start_custom: Option<String> = None;
-
-    #[cfg(feature = "visitor")]
-    if let Some(ref visitor_handle) = ctx.visitor {
-        use crate::visitor::{NodeContext, NodeType, VisitResult};
-
-        let attributes: BTreeMap<String, String> = collect_tag_attributes(tag);
-
-        let parent_tag = dom_ctx
-            .parent_of(node_handle.get_inner())
-            .and_then(|pid| dom_ctx.tag_name_for(dom_ctx.node_handle(pid).copied()?, parser))
-            .map(|s| s.to_string());
-
-        let index = dom_ctx.sibling_index(node_handle.get_inner()).unwrap_or(0);
-
-        let node_ctx = NodeContext {
-            node_type: NodeType::List,
-            tag_name: "ul".to_string(),
-            attributes,
-            depth,
-            index_in_parent: index,
-            parent_tag,
-            is_inline: false,
-        };
-
-        let visit_result = {
-            let mut visitor = visitor_handle.borrow_mut();
-            visitor.visit_list_start(&node_ctx, false)
-        };
-        match visit_result {
-            VisitResult::Continue => {}
-            VisitResult::Custom(custom) => {
-                list_start_custom = Some(custom);
-            }
-            VisitResult::Skip => {
-                return;
-            }
-            VisitResult::PreserveHtml => {
-                use crate::converter::serialize_node_to_html;
-                serialize_node_to_html(node_handle, parser, output);
-                return;
-            }
-            VisitResult::Error(err) => {
-                if ctx.visitor_error.borrow().is_none() {
-                    *ctx.visitor_error.borrow_mut() = Some(err);
-                }
-                return;
-            }
-        }
-    }
-
-    if !ctx.in_table_cell {
-        if let Some(ref sc) = ctx.structure_collector {
-            sc.borrow_mut().push_list_start(false);
-        }
-    }
-
-    process_list_children(
-        *node_handle,
-        parser,
-        output,
-        options,
-        ctx,
-        depth,
-        false,
-        is_loose,
-        nested_depth,
-        1,
-        dom_ctx,
-    );
-
-    if !ctx.in_table_cell {
-        if let Some(ref sc) = ctx.structure_collector {
-            sc.borrow_mut().push_list_end();
-        }
-    }
-
-    add_nested_list_trailing_separator(output, ctx);
-
-    #[cfg(feature = "visitor")]
-    if let Some(ref visitor_handle) = ctx.visitor {
-        use crate::visitor::{NodeContext, NodeType, VisitResult};
-
-        let attributes: BTreeMap<String, String> = collect_tag_attributes(tag);
-
-        let parent_tag = dom_ctx
-            .parent_of(node_handle.get_inner())
-            .and_then(|pid| dom_ctx.tag_name_for(dom_ctx.node_handle(pid).copied()?, parser))
-            .map(|s| s.to_string());
-
-        let index = dom_ctx.sibling_index(node_handle.get_inner()).unwrap_or(0);
-
-        let node_ctx = NodeContext {
-            node_type: NodeType::List,
-            tag_name: "ul".to_string(),
-            attributes,
-            depth,
-            index_in_parent: index,
-            parent_tag,
-            is_inline: false,
-        };
-
-        let list_content = &output[list_output_start..];
-
-        let visit_result = {
-            let mut visitor = visitor_handle.borrow_mut();
-            visitor.visit_list_end(&node_ctx, false, list_content)
-        };
-        match visit_result {
-            VisitResult::Continue => {
-                if let Some(custom_start) = list_start_custom {
-                    output.insert_str(list_output_start, &custom_start);
-                }
-            }
-            VisitResult::Custom(custom) => {
-                let children_output = output[list_output_start..].to_string();
-                output.truncate(list_output_start);
-                if let Some(custom_start) = list_start_custom {
-                    output.push_str(&custom_start);
-                }
-                output.push_str(&children_output);
-                output.push_str(&custom);
-            }
-            VisitResult::Skip => {
-                output.truncate(list_output_start);
-            }
-            VisitResult::PreserveHtml => {
-                output.truncate(list_output_start);
-                use crate::converter::serialize_node_to_html;
-                serialize_node_to_html(node_handle, parser, output);
-            }
-            VisitResult::Error(err) => {
-                if ctx.visitor_error.borrow().is_none() {
-                    *ctx.visitor_error.borrow_mut() = Some(err);
-                }
-                output.truncate(list_output_start);
-            }
-        }
-    }
-}
-
-/// Public alias for `handle_ul` to match the expected module interface.
-pub use handle_ul as handle;

data/vendor/html-to-markdown-rs/src/converter/list/utils.rs

@@ -1,314 +0,0 @@
-//! Utility functions for list processing.
-//!
-//! Contains helper functions for loose list detection, indentation calculation,
-//! list spacing, and list child processing.
-
-use crate::converter::main_helpers::{tag_name_eq, trim_trailing_whitespace};
-use crate::options::{ConversionOptions, ListIndentType};
-use tl;
-
-// Type aliases for Context and DomContext to avoid circular imports
-// These are imported from converter.rs and should be made accessible
-type Context = crate::converter::Context;
-type DomContext = crate::converter::DomContext;
-
-/// Calculate indentation level for list item continuations.
-///
-/// Returns the number of 4-space indent groups needed for list continuations.
-///
-/// List continuations (block elements inside list items) need special indentation:
-/// - Base indentation: (depth - 1) groups (for the nesting level)
-/// - Content indentation: depth groups (for the list item content)
-/// - Combined formula: (2 * depth - 1) groups of 4 spaces each
-///
-/// # Examples
-///
-/// ```text
-/// * Item 1           (depth=0, no continuation)
-/// * Item 2           (depth=0)
-///     Continuation   (depth=0: 0 groups = 0 spaces)
-///
-/// * Level 1          (depth=0)
-///     + Level 2      (depth=1)
-///             Cont   (depth=1: (2*1-1) = 1 group = 4 spaces, total 12 with bullet indent)
-/// ```
-pub const fn calculate_list_continuation_indent(depth: usize) -> usize {
-    if depth > 0 { 2 * depth - 1 } else { 0 }
-}
-
-/// Check if a list (ul or ol) is "loose".
-///
-/// A loose list is one where any list item contains block-level elements
-/// like paragraphs (<p>). In loose lists, all items should have blank line
-/// separation (ending with \n\n) regardless of their own content.
-///
-/// # Examples
-///
-/// ```html
-/// <!-- Loose list (has <p> in an item) -->
-/// <ul>
-///   <li><p>Item 1</p></li>
-///   <li>Item 2</li>  <!-- Also gets \n\n ending -->
-/// </ul>
-///
-/// <!-- Tight list (no block elements) -->
-/// <ul>
-///   <li>Item 1</li>
-///   <li>Item 2</li>
-/// </ul>
-/// ```
-pub fn is_loose_list(node_handle: tl::NodeHandle, parser: &tl::Parser, dom_ctx: &DomContext) -> bool {
-    if let Some(tl::Node::Tag(tag)) = node_handle.get(parser) {
-        let children = tag.children();
-        {
-            for child_handle in children.top().iter() {
-                let is_li = dom_ctx.tag_info(child_handle.get_inner(), parser).map_or_else(
-                    || {
-                        matches!(
-                            child_handle.get(parser),
-                            Some(tl::Node::Tag(child_tag))
-                                if tag_name_eq(child_tag.name().as_utf8_str(), "li")
-                        )
-                    },
-                    |info| info.name == "li",
-                );
-                if !is_li {
-                    continue;
-                }
-
-                if let Some(tl::Node::Tag(child_tag)) = child_handle.get(parser) {
-                    let li_children = child_tag.children();
-                    for li_child_handle in li_children.top().iter() {
-                        let is_p = dom_ctx.tag_info(li_child_handle.get_inner(), parser).map_or_else(
-                            || {
-                                matches!(
-                                    li_child_handle.get(parser),
-                                    Some(tl::Node::Tag(li_child_tag))
-                                        if tag_name_eq(li_child_tag.name().as_utf8_str(), "p")
-                                )
-                            },
-                            |info| info.name == "p",
-                        );
-                        if is_p {
-                            return true;
-                        }
-                    }
-                }
-            }
-        }
-    }
-    false
-}
-
-/// Add list continuation indentation to output.
-///
-/// Used when block elements (like <p> or <div>) appear inside list items.
-/// Adds appropriate line separation and indentation to continue the list item.
-///
-/// # Arguments
-///
-/// * `output` - The output string to append to
-/// * `list_depth` - Current list nesting depth
-/// * `blank_line` - If true, adds blank line separation (\n\n); if false, single newline (\n)
-///
-/// # Examples
-///
-/// ```text
-/// Paragraph continuation (blank_line = true):
-///   * First para
-///
-///       Second para  (blank line + indentation)
-///
-/// Div continuation (blank_line = false):
-///   * First div
-///       Second div   (single newline + indentation)
-/// ```
-pub fn add_list_continuation_indent(
-    output: &mut String,
-    list_depth: usize,
-    blank_line: bool,
-    options: &ConversionOptions,
-) {
-    trim_trailing_whitespace(output);
-
-    if blank_line {
-        if !output.ends_with("\n\n") {
-            if output.ends_with('\n') {
-                output.push('\n');
-            } else {
-                output.push_str("\n\n");
-            }
-        }
-    } else if !output.ends_with('\n') {
-        output.push('\n');
-    }
-
-    let indent_level = calculate_list_continuation_indent(list_depth);
-    let indent_char = match options.list_indent_type {
-        ListIndentType::Tabs => "\t",
-        ListIndentType::Spaces => {
-            for _ in 0..options.list_indent_width {
-                output.push(' ');
-            }
-            return;
-        }
-    };
-    for _ in 0..indent_level {
-        output.push_str(indent_char);
-    }
-}
-
-/// Calculate the indentation string for list continuations based on depth and options.
-pub fn continuation_indent_string(list_depth: usize, options: &ConversionOptions) -> Option<String> {
-    let indent_level = calculate_list_continuation_indent(list_depth);
-    if indent_level == 0 {
-        return None;
-    }
-
-    let mut indent = String::new();
-    match options.list_indent_type {
-        ListIndentType::Tabs => {
-            for _ in 0..indent_level {
-                indent.push('\t');
-            }
-        }
-        ListIndentType::Spaces => {
-            for _ in 0..(options.list_indent_width * indent_level) {
-                indent.push(' ');
-            }
-        }
-    }
-    Some(indent)
-}
-
-/// Add appropriate leading separator before a list.
-///
-/// Lists need different separators depending on context:
-/// - In table cells: <br> tag if there's already content
-/// - Outside lists: blank line (\n\n) if needed
-/// - Inside list items: blank line before nested list
-pub fn add_list_leading_separator(output: &mut String, ctx: &Context) {
-    if ctx.in_table_cell {
-        let is_table_continuation =
-            !output.is_empty() && !output.ends_with('|') && !output.ends_with(' ') && !output.ends_with("<br>");
-        if is_table_continuation {
-            output.push_str("<br>");
-        }
-        return;
-    }
-
-    if !output.is_empty() && !ctx.in_list {
-        let needs_newline =
-            !output.ends_with("\n\n") && !output.ends_with("* ") && !output.ends_with("- ") && !output.ends_with(". ");
-        if needs_newline {
-            output.push_str("\n\n");
-        }
-        return;
-    }
-
-    if ctx.in_list_item && !output.is_empty() {
-        let needs_newline =
-            !output.ends_with('\n') && !output.ends_with("* ") && !output.ends_with("- ") && !output.ends_with(". ");
-        if needs_newline {
-            trim_trailing_whitespace(output);
-            output.push('\n');
-        }
-    }
-}
-
-/// Add appropriate trailing separator after a nested list.
-///
-/// Nested lists inside list items need trailing newlines to separate
-/// from following content. In loose lists, use blank line (\n\n). In tight lists, single newline (\n).
-pub fn add_nested_list_trailing_separator(output: &mut String, ctx: &Context) {
-    if !ctx.in_list_item {
-        return;
-    }
-
-    if ctx.loose_list {
-        if !output.ends_with("\n\n") {
-            if !output.ends_with('\n') {
-                output.push('\n');
-            }
-            output.push('\n');
-        }
-    } else if !output.ends_with('\n') {
-        output.push('\n');
-    }
-}
-
-/// Calculate the nesting depth for a list.
-///
-/// If we're in a list but NOT in a list item, this is incorrectly nested HTML
-/// and we need to increment the depth. If in a list item, the depth was already
-/// incremented by the <li> element.
-pub const fn calculate_list_nesting_depth(ctx: &Context) -> usize {
-    if ctx.in_list && !ctx.in_list_item {
-        ctx.list_depth + 1
-    } else {
-        ctx.list_depth
-    }
-}
-
-/// Check if a node is a list item element.
-pub fn is_list_item(node_handle: tl::NodeHandle, parser: &tl::Parser, dom_ctx: &DomContext) -> bool {
-    if let Some(info) = dom_ctx.tag_info(node_handle.get_inner(), parser) {
-        return info.name == "li";
-    }
-    matches!(
-        node_handle.get(parser),
-        Some(tl::Node::Tag(tag)) if tag_name_eq(tag.name().as_utf8_str(), "li")
-    )
-}
-
-/// Process a list's children, tracking which items had block elements.
-///
-/// This is used to determine proper spacing between list items.
-/// Returns true if the last processed item had block children.
-#[allow(clippy::too_many_arguments)]
-pub fn process_list_children(
-    node_handle: tl::NodeHandle,
-    parser: &tl::Parser,
-    output: &mut String,
-    options: &ConversionOptions,
-    ctx: &Context,
-    depth: usize,
-    is_ordered: bool,
-    is_loose: bool,
-    nested_depth: usize,
-    start_counter: usize,
-    dom_ctx: &DomContext,
-) {
-    let mut counter = start_counter;
-
-    if let Some(tl::Node::Tag(tag)) = node_handle.get(parser) {
-        let children = tag.children();
-        {
-            for child_handle in children.top().iter() {
-                if let Some(tl::Node::Raw(bytes)) = child_handle.get(parser) {
-                    if bytes.as_utf8_str().trim().is_empty() {
-                        continue;
-                    }
-                }
-
-                let list_ctx = Context {
-                    in_ordered_list: is_ordered,
-                    list_counter: if is_ordered { counter } else { 0 },
-                    in_list: true,
-                    list_depth: nested_depth,
-                    ul_depth: if is_ordered { ctx.ul_depth } else { ctx.ul_depth + 1 },
-                    loose_list: is_loose,
-                    prev_item_had_blocks: false,
-                    ..ctx.clone()
-                };
-
-                use crate::converter::walk_node;
-                walk_node(child_handle, parser, output, options, &list_ctx, depth, dom_ctx);
-
-                if is_ordered && is_list_item(*child_handle, parser, dom_ctx) {
-                    counter += 1;
-                }
-            }
-        }
-    }
-}