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

data/vendor/html-to-markdown-rs/src/converter/block/table/mod.rs

@@ -1,266 +0,0 @@
-//! Table element handler for HTML to Markdown conversion.
-//!
-//! This module provides specialized handling for table elements including:
-//! - Table structure detection and scanning (TableScan)
-//! - Row and cell conversion to Markdown table format
-//! - Cell content processing with colspan/rowspan support
-//! - Layout table detection (tables used for visual layout)
-//! - Integration with the visitor pattern for custom table handling
-//!
-//! Tables are converted to Markdown pipe-delimited format with header separators.
-//! Layout tables (tables without proper semantic headers) may be converted to lists
-//! instead of tables for better readability.
-
-pub mod builder;
-pub mod caption;
-pub mod cell;
-pub mod cells;
-pub mod layout;
-pub mod scanner;
-pub(super) mod utils;
-
-// Re-export types from parent module for submodule access
-
-// Re-export for use in converter.rs
-pub use caption::handle_caption;
-
-/// Dispatches table element handling to the main convert_table function.
-///
-/// # Usage in converter.rs
-/// ```text
-/// if "table" == tag_name {
-///     crate::converter::block::table::handle_table(
-///         node_handle,
-///         parser,
-///         output,
-///         options,
-///         ctx,
-///         dom_ctx,
-///         depth,
-///     );
-///     return;
-/// }
-/// ```
-pub fn dispatch_table_handler(
-    tag_name: &str,
-    node_handle: &tl::NodeHandle,
-    parser: &tl::Parser,
-    output: &mut String,
-    options: &crate::options::ConversionOptions,
-    ctx: &super::super::Context,
-    depth: usize,
-    dom_ctx: &super::super::DomContext,
-) -> bool {
-    match tag_name {
-        "table" => {
-            builder::handle_table(node_handle, parser, output, options, ctx, dom_ctx, depth);
-            true
-        }
-        _ => false,
-    }
-}
-
-/// Handles table output with context-aware formatting.
-///
-/// This function wraps `handle_table` with list indentation and whitespace management logic.
-/// It handles two distinct contexts:
-///
-/// 1. **List Context** (`ctx.in_list_item = true`):
-///    - Indents table content using `indent_table_for_list` for proper nesting
-///    - Preserves special caption formatting (lines starting with `*`)
-///    - Adds newlines for proper list item separation
-///
-/// 2. **Normal Context**:
-///    - Ensures proper spacing with double newlines around tables
-///    - Handles various output state scenarios (empty, ends with newline, etc.)
-///
-/// # Arguments
-/// * `node_handle` - The table node handle
-/// * `parser` - The HTML parser instance
-/// * `output` - The output string being built
-/// * `options` - Conversion options (includes list indent type)
-/// * `ctx` - Conversion context (includes list state)
-/// * `dom_ctx` - DOM context for tree structure info
-/// * `depth` - Current nesting depth
-pub fn handle_table_with_context(
-    node_handle: &tl::NodeHandle,
-    parser: &tl::Parser,
-    output: &mut String,
-    options: &crate::options::ConversionOptions,
-    ctx: &super::super::Context,
-    dom_ctx: &super::super::DomContext,
-    depth: usize,
-) {
-    let mut table_output = String::new();
-    builder::handle_table(node_handle, parser, &mut table_output, options, ctx, dom_ctx, depth);
-
-    // Feed the table into the structure collector when document structure extraction is enabled.
-    // Use push_table_data so that ConversionResult.tables is populated with both the grid and
-    // the markdown rendering that was just generated above.
-    if let Some(ref sc) = ctx.structure_collector {
-        if let Some(grid) = collect_table_grid(node_handle, parser, options, ctx, dom_ctx) {
-            sc.borrow_mut().push_table_data(grid, table_output.trim().to_string());
-        }
-    }
-
-    if ctx.in_list_item {
-        let has_caption = table_output.starts_with('*');
-
-        if !has_caption {
-            use crate::converter::main_helpers::trim_trailing_whitespace;
-            trim_trailing_whitespace(output);
-            if !output.is_empty() && !output.ends_with('\n') {
-                output.push('\n');
-            }
-        }
-
-        let indented = layout::indent_table_for_list(&table_output, ctx.list_depth, options);
-        output.push_str(&indented);
-    } else {
-        if !output.is_empty() && !output.ends_with("\n\n") {
-            if output.ends_with('\n') {
-                output.push('\n');
-            } else {
-                output.push_str("\n\n");
-            }
-        }
-        output.push_str(&table_output);
-    }
-
-    if !output.ends_with('\n') {
-        output.push('\n');
-    }
-}
-
-/// Collect a [`crate::types::TableGrid`] from the DOM for the structure collector.
-///
-/// Walks the table's rows and cells, extracting text content and span attributes
-/// to build a structured grid representation.
-fn collect_table_grid(
-    node_handle: &tl::NodeHandle,
-    parser: &tl::Parser,
-    options: &crate::options::ConversionOptions,
-    ctx: &super::super::Context,
-    dom_ctx: &super::super::DomContext,
-) -> Option<crate::types::TableGrid> {
-    use utils::{is_tag_name, normalized_tag_name};
-
-    let tl::Node::Tag(tag) = node_handle.get(parser)? else {
-        return None;
-    };
-
-    let mut grid_cells = Vec::new();
-    let mut row_index: u32 = 0;
-    let mut max_cols: u32 = 0;
-    let mut cell_handles = Vec::new();
-
-    let children = tag.children();
-    for child_handle in children.top().iter() {
-        if let Some(tl::Node::Tag(child_tag)) = child_handle.get(parser) {
-            let tag_name = normalized_tag_name(child_tag.name().as_utf8_str());
-            match tag_name.as_ref() {
-                "thead" | "tbody" | "tfoot" => {
-                    let is_header_section = tag_name.as_ref() == "thead";
-                    for row_handle in child_tag.children().top().iter() {
-                        if is_tag_name(row_handle, parser, dom_ctx, "tr") {
-                            collect_grid_row(
-                                row_handle,
-                                parser,
-                                options,
-                                ctx,
-                                dom_ctx,
-                                &mut cell_handles,
-                                &mut grid_cells,
-                                &mut row_index,
-                                &mut max_cols,
-                                is_header_section,
-                            );
-                        }
-                    }
-                }
-                "tr" | "row" => {
-                    let is_first = row_index == 0;
-                    collect_grid_row(
-                        child_handle,
-                        parser,
-                        options,
-                        ctx,
-                        dom_ctx,
-                        &mut cell_handles,
-                        &mut grid_cells,
-                        &mut row_index,
-                        &mut max_cols,
-                        is_first,
-                    );
-                }
-                _ => {}
-            }
-        }
-    }
-
-    if row_index == 0 {
-        return None;
-    }
-
-    Some(crate::types::TableGrid {
-        rows: row_index,
-        cols: max_cols,
-        cells: grid_cells,
-    })
-}
-
-/// Process a single table row for grid collection.
-#[allow(clippy::too_many_arguments)]
-fn collect_grid_row(
-    row_handle: &tl::NodeHandle,
-    parser: &tl::Parser,
-    options: &crate::options::ConversionOptions,
-    ctx: &super::super::Context,
-    dom_ctx: &super::super::DomContext,
-    cell_handles: &mut Vec<tl::NodeHandle>,
-    grid_cells: &mut Vec<crate::types::GridCell>,
-    row_index: &mut u32,
-    max_cols: &mut u32,
-    is_header_section: bool,
-) {
-    use cell::{collect_table_cells, get_colspan_rowspan};
-
-    collect_table_cells(row_handle, parser, dom_ctx, cell_handles);
-
-    let mut col_index: u32 = 0;
-    for cell_handle in cell_handles.iter() {
-        let is_header = is_header_section
-            || dom_ctx
-                .tag_name_for(*cell_handle, parser)
-                .is_some_and(|name| name.as_ref() == "th");
-
-        let mut text = String::new();
-        let cell_ctx = super::super::Context {
-            in_table_cell: true,
-            ..ctx.clone()
-        };
-        if let Some(tl::Node::Tag(cell_tag)) = cell_handle.get(parser) {
-            for child_handle in cell_tag.children().top().iter() {
-                super::super::walk_node(child_handle, parser, &mut text, options, &cell_ctx, 0, dom_ctx);
-            }
-        }
-        let content = crate::text::normalize_whitespace_cow(&text).trim().to_string();
-
-        let (colspan, rowspan) = get_colspan_rowspan(cell_handle, parser);
-
-        grid_cells.push(crate::types::GridCell {
-            content,
-            row: *row_index,
-            col: col_index,
-            row_span: rowspan as u32,
-            col_span: colspan as u32,
-            is_header,
-        });
-
-        col_index += colspan as u32;
-    }
-    if col_index > *max_cols {
-        *max_cols = col_index;
-    }
-    *row_index += 1;
-}

data/vendor/html-to-markdown-rs/src/converter/block/table/scanner.rs

@@ -1,146 +0,0 @@
-//! Table scanning and analysis utilities.
-//!
-//! Provides the TableScan struct and scanning functions for analyzing table structure
-//! to determine if it should be rendered as a Markdown table or converted to list format.
-
-use crate::converter::utility::content::normalized_tag_name;
-use std::borrow::Cow;
-
-/// Scan results for a table element.
-///
-/// Contains metadata about table structure to determine optimal rendering:
-/// - Row counts for consistency checking
-/// - Presence of headers, captions, and nested tables
-/// - Presence of colspan/rowspan (spanning cells)
-/// - Link and text content counts
-#[derive(Default)]
-pub struct TableScan {
-    /// Number of cells in each row
-    pub row_counts: Vec<usize>,
-    /// Whether any cells have colspan or rowspan attributes
-    pub has_span: bool,
-    /// Whether the table has header cells (th elements or role="head")
-    pub has_header: bool,
-    /// Whether the table has a caption element
-    pub has_caption: bool,
-    /// Number of nested tables found inside this table
-    pub nested_table_count: usize,
-    /// Count of anchor elements in the table
-    pub link_count: usize,
-    /// Whether the table contains text content (not empty)
-    pub has_text: bool,
-}
-
-/// Scan a table element for structural metadata.
-///
-/// Analyzes the table to determine characteristics that influence rendering:
-/// - Whether to render as a Markdown table or layout table
-/// - If spanning cells are present
-/// - If the table has semantic meaning (headers, captions)
-///
-/// # Arguments
-/// * `node_handle` - Handle to the table element
-/// * `parser` - HTML parser instance
-/// * `dom_ctx` - DOM context for tag name resolution
-#[allow(clippy::trivially_copy_pass_by_ref)]
-pub fn scan_table(
-    node_handle: &tl::NodeHandle,
-    parser: &tl::Parser,
-    dom_ctx: &super::super::super::DomContext,
-) -> TableScan {
-    let mut scan = TableScan::default();
-    scan_table_node(node_handle, parser, dom_ctx, true, &mut scan);
-    scan
-}
-
-/// Recursively scan table structure.
-///
-/// Internal recursive function that walks the table tree and collects metadata.
-///
-/// # Arguments
-/// * `node_handle` - Current node to scan
-/// * `parser` - HTML parser instance
-/// * `dom_ctx` - DOM context for tag name resolution
-/// * `is_root` - Whether this is the root table element
-/// * `scan` - Mutable scan results to accumulate
-#[allow(clippy::trivially_copy_pass_by_ref)]
-fn scan_table_node(
-    node_handle: &tl::NodeHandle,
-    parser: &tl::Parser,
-    dom_ctx: &super::super::super::DomContext,
-    is_root: bool,
-    scan: &mut TableScan,
-) {
-    if let Some(node) = node_handle.get(parser) {
-        match node {
-            tl::Node::Raw(bytes) => {
-                if !scan.has_text {
-                    let raw = bytes.as_utf8_str();
-                    let decoded = crate::text::decode_html_entities_cow(raw.as_ref());
-                    if !decoded.trim().is_empty() {
-                        scan.has_text = true;
-                    }
-                }
-            }
-            tl::Node::Tag(tag) => {
-                let tag_name: Cow<'_, str> = dom_ctx.tag_info(node_handle.get_inner(), parser).map_or_else(
-                    || normalized_tag_name(tag.name().as_utf8_str()).into_owned().into(),
-                    |info| Cow::Borrowed(info.name.as_str()),
-                );
-
-                match tag_name.as_ref() {
-                    "a" => scan.link_count += 1,
-                    "caption" => scan.has_caption = true,
-                    "th" => scan.has_header = true,
-                    "img" | "graphic" => {
-                        // Images with src or alt attributes count as content
-                        if tag.attributes().get("src").is_some() || tag.attributes().get("alt").is_some() {
-                            scan.has_text = true;
-                        }
-                    }
-                    "cell" => {
-                        // Check if cell has role="head" attribute
-                        if let Some(role) = tag.attributes().get("role") {
-                            if let Some(role_val) = role {
-                                let role_str = role_val.as_utf8_str();
-                                if role_str == "head" {
-                                    scan.has_header = true;
-                                }
-                            }
-                        }
-                    }
-                    "table" if !is_root => scan.nested_table_count += 1,
-                    "tr" | "row" => {
-                        let mut cell_count = 0;
-                        for child in tag.children().top().iter() {
-                            if let Some(tl::Node::Tag(cell_tag)) = child.get(parser) {
-                                let cell_name: Cow<'_, str> = dom_ctx
-                                    .tag_info(child.get_inner(), parser)
-                                    .map(|info| Cow::Borrowed(info.name.as_str()))
-                                    .unwrap_or_else(|| {
-                                        normalized_tag_name(cell_tag.name().as_utf8_str()).into_owned().into()
-                                    });
-                                if matches!(cell_name.as_ref(), "td" | "th" | "cell") {
-                                    cell_count += super::cell::get_colspan(child, parser);
-                                    let attrs = cell_tag.attributes();
-                                    if attrs.get("colspan").is_some() || attrs.get("rowspan").is_some() {
-                                        scan.has_span = true;
-                                    }
-                                }
-                            }
-                            scan_table_node(child, parser, dom_ctx, false, scan);
-                        }
-                        scan.row_counts.push(cell_count);
-                        return;
-                    }
-                    _ => {}
-                }
-
-                for child in tag.children().top().iter() {
-                    scan_table_node(child, parser, dom_ctx, false, scan);
-                }
-            }
-            _ => {}
-        }
-    }
-}

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

@@ -1,34 +0,0 @@
-//! Utility functions for table processing.
-//!
-//! Provides helper functions for tag name normalization and comparison.
-
-pub(super) use crate::converter::main_helpers::tag_name_eq;
-pub(super) use crate::converter::utility::content::normalized_tag_name;
-
-/// Check if a node has a specific tag name.
-///
-/// Handles both direct tag matching and DOM context-based tag resolution.
-///
-/// # Arguments
-/// * `node_handle` - Handle to the node
-/// * `parser` - HTML parser instance
-/// * `dom_ctx` - DOM context for tag name resolution
-/// * `name` - Expected tag name
-///
-/// # Returns
-/// True if node has the specified tag name
-#[allow(clippy::trivially_copy_pass_by_ref)]
-pub(super) fn is_tag_name(
-    node_handle: &tl::NodeHandle,
-    parser: &tl::Parser,
-    dom_ctx: &super::super::super::DomContext,
-    name: &str,
-) -> bool {
-    if let Some(info) = dom_ctx.tag_info(node_handle.get_inner(), parser) {
-        return info.name == name;
-    }
-    matches!(
-        node_handle.get(parser),
-        Some(tl::Node::Tag(tag)) if tag_name_eq(tag.name().as_utf8_str(), name)
-    )
-}

data/vendor/html-to-markdown-rs/src/converter/block/unknown.rs

@@ -1,138 +0,0 @@
-//! Handler for unknown/unspecified HTML elements.
-//!
-//! Processes HTML elements that don't have specific handlers by passing through
-//! their children while managing whitespace and content preservation:
-//! - Processes all child nodes recursively
-//! - Validates UTF-8 character boundaries when checking content
-//! - Preserves code blocks (indented or fenced) while removing empty content
-//! - Manages trailing whitespace intelligently
-
-use crate::options::ConversionOptions;
-use tl::{NodeHandle, Parser};
-
-// Type aliases for Context and DomContext to avoid circular imports
-type Context = crate::converter::Context;
-type DomContext = crate::converter::DomContext;
-
-/// Handles unknown/unspecified HTML elements.
-///
-/// For elements without specific handlers, this function:
-/// 1. Records the output position before processing children
-/// 2. Processes all children recursively
-/// 3. Checks if any content was added
-/// 4. Validates UTF-8 character boundaries for safe string slicing
-/// 5. Detects if added content is a code block (indented or fenced)
-/// 6. Removes empty content while preserving code blocks and spacing
-///
-/// # UTF-8 Safety
-/// The function carefully handles UTF-8 boundaries to prevent panic when
-/// slicing the output string. It finds the nearest valid boundary if the
-/// position falls in the middle of a multi-byte character.
-///
-/// # Code Block Detection
-/// Code blocks (identified by markdown formatting) are always preserved,
-/// even if they appear "empty" according to trim().
-#[cfg_attr(not(feature = "visitor"), allow(unused_variables))]
-pub fn handle(
-    node_handle: &NodeHandle,
-    parser: &Parser,
-    output: &mut String,
-    options: &ConversionOptions,
-    ctx: &Context,
-    depth: usize,
-    dom_ctx: &DomContext,
-) {
-    use crate::converter::walk_node;
-
-    let Some(node) = node_handle.get(parser) else { return };
-
-    let tag = match node {
-        tl::Node::Tag(tag) => tag,
-        _ => return,
-    };
-
-    #[cfg(feature = "visitor")]
-    if let Some(ref visitor_handle) = ctx.visitor {
-        use crate::converter::utility::content::collect_tag_attributes;
-        use crate::converter::utility::serialization::serialize_tag_to_html;
-        use crate::visitor::{NodeContext, NodeType, VisitResult};
-
-        let tag_name = tag.name().as_utf8_str().to_string();
-        let raw_html = serialize_tag_to_html(node_handle, parser);
-        let attributes = collect_tag_attributes(tag);
-        let node_id = node_handle.get_inner();
-        let parent_tag = dom_ctx.parent_tag_name(node_id, parser);
-        let index_in_parent = dom_ctx.get_sibling_index(node_id).unwrap_or(0);
-        let node_ctx = NodeContext {
-            node_type: NodeType::Custom,
-            tag_name: tag_name.clone(),
-            attributes,
-            depth,
-            index_in_parent,
-            parent_tag,
-            is_inline: false,
-        };
-        let visit_result = {
-            let mut visitor = visitor_handle.borrow_mut();
-            visitor.visit_custom_element(&node_ctx, &tag_name, &raw_html)
-        };
-        match visit_result {
-            VisitResult::Continue => {}
-            VisitResult::Skip => return,
-            VisitResult::Custom(custom) => {
-                output.push_str(&custom);
-                return;
-            }
-            VisitResult::PreserveHtml => {
-                output.push_str(&raw_html);
-                return;
-            }
-            VisitResult::Error(err) => {
-                if ctx.visitor_error.borrow().is_none() {
-                    *ctx.visitor_error.borrow_mut() = Some(err);
-                }
-                return;
-            }
-        }
-    }
-
-    let len_before = output.len();
-    let had_trailing_space = output.ends_with(' ');
-
-    let children = tag.children();
-    {
-        for child_handle in children.top().iter() {
-            walk_node(child_handle, parser, output, options, ctx, depth + 1, dom_ctx);
-        }
-    }
-
-    let len_after = output.len();
-    if len_after > len_before {
-        let start_idx = if output.is_char_boundary(len_before) {
-            len_before
-        } else {
-            // Find the nearest valid UTF-8 character boundary
-            let capped = len_before.min(output.len());
-            output
-                .char_indices()
-                .map(|(idx, _)| idx)
-                .take_while(|idx| *idx <= capped)
-                .last()
-                .unwrap_or(capped)
-        };
-
-        let added_content = output[start_idx..].to_string();
-
-        // Detect code blocks by markdown formatting
-        let is_code_block =
-            added_content.starts_with("    ") || added_content.starts_with("```") || added_content.starts_with("~~~");
-
-        // Remove empty content while preserving code blocks
-        if added_content.trim().is_empty() && !is_code_block {
-            output.truncate(start_idx);
-            if !had_trailing_space && added_content.contains(' ') {
-                output.push(' ');
-            }
-        }
-    }
-}