html-to-markdown 2.30.0 → 3.0.0

data/vendor/html-to-markdown-rs/src/visitor_helpers/helpers/callbacks/bridge_visitor.rs

@@ -1,343 +0,0 @@
-//! HtmlVisitor trait implementation for AsyncToSyncVisitorBridge.
-//!
-//! This module implements the sync `HtmlVisitor` trait for the async-to-sync bridge,
-//! translating each method call into a channel request/response pair.
-
-#[cfg(feature = "async-visitor")]
-use super::bridge::{AsyncToSyncVisitorBridge, VisitorRequest};
-
-#[cfg(feature = "async-visitor")]
-impl crate::visitor::HtmlVisitor for AsyncToSyncVisitorBridge {
-    fn visit_element_start(&mut self, ctx: &crate::visitor::NodeContext) -> crate::visitor::VisitResult {
-        if self.request_tx.send(VisitorRequest::ElementStart(ctx.clone())).is_err() {
-            return crate::visitor::VisitResult::Continue;
-        }
-        self.response_rx.recv().unwrap_or(crate::visitor::VisitResult::Continue)
-    }
-
-    fn visit_element_end(&mut self, ctx: &crate::visitor::NodeContext, output: &str) -> crate::visitor::VisitResult {
-        if self
-            .request_tx
-            .send(VisitorRequest::ElementEnd(ctx.clone(), output.to_string()))
-            .is_err()
-        {
-            return crate::visitor::VisitResult::Continue;
-        }
-        self.response_rx.recv().unwrap_or(crate::visitor::VisitResult::Continue)
-    }
-
-    fn visit_text(&mut self, ctx: &crate::visitor::NodeContext, text: &str) -> crate::visitor::VisitResult {
-        if self
-            .request_tx
-            .send(VisitorRequest::Text(ctx.clone(), text.to_string()))
-            .is_err()
-        {
-            return crate::visitor::VisitResult::Continue;
-        }
-        self.response_rx.recv().unwrap_or(crate::visitor::VisitResult::Continue)
-    }
-
-    fn visit_link(
-        &mut self,
-        ctx: &crate::visitor::NodeContext,
-        href: &str,
-        text: &str,
-        title: Option<&str>,
-    ) -> crate::visitor::VisitResult {
-        if self
-            .request_tx
-            .send(VisitorRequest::Link(
-                ctx.clone(),
-                href.to_string(),
-                text.to_string(),
-                title.map(std::string::ToString::to_string),
-            ))
-            .is_err()
-        {
-            return crate::visitor::VisitResult::Continue;
-        }
-        self.response_rx.recv().unwrap_or(crate::visitor::VisitResult::Continue)
-    }
-
-    fn visit_image(
-        &mut self,
-        ctx: &crate::visitor::NodeContext,
-        src: &str,
-        alt: &str,
-        title: Option<&str>,
-    ) -> crate::visitor::VisitResult {
-        if self
-            .request_tx
-            .send(VisitorRequest::Image(
-                ctx.clone(),
-                src.to_string(),
-                alt.to_string(),
-                title.map(std::string::ToString::to_string),
-            ))
-            .is_err()
-        {
-            return crate::visitor::VisitResult::Continue;
-        }
-        self.response_rx.recv().unwrap_or(crate::visitor::VisitResult::Continue)
-    }
-
-    fn visit_heading(
-        &mut self,
-        ctx: &crate::visitor::NodeContext,
-        level: u32,
-        text: &str,
-        id: Option<&str>,
-    ) -> crate::visitor::VisitResult {
-        if self
-            .request_tx
-            .send(VisitorRequest::Heading(
-                ctx.clone(),
-                level,
-                text.to_string(),
-                id.map(std::string::ToString::to_string),
-            ))
-            .is_err()
-        {
-            return crate::visitor::VisitResult::Continue;
-        }
-        self.response_rx.recv().unwrap_or(crate::visitor::VisitResult::Continue)
-    }
-
-    fn visit_code_block(
-        &mut self,
-        ctx: &crate::visitor::NodeContext,
-        language: Option<&str>,
-        code: &str,
-    ) -> crate::visitor::VisitResult {
-        if self
-            .request_tx
-            .send(VisitorRequest::CodeBlock(
-                ctx.clone(),
-                language.map(std::string::ToString::to_string),
-                code.to_string(),
-            ))
-            .is_err()
-        {
-            return crate::visitor::VisitResult::Continue;
-        }
-        self.response_rx.recv().unwrap_or(crate::visitor::VisitResult::Continue)
-    }
-
-    fn visit_code_inline(&mut self, ctx: &crate::visitor::NodeContext, code: &str) -> crate::visitor::VisitResult {
-        if self
-            .request_tx
-            .send(VisitorRequest::CodeInline(ctx.clone(), code.to_string()))
-            .is_err()
-        {
-            return crate::visitor::VisitResult::Continue;
-        }
-        self.response_rx.recv().unwrap_or(crate::visitor::VisitResult::Continue)
-    }
-
-    fn visit_list_item(
-        &mut self,
-        ctx: &crate::visitor::NodeContext,
-        ordered: bool,
-        marker: &str,
-        text: &str,
-    ) -> crate::visitor::VisitResult {
-        if self
-            .request_tx
-            .send(VisitorRequest::ListItem(
-                ctx.clone(),
-                ordered,
-                marker.to_string(),
-                text.to_string(),
-            ))
-            .is_err()
-        {
-            return crate::visitor::VisitResult::Continue;
-        }
-        self.response_rx.recv().unwrap_or(crate::visitor::VisitResult::Continue)
-    }
-
-    fn visit_list_start(&mut self, ctx: &crate::visitor::NodeContext, ordered: bool) -> crate::visitor::VisitResult {
-        if self
-            .request_tx
-            .send(VisitorRequest::ListStart(ctx.clone(), ordered))
-            .is_err()
-        {
-            return crate::visitor::VisitResult::Continue;
-        }
-        self.response_rx.recv().unwrap_or(crate::visitor::VisitResult::Continue)
-    }
-
-    fn visit_list_end(
-        &mut self,
-        ctx: &crate::visitor::NodeContext,
-        ordered: bool,
-        output: &str,
-    ) -> crate::visitor::VisitResult {
-        if self
-            .request_tx
-            .send(VisitorRequest::ListEnd(ctx.clone(), ordered, output.to_string()))
-            .is_err()
-        {
-            return crate::visitor::VisitResult::Continue;
-        }
-        self.response_rx.recv().unwrap_or(crate::visitor::VisitResult::Continue)
-    }
-
-    fn visit_table_start(&mut self, ctx: &crate::visitor::NodeContext) -> crate::visitor::VisitResult {
-        if self.request_tx.send(VisitorRequest::TableStart(ctx.clone())).is_err() {
-            return crate::visitor::VisitResult::Continue;
-        }
-        self.response_rx.recv().unwrap_or(crate::visitor::VisitResult::Continue)
-    }
-
-    fn visit_table_row(
-        &mut self,
-        ctx: &crate::visitor::NodeContext,
-        cells: &[String],
-        is_header: bool,
-    ) -> crate::visitor::VisitResult {
-        if self
-            .request_tx
-            .send(VisitorRequest::TableRow(ctx.clone(), cells.to_vec(), is_header))
-            .is_err()
-        {
-            return crate::visitor::VisitResult::Continue;
-        }
-        self.response_rx.recv().unwrap_or(crate::visitor::VisitResult::Continue)
-    }
-
-    fn visit_table_end(&mut self, ctx: &crate::visitor::NodeContext, output: &str) -> crate::visitor::VisitResult {
-        if self
-            .request_tx
-            .send(VisitorRequest::TableEnd(ctx.clone(), output.to_string()))
-            .is_err()
-        {
-            return crate::visitor::VisitResult::Continue;
-        }
-        self.response_rx.recv().unwrap_or(crate::visitor::VisitResult::Continue)
-    }
-
-    fn visit_blockquote(
-        &mut self,
-        ctx: &crate::visitor::NodeContext,
-        content: &str,
-        depth: usize,
-    ) -> crate::visitor::VisitResult {
-        if self
-            .request_tx
-            .send(VisitorRequest::Blockquote(ctx.clone(), content.to_string(), depth))
-            .is_err()
-        {
-            return crate::visitor::VisitResult::Continue;
-        }
-        self.response_rx.recv().unwrap_or(crate::visitor::VisitResult::Continue)
-    }
-
-    fn visit_strong(&mut self, ctx: &crate::visitor::NodeContext, text: &str) -> crate::visitor::VisitResult {
-        if self
-            .request_tx
-            .send(VisitorRequest::Strong(ctx.clone(), text.to_string()))
-            .is_err()
-        {
-            return crate::visitor::VisitResult::Continue;
-        }
-        self.response_rx.recv().unwrap_or(crate::visitor::VisitResult::Continue)
-    }
-
-    fn visit_emphasis(&mut self, ctx: &crate::visitor::NodeContext, text: &str) -> crate::visitor::VisitResult {
-        if self
-            .request_tx
-            .send(VisitorRequest::Emphasis(ctx.clone(), text.to_string()))
-            .is_err()
-        {
-            return crate::visitor::VisitResult::Continue;
-        }
-        self.response_rx.recv().unwrap_or(crate::visitor::VisitResult::Continue)
-    }
-
-    fn visit_strikethrough(&mut self, ctx: &crate::visitor::NodeContext, text: &str) -> crate::visitor::VisitResult {
-        if self
-            .request_tx
-            .send(VisitorRequest::Strikethrough(ctx.clone(), text.to_string()))
-            .is_err()
-        {
-            return crate::visitor::VisitResult::Continue;
-        }
-        self.response_rx.recv().unwrap_or(crate::visitor::VisitResult::Continue)
-    }
-
-    fn visit_underline(&mut self, ctx: &crate::visitor::NodeContext, text: &str) -> crate::visitor::VisitResult {
-        if self
-            .request_tx
-            .send(VisitorRequest::Underline(ctx.clone(), text.to_string()))
-            .is_err()
-        {
-            return crate::visitor::VisitResult::Continue;
-        }
-        self.response_rx.recv().unwrap_or(crate::visitor::VisitResult::Continue)
-    }
-
-    fn visit_subscript(&mut self, ctx: &crate::visitor::NodeContext, text: &str) -> crate::visitor::VisitResult {
-        if self
-            .request_tx
-            .send(VisitorRequest::Subscript(ctx.clone(), text.to_string()))
-            .is_err()
-        {
-            return crate::visitor::VisitResult::Continue;
-        }
-        self.response_rx.recv().unwrap_or(crate::visitor::VisitResult::Continue)
-    }
-
-    fn visit_superscript(&mut self, ctx: &crate::visitor::NodeContext, text: &str) -> crate::visitor::VisitResult {
-        if self
-            .request_tx
-            .send(VisitorRequest::Superscript(ctx.clone(), text.to_string()))
-            .is_err()
-        {
-            return crate::visitor::VisitResult::Continue;
-        }
-        self.response_rx.recv().unwrap_or(crate::visitor::VisitResult::Continue)
-    }
-
-    fn visit_mark(&mut self, ctx: &crate::visitor::NodeContext, text: &str) -> crate::visitor::VisitResult {
-        if self
-            .request_tx
-            .send(VisitorRequest::Mark(ctx.clone(), text.to_string()))
-            .is_err()
-        {
-            return crate::visitor::VisitResult::Continue;
-        }
-        self.response_rx.recv().unwrap_or(crate::visitor::VisitResult::Continue)
-    }
-
-    fn visit_horizontal_rule(&mut self, ctx: &crate::visitor::NodeContext) -> crate::visitor::VisitResult {
-        if self
-            .request_tx
-            .send(VisitorRequest::HorizontalRule(ctx.clone()))
-            .is_err()
-        {
-            return crate::visitor::VisitResult::Continue;
-        }
-        self.response_rx.recv().unwrap_or(crate::visitor::VisitResult::Continue)
-    }
-
-    fn visit_custom_element(
-        &mut self,
-        ctx: &crate::visitor::NodeContext,
-        tag_name: &str,
-        html: &str,
-    ) -> crate::visitor::VisitResult {
-        if self
-            .request_tx
-            .send(VisitorRequest::CustomElement(
-                ctx.clone(),
-                tag_name.to_string(),
-                html.to_string(),
-            ))
-            .is_err()
-        {
-            return crate::visitor::VisitResult::Continue;
-        }
-        self.response_rx.recv().unwrap_or(crate::visitor::VisitResult::Continue)
-    }
-}

data/vendor/html-to-markdown-rs/src/visitor_helpers/helpers/callbacks/macros.rs

@@ -1,217 +0,0 @@
-//! Async visitor dispatch function and helper macros.
-//!
-//! This module provides:
-//! - `dispatch_async_visitor` function for async visitor callback dispatch
-//! - `try_async_visitor!` macro for common visitor patterns
-//! - `try_async_visitor_element_start!` macro for element start callbacks
-//! - `try_async_visitor_element_end!` macro for element end callbacks
-
-#[cfg(feature = "async-visitor")]
-use super::super::content::VisitorDispatch;
-#[cfg(feature = "async-visitor")]
-use super::AsyncVisitorHandle;
-#[cfg(feature = "async-visitor")]
-use crate::error::{ConversionError, Result};
-#[cfg(feature = "async-visitor")]
-use crate::visitor::AsyncHtmlVisitor;
-
-/// Dispatch an async visitor callback and handle the result.
-///
-/// This is the async version of `dispatch_visitor`, supporting async visitor implementations.
-/// It safely handles the optional visitor, calls the callback function, and translates the
-/// `VisitResult` into concrete control flow decisions.
-///
-/// # Type Parameters
-///
-/// - `F`: Async visitor callback function type
-///
-/// # Parameters
-///
-/// - `visitor`: Optional async visitor (wrapped in Rc<`RefCell`<>>)
-/// - `callback`: Async closure that invokes the appropriate async visitor method
-///
-/// # Returns
-///
-/// - `Ok(VisitorDispatch::Custom(String))`: Custom markdown output from `VisitResult::Custom`
-/// - `Ok(VisitorDispatch::Continue)`: Continue with default behavior (`VisitResult::Continue`)
-/// - `Err(ConversionError)`: Stop conversion with error (`VisitResult::Error`)
-///
-/// # Errors
-///
-/// - If the visitor returns `VisitResult::Error`, this is converted to `Error::Visitor`
-/// - `RefCell` borrow failures panic (should never happen with correct usage)
-///
-/// # Performance
-///
-/// - Zero-cost when visitor is None (common case)
-/// - Single dynamic dispatch when visitor is present
-/// - No allocations except for error messages
-///
-/// # Examples
-///
-/// ```ignore
-/// let result = dispatch_async_visitor(
-///     &visitor,
-///     |v| Box::pin(v.visit_heading(&ctx, level, text, id)),
-/// ).await?;
-///
-/// match result {
-///     VisitorDispatch::Custom(output) => return Ok(output),
-///     VisitorDispatch::Continue => { /* proceed with default conversion */ }
-///     _ => {}
-/// }
-/// ```
-#[cfg(feature = "async-visitor")]
-#[allow(dead_code, clippy::future_not_send)]
-#[inline]
-pub async fn dispatch_async_visitor<F, Fut>(
-    visitor: &Option<AsyncVisitorHandle>,
-    callback: F,
-) -> Result<VisitorDispatch>
-where
-    F: FnOnce(&mut dyn AsyncHtmlVisitor) -> Fut,
-    Fut: std::future::Future<Output = crate::visitor::VisitResult>,
-{
-    let Some(visitor_mutex) = visitor else {
-        return Ok(VisitorDispatch::Continue);
-    };
-
-    let future = {
-        let mut visitor_ref = visitor_mutex.lock().await;
-        callback(&mut *visitor_ref)
-    };
-
-    let result = future.await;
-
-    match result {
-        crate::visitor::VisitResult::Continue => Ok(VisitorDispatch::Continue),
-        crate::visitor::VisitResult::Custom(output) => Ok(VisitorDispatch::Custom(output)),
-        crate::visitor::VisitResult::Skip => Ok(VisitorDispatch::Skip),
-        crate::visitor::VisitResult::PreserveHtml => Ok(VisitorDispatch::PreserveHtml),
-        crate::visitor::VisitResult::Error(msg) => Err(ConversionError::Visitor(msg)),
-    }
-}
-
-/// Macro to reduce boilerplate when calling async visitor methods.
-///
-/// This macro wraps the common pattern of:
-/// 1. Check if visitor is present
-/// 2. Call async visitor method (awaiting the result)
-/// 3. Handle early return for Custom/Skip/PreserveHtml/Error
-/// 4. Continue with default behavior if visitor returns Continue
-///
-/// # Syntax
-///
-/// ```ignore
-/// try_async_visitor!(visitor_option, method_name, ctx, arg1, arg2, ...).await?;
-/// ```
-///
-/// # Returns
-///
-/// - Returns early with custom output if visitor returns Custom/Skip/PreserveHtml
-/// - Returns early with Err if visitor returns Error
-/// - Continues execution if visitor returns Continue or is None
-///
-/// # Examples
-///
-/// ```ignore
-/// // Before (verbose):
-/// let dispatch = dispatch_async_visitor(&visitor, |v| {
-///     Box::pin(v.visit_heading(&ctx, level, text, id))
-/// }).await?;
-/// match dispatch {
-///     VisitorDispatch::Custom(output) => return Ok(output),
-///     VisitorDispatch::Skip => return Ok(String::new()),
-///     VisitorDispatch::PreserveHtml => return Ok(preserve_html_output),
-///     VisitorDispatch::Continue => { /* proceed */ }
-/// }
-///
-/// // After (concise):
-/// try_async_visitor!(visitor, visit_heading, &ctx, level, text, id).await?;
-/// // Default conversion logic continues here...
-/// ```
-#[cfg(feature = "async-visitor")]
-#[macro_export]
-macro_rules! try_async_visitor {
-    ($visitor:expr, $method:ident, $ctx:expr $(, $arg:expr)*) => {{
-        let dispatch = $crate::visitor_helpers::dispatch_async_visitor(
-            $visitor,
-            |v| Box::pin(v.$method($ctx $(, $arg)*)),
-        ).await?;
-
-        match dispatch {
-            $crate::visitor_helpers::VisitorDispatch::Continue => {
-            }
-            $crate::visitor_helpers::VisitorDispatch::Custom(output) => {
-                return Ok(output);
-            }
-            $crate::visitor_helpers::VisitorDispatch::Skip => {
-                return Ok(String::new());
-            }
-            $crate::visitor_helpers::VisitorDispatch::PreserveHtml => {
-                // TODO: Implement HTML preservation logic
-            }
-        }
-    }};
-}
-
-/// Convenience macro for async `element_start` visitor calls with early return.
-///
-/// This is the async version of `try_visitor_element_start!` macro.
-/// It handles the common pattern of calling `visit_element_start` at the beginning
-/// of element processing.
-///
-/// # Syntax
-///
-/// ```ignore
-/// try_async_visitor_element_start!(visitor_option, ctx).await?;
-/// ```
-///
-/// # Examples
-///
-/// ```ignore
-/// async fn process_heading(...) -> Result<String> {
-///     let ctx = build_node_context(...);
-///     try_async_visitor_element_start!(visitor, &ctx).await?;
-///
-///     // Default heading processing continues here...
-/// }
-/// ```
-#[cfg(feature = "async-visitor")]
-#[macro_export]
-macro_rules! try_async_visitor_element_start {
-    ($visitor:expr, $ctx:expr) => {{
-        $crate::try_async_visitor!($visitor, visit_element_start, $ctx);
-    }};
-}
-
-/// Convenience macro for async `element_end` visitor calls with output inspection.
-///
-/// This is the async version of `try_visitor_element_end!` macro.
-/// It handles the common pattern of calling `visit_element_end` after generating
-/// default markdown output.
-///
-/// # Syntax
-///
-/// ```ignore
-/// try_async_visitor_element_end!(visitor_option, ctx, default_output_string).await?;
-/// ```
-///
-/// # Examples
-///
-/// ```ignore
-/// async fn process_heading(...) -> Result<String> {
-///     let ctx = build_node_context(...);
-///     let mut output = String::from("# Heading");
-///
-///     try_async_visitor_element_end!(visitor, &ctx, &output).await?;
-///     Ok(output)
-/// }
-/// ```
-#[cfg(feature = "async-visitor")]
-#[macro_export]
-macro_rules! try_async_visitor_element_end {
-    ($visitor:expr, $ctx:expr, $output:expr) => {{
-        $crate::try_async_visitor!($visitor, visit_element_end, $ctx, $output);
-    }};
-}

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

@@ -1,57 +0,0 @@
-//! Integration tests for async visitor functionality
-//! Tests that async visitors work correctly with `current_thread` runtime
-
-#![cfg(feature = "async-visitor")]
-
-use async_trait::async_trait;
-use html_to_markdown_rs::visitor::{AsyncHtmlVisitor, NodeContext, VisitResult};
-use std::cell::RefCell;
-use std::rc::Rc;
-
-#[derive(Debug)]
-struct CustomOutputVisitor;
-
-#[async_trait]
-impl AsyncHtmlVisitor for CustomOutputVisitor {
-    async fn visit_heading(&mut self, _ctx: &NodeContext, level: u32, text: &str, _id: Option<&str>) -> VisitResult {
-        // Return custom output for headings
-        VisitResult::Custom(format!("[HEADING-{level}] {text}\n\n"))
-    }
-
-    async fn visit_text(&mut self, _ctx: &NodeContext, _text: &str) -> VisitResult {
-        VisitResult::Continue
-    }
-}
-
-// Manual test function for current_thread runtime
-// Note: We don't use #[tokio::test] here because it requires the macros feature
-// Instead, this test demonstrates that the code compiles and can be called
-#[test]
-fn test_async_visitor_signature_compatibility() {
-    // This test verifies that the AsyncToSyncVisitorBridge properly compiles
-    // and can wrap async visitors for use in sync contexts.
-    // The actual functionality is tested in integration tests or manually.
-
-    // Create a visitor
-    let visitor = CustomOutputVisitor;
-    let _visitor_handle: Rc<RefCell<dyn AsyncHtmlVisitor>> = Rc::new(RefCell::new(visitor));
-
-    // This test just verifies compilation
-}
-
-#[derive(Debug)]
-struct SkipImagesVisitor;
-
-#[async_trait]
-impl AsyncHtmlVisitor for SkipImagesVisitor {
-    async fn visit_image(&mut self, _ctx: &NodeContext, _src: &str, _alt: &str, _title: Option<&str>) -> VisitResult {
-        VisitResult::Skip
-    }
-}
-
-#[test]
-fn test_skip_images_visitor_compiles() {
-    // Verify the SkipImagesVisitor compiles correctly
-    let visitor = SkipImagesVisitor;
-    let _visitor_handle: Rc<RefCell<dyn AsyncHtmlVisitor>> = Rc::new(RefCell::new(visitor));
-}