html-to-markdown 2.30.0 → 3.0.1

data/ext/html-to-markdown-rb/native/src/profiling.rs

@@ -1,215 +0,0 @@
-use html_to_markdown_rs::{ConversionError, Result};
-use std::path::PathBuf;
-
-#[cfg(all(not(target_os = "windows"), feature = "profiling"))]
-mod enabled {
-    use super::{ConversionError, PathBuf, Result};
-    use std::sync::atomic::{AtomicBool, Ordering};
-    use std::sync::{Mutex, OnceLock};
-
-    const ENV_OUTPUT: &str = "HTML_TO_MARKDOWN_PROFILE_OUTPUT";
-    const ENV_FREQUENCY: &str = "HTML_TO_MARKDOWN_PROFILE_FREQUENCY";
-    const ENV_ONCE: &str = "HTML_TO_MARKDOWN_PROFILE_ONCE";
-
-    static PROFILED_ONCE: AtomicBool = AtomicBool::new(false);
-    static PROFILE_ACTIVE: AtomicBool = AtomicBool::new(false);
-
-    struct EnvProfileConfig {
-        output: Option<PathBuf>,
-        profile_once: bool,
-        frequency: i32,
-    }
-
-    fn env_profile_config() -> &'static EnvProfileConfig {
-        static ENV_CONFIG: OnceLock<EnvProfileConfig> = OnceLock::new();
-        ENV_CONFIG.get_or_init(|| {
-            let output = match std::env::var(ENV_OUTPUT) {
-                Ok(value) if !value.trim().is_empty() => Some(PathBuf::from(value)),
-                _ => None,
-            };
-
-            let profile_once = match std::env::var(ENV_ONCE) {
-                Ok(value) => !matches!(value.as_str(), "0" | "false" | "no"),
-                Err(_) => true,
-            };
-
-            let frequency = std::env::var(ENV_FREQUENCY)
-                .ok()
-                .and_then(|value| value.parse::<i32>().ok())
-                .unwrap_or(1000);
-
-            EnvProfileConfig {
-                output,
-                profile_once,
-                frequency,
-            }
-        })
-    }
-
-    struct ProfileState {
-        guard: Option<pprof::ProfilerGuard<'static>>,
-        output: Option<PathBuf>,
-    }
-
-    fn state() -> &'static Mutex<ProfileState> {
-        static STATE: OnceLock<Mutex<ProfileState>> = OnceLock::new();
-        STATE.get_or_init(|| {
-            Mutex::new(ProfileState {
-                guard: None,
-                output: None,
-            })
-        })
-    }
-
-    pub fn start(output_path: PathBuf, frequency: i32) -> Result<()> {
-        let mut state = state()
-            .lock()
-            .map_err(|_| ConversionError::Other("profiling state lock poisoned".to_string()))?;
-
-        if state.guard.is_some() {
-            return Err(ConversionError::Other("profiling already active".to_string()));
-        }
-
-        let guard = pprof::ProfilerGuardBuilder::default()
-            .frequency(frequency)
-            .blocklist(&["libc", "libpthread", "libgcc", "libm"])
-            .build()
-            .map_err(|err| ConversionError::Other(format!("Profiling init failed: {err}")))?;
-
-        state.guard = Some(guard);
-        state.output = Some(output_path);
-        PROFILE_ACTIVE.store(true, Ordering::Release);
-        Ok(())
-    }
-
-    pub fn stop() -> Result<()> {
-        let (guard, output) = {
-            let mut state = state()
-                .lock()
-                .map_err(|_| ConversionError::Other("profiling state lock poisoned".to_string()))?;
-            let guard = state.guard.take();
-            let output = state.output.take();
-            (guard, output)
-        };
-        PROFILE_ACTIVE.store(false, Ordering::Release);
-
-        let Some(guard) = guard else {
-            return Err(ConversionError::Other("profiling not active".to_string()));
-        };
-        let Some(output_path) = output else {
-            return Err(ConversionError::Other("profiling output path missing".to_string()));
-        };
-
-        if let Some(parent) = output_path.parent() {
-            std::fs::create_dir_all(parent).map_err(ConversionError::IoError)?;
-        }
-
-        let report = guard
-            .report()
-            .build()
-            .map_err(|err| ConversionError::Other(format!("Profiling report failed: {err}")))?;
-
-        let file = std::fs::File::create(&output_path).map_err(ConversionError::IoError)?;
-        report
-            .flamegraph(file)
-            .map_err(|err| ConversionError::Other(format!("Flamegraph write failed: {err}")))?;
-        PROFILE_ACTIVE.store(false, Ordering::Release);
-        Ok(())
-    }
-
-    pub fn maybe_profile<T, F>(f: F) -> Result<T>
-    where
-        F: FnOnce() -> Result<T>,
-    {
-        if PROFILE_ACTIVE.load(Ordering::Relaxed) {
-            return f();
-        }
-
-        let config = env_profile_config();
-        let Some(output_path) = config.output.as_ref() else {
-            return f();
-        };
-
-        if config.profile_once && PROFILED_ONCE.swap(true, Ordering::SeqCst) {
-            return f();
-        }
-
-        struct ActiveGuard;
-        impl Drop for ActiveGuard {
-            fn drop(&mut self) {
-                PROFILE_ACTIVE.store(false, Ordering::Release);
-            }
-        }
-        PROFILE_ACTIVE.store(true, Ordering::Release);
-        let _active = ActiveGuard;
-
-        let guard = pprof::ProfilerGuardBuilder::default()
-            .frequency(config.frequency)
-            .blocklist(&["libc", "libpthread", "libgcc", "libm"])
-            .build()
-            .map_err(|err| ConversionError::Other(format!("Profiling init failed: {err}")))?;
-
-        let result = f();
-
-        if result.is_ok() {
-            if let Some(parent) = output_path.parent() {
-                std::fs::create_dir_all(parent).map_err(ConversionError::IoError)?;
-            }
-
-            let report = guard
-                .report()
-                .build()
-                .map_err(|err| ConversionError::Other(format!("Profiling report failed: {err}")))?;
-
-            let file = std::fs::File::create(output_path).map_err(ConversionError::IoError)?;
-            report
-                .flamegraph(file)
-                .map_err(|err| ConversionError::Other(format!("Flamegraph write failed: {err}")))?;
-        }
-
-        result
-    }
-}
-
-#[cfg(all(not(target_os = "windows"), feature = "profiling"))]
-pub use enabled::{maybe_profile, start, stop};
-
-#[cfg(target_os = "windows")]
-#[allow(dead_code)]
-pub fn start(_output_path: PathBuf, _frequency: i32) -> Result<()> {
-    Err(ConversionError::Other(
-        "Profiling is not supported on Windows".to_string(),
-    ))
-}
-
-#[cfg(all(not(target_os = "windows"), not(feature = "profiling")))]
-#[allow(dead_code)]
-pub fn start(_output_path: PathBuf, _frequency: i32) -> Result<()> {
-    Err(ConversionError::Other(
-        "Profiling is disabled; rebuild with the profiling feature".to_string(),
-    ))
-}
-
-#[cfg(target_os = "windows")]
-#[allow(dead_code)]
-pub fn stop() -> Result<()> {
-    Err(ConversionError::Other(
-        "Profiling is not supported on Windows".to_string(),
-    ))
-}
-
-#[cfg(all(not(target_os = "windows"), not(feature = "profiling")))]
-#[allow(dead_code)]
-pub fn stop() -> Result<()> {
-    Err(ConversionError::Other(
-        "Profiling is disabled; rebuild with the profiling feature".to_string(),
-    ))
-}
-
-#[cfg(any(target_os = "windows", not(feature = "profiling")))]
-pub fn maybe_profile<T, F>(f: F) -> Result<T>
-where
-    F: FnOnce() -> Result<T>,
-{
-    f()
-}

data/ext/html-to-markdown-rb/native/src/visitor/bridge.rs

@@ -1,252 +0,0 @@
-//! Ruby visitor wrapper and bridge utilities.
-
-use crate::types::{arg_error, symbol_to_string};
-use html_to_markdown_rs::visitor::{NodeContext, NodeType, VisitResult};
-use magnus::prelude::*;
-use magnus::{Error, RHash, Ruby, TryConvert, Value};
-
-/// Wrapper for a Ruby visitor object that implements the HtmlVisitor trait.
-#[derive(Clone)]
-pub struct RubyVisitorWrapper {
-    pub ruby_visitor: Value,
-    pub last_error: std::rc::Rc<std::cell::RefCell<Option<String>>>,
-}
-
-impl RubyVisitorWrapper {
-    pub fn new(ruby_visitor: Value) -> Self {
-        Self {
-            ruby_visitor,
-            last_error: std::rc::Rc::new(std::cell::RefCell::new(None)),
-        }
-    }
-
-    pub fn utf8_str(&self, ruby: &Ruby, s: &str) -> Value {
-        if let Ok(val) = ruby.eval::<Value>(&format!("String.new({s:?}, encoding: 'UTF-8')")) {
-            val
-        } else {
-            let str_val = ruby.str_from_slice(s.as_bytes());
-            str_val.as_value()
-        }
-    }
-
-    pub fn call_visitor_method(&self, method_name: &str, args: &[Value]) -> Result<VisitResult, Error> {
-        let ruby = Ruby::get().expect("Ruby not initialized");
-
-        let result: Value = match args.len() {
-            0 => match self.ruby_visitor.funcall::<&str, (), Value>(method_name, ()) {
-                Ok(val) => val,
-                Err(e) => {
-                    *self.last_error.borrow_mut() = Some(format!("Visitor error in {method_name}: {e}"));
-                    return Err(e);
-                }
-            },
-            1 => match self
-                .ruby_visitor
-                .funcall::<&str, (Value,), Value>(method_name, (args[0],))
-            {
-                Ok(val) => val,
-                Err(e) => {
-                    *self.last_error.borrow_mut() = Some(format!("Visitor error in {method_name}: {e}"));
-                    return Err(e);
-                }
-            },
-            2 => match self
-                .ruby_visitor
-                .funcall::<&str, (Value, Value), Value>(method_name, (args[0], args[1]))
-            {
-                Ok(val) => val,
-                Err(e) => {
-                    *self.last_error.borrow_mut() = Some(format!("Visitor error in {method_name}: {e}"));
-                    return Err(e);
-                }
-            },
-            3 => match self
-                .ruby_visitor
-                .funcall::<&str, (Value, Value, Value), Value>(method_name, (args[0], args[1], args[2]))
-            {
-                Ok(val) => val,
-                Err(e) => {
-                    *self.last_error.borrow_mut() = Some(format!("Visitor error in {method_name}: {e}"));
-                    return Err(e);
-                }
-            },
-            4 => match self
-                .ruby_visitor
-                .funcall::<&str, (Value, Value, Value, Value), Value>(method_name, (args[0], args[1], args[2], args[3]))
-            {
-                Ok(val) => val,
-                Err(e) => {
-                    *self.last_error.borrow_mut() = Some(format!("Visitor error in {method_name}: {e}"));
-                    return Err(e);
-                }
-            },
-            _ => {
-                return Err(arg_error(format!(
-                    "Unsupported number of visitor method arguments: {}",
-                    args.len()
-                )));
-            }
-        };
-
-        let hash = RHash::from_value(result)
-            .ok_or_else(|| arg_error(format!("visitor method {method_name} must return a Hash")))?;
-
-        let type_value: Value = hash
-            .get(ruby.intern("type"))
-            .ok_or_else(|| arg_error(format!("visitor method {method_name} result Hash must have :type key")))?;
-
-        let type_str = symbol_to_string(type_value)?;
-
-        match type_str.as_str() {
-            "continue" => Ok(VisitResult::Continue),
-            "custom" => {
-                let output_value: Value = hash.get(ruby.intern("output")).ok_or_else(|| {
-                    arg_error(format!(
-                        "visitor method {method_name} with type :custom must provide :output string"
-                    ))
-                })?;
-                let output = String::try_convert(output_value)?;
-                Ok(VisitResult::Custom(output))
-            }
-            "skip" => Ok(VisitResult::Skip),
-            "preserve_html" => Ok(VisitResult::PreserveHtml),
-            "error" => {
-                let message_value: Value = hash.get(ruby.intern("message")).ok_or_else(|| {
-                    arg_error(format!(
-                        "visitor method {method_name} with type :error must provide :message string"
-                    ))
-                })?;
-                let message = String::try_convert(message_value)?;
-                Ok(VisitResult::Error(message))
-            }
-            other => Err(arg_error(format!(
-                "visitor method {method_name} returned invalid type: {other}"
-            ))),
-        }
-    }
-
-    pub fn ruby_to_node_context(&self, ctx: &NodeContext, ruby: &Ruby) -> Result<Value, Error> {
-        let hash = ruby.hash_new();
-
-        let node_type_str = match ctx.node_type {
-            NodeType::Text => "text",
-            NodeType::Element => "element",
-            NodeType::Heading => "heading",
-            NodeType::Paragraph => "paragraph",
-            NodeType::Div => "div",
-            NodeType::Blockquote => "blockquote",
-            NodeType::Pre => "pre",
-            NodeType::Hr => "hr",
-            NodeType::List => "list",
-            NodeType::ListItem => "list_item",
-            NodeType::DefinitionList => "definition_list",
-            NodeType::DefinitionTerm => "definition_term",
-            NodeType::DefinitionDescription => "definition_description",
-            NodeType::Table => "table",
-            NodeType::TableRow => "table_row",
-            NodeType::TableCell => "table_cell",
-            NodeType::TableHeader => "table_header",
-            NodeType::TableBody => "table_body",
-            NodeType::TableHead => "table_head",
-            NodeType::TableFoot => "table_foot",
-            NodeType::Link => "link",
-            NodeType::Image => "image",
-            NodeType::Strong => "strong",
-            NodeType::Em => "em",
-            NodeType::Code => "code",
-            NodeType::Strikethrough => "strikethrough",
-            NodeType::Underline => "underline",
-            NodeType::Subscript => "subscript",
-            NodeType::Superscript => "superscript",
-            NodeType::Mark => "mark",
-            NodeType::Small => "small",
-            NodeType::Br => "br",
-            NodeType::Span => "span",
-            NodeType::Article => "article",
-            NodeType::Section => "section",
-            NodeType::Nav => "nav",
-            NodeType::Aside => "aside",
-            NodeType::Header => "header",
-            NodeType::Footer => "footer",
-            NodeType::Main => "main",
-            NodeType::Figure => "figure",
-            NodeType::Figcaption => "figcaption",
-            NodeType::Time => "time",
-            NodeType::Details => "details",
-            NodeType::Summary => "summary",
-            NodeType::Form => "form",
-            NodeType::Input => "input",
-            NodeType::Select => "select",
-            NodeType::Option => "option",
-            NodeType::Button => "button",
-            NodeType::Textarea => "textarea",
-            NodeType::Label => "label",
-            NodeType::Fieldset => "fieldset",
-            NodeType::Legend => "legend",
-            NodeType::Audio => "audio",
-            NodeType::Video => "video",
-            NodeType::Picture => "picture",
-            NodeType::Source => "source",
-            NodeType::Iframe => "iframe",
-            NodeType::Svg => "svg",
-            NodeType::Canvas => "canvas",
-            NodeType::Ruby => "ruby",
-            NodeType::Rt => "rt",
-            NodeType::Rp => "rp",
-            NodeType::Abbr => "abbr",
-            NodeType::Kbd => "kbd",
-            NodeType::Samp => "samp",
-            NodeType::Var => "var",
-            NodeType::Cite => "cite",
-            NodeType::Q => "q",
-            NodeType::Del => "del",
-            NodeType::Ins => "ins",
-            NodeType::Data => "data",
-            NodeType::Meter => "meter",
-            NodeType::Progress => "progress",
-            NodeType::Output => "output",
-            NodeType::Template => "template",
-            NodeType::Slot => "slot",
-            NodeType::Html => "html",
-            NodeType::Head => "head",
-            NodeType::Body => "body",
-            NodeType::Title => "title",
-            NodeType::Meta => "meta",
-            NodeType::LinkTag => "link_tag",
-            NodeType::Style => "style",
-            NodeType::Script => "script",
-            NodeType::Base => "base",
-            NodeType::Custom => "custom",
-        };
-        hash.aset(ruby.intern("node_type"), ruby.intern(node_type_str))?;
-
-        hash.aset(ruby.intern("tag_name"), ctx.tag_name.as_str())?;
-
-        let attrs_hash = ruby.hash_new();
-        for (key, value) in &ctx.attributes {
-            attrs_hash.aset(key.as_str(), value.as_str())?;
-        }
-        hash.aset(ruby.intern("attributes"), attrs_hash)?;
-
-        hash.aset(ruby.intern("depth"), ctx.depth as i64)?;
-
-        hash.aset(ruby.intern("index_in_parent"), ctx.index_in_parent as i64)?;
-
-        match &ctx.parent_tag {
-            Some(tag) => hash.aset(ruby.intern("parent_tag"), tag.as_str())?,
-            None => hash.aset(ruby.intern("parent_tag"), ruby.qnil())?,
-        }
-
-        hash.aset(ruby.intern("is_inline"), ctx.is_inline)?;
-
-        Ok(hash.as_value())
-    }
-}
-
-impl std::fmt::Debug for RubyVisitorWrapper {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("RubyVisitorWrapper")
-            .field("ruby_visitor", &self.ruby_visitor)
-            .finish()
-    }
-}