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

data/vendor/html-to-markdown-rs/src/options/preprocessing.rs

@@ -1,201 +0,0 @@
-#![allow(clippy::cast_precision_loss, clippy::cast_sign_loss, clippy::unused_self)]
-
-//! HTML preprocessing configuration options.
-//!
-//! This module provides configuration for document cleanup before conversion,
-//! including preset levels and granular control over element removal.
-
-use crate::options::validation::normalize_token;
-
-/// HTML preprocessing aggressiveness level.
-///
-/// Controls the extent of cleanup performed before conversion. Higher levels remove more elements.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
-pub enum PreprocessingPreset {
-    /// Minimal cleanup. Remove only essential noise (scripts, styles).
-    Minimal,
-    /// Standard cleanup. Default. Removes navigation, forms, and other auxiliary content.
-    #[default]
-    Standard,
-    /// Aggressive cleanup. Remove extensive non-content elements and structure.
-    Aggressive,
-}
-
-impl PreprocessingPreset {
-    /// Parse a preprocessing preset from a string.
-    ///
-    /// Accepts "minimal", "aggressive", or defaults to Standard.
-    /// Input is normalized (lowercased, alphanumeric only).
-    #[must_use]
-    pub fn parse(value: &str) -> Self {
-        match normalize_token(value).as_str() {
-            "minimal" => Self::Minimal,
-            "aggressive" => Self::Aggressive,
-            _ => Self::Standard,
-        }
-    }
-}
-
-/// HTML preprocessing options for document cleanup before conversion.
-#[derive(Debug, Clone)]
-#[cfg_attr(
-    any(feature = "serde", feature = "metadata"),
-    derive(serde::Serialize, serde::Deserialize)
-)]
-#[cfg_attr(any(feature = "serde", feature = "metadata"), serde(default, deny_unknown_fields))]
-pub struct PreprocessingOptions {
-    /// Enable HTML preprocessing globally
-    pub enabled: bool,
-
-    /// Preprocessing preset level (Minimal, Standard, Aggressive)
-    pub preset: PreprocessingPreset,
-
-    /// Remove navigation elements (nav, breadcrumbs, menus, sidebars)
-    pub remove_navigation: bool,
-
-    /// Remove form elements (forms, inputs, buttons, etc.)
-    pub remove_forms: bool,
-}
-
-/// Partial update for `PreprocessingOptions`.
-///
-/// This struct uses `Option<T>` to represent optional fields that can be selectively updated.
-/// Only specified fields (Some values) will override existing options; None values leave the
-/// corresponding fields unchanged when applied via [`PreprocessingOptions::apply_update`].
-#[derive(Debug, Clone, Default)]
-#[cfg_attr(
-    any(feature = "serde", feature = "metadata"),
-    derive(serde::Serialize, serde::Deserialize)
-)]
-#[cfg_attr(any(feature = "serde", feature = "metadata"), serde(deny_unknown_fields))]
-pub struct PreprocessingOptionsUpdate {
-    /// Optional global preprocessing enablement override
-    pub enabled: Option<bool>,
-
-    /// Optional preprocessing preset level override (Minimal, Standard, Aggressive)
-    pub preset: Option<PreprocessingPreset>,
-
-    /// Optional navigation element removal override (nav, breadcrumbs, menus, sidebars)
-    pub remove_navigation: Option<bool>,
-
-    /// Optional form element removal override (forms, inputs, buttons, etc.)
-    pub remove_forms: Option<bool>,
-}
-
-impl Default for PreprocessingOptions {
-    fn default() -> Self {
-        Self {
-            enabled: true,
-            preset: PreprocessingPreset::default(),
-            remove_navigation: true,
-            remove_forms: true,
-        }
-    }
-}
-
-impl PreprocessingOptions {
-    /// Apply a partial update to these preprocessing options.
-    ///
-    /// Any specified fields in the update will override the current values.
-    /// Unspecified fields (None) are left unchanged.
-    ///
-    /// # Arguments
-    ///
-    /// * `update` - Partial preprocessing options update
-    #[allow(clippy::needless_pass_by_value)]
-    pub const fn apply_update(&mut self, update: PreprocessingOptionsUpdate) {
-        if let Some(enabled) = update.enabled {
-            self.enabled = enabled;
-        }
-        if let Some(preset) = update.preset {
-            self.preset = preset;
-        }
-        if let Some(remove_navigation) = update.remove_navigation {
-            self.remove_navigation = remove_navigation;
-        }
-        if let Some(remove_forms) = update.remove_forms {
-            self.remove_forms = remove_forms;
-        }
-    }
-
-    /// Create new preprocessing options from a partial update.
-    ///
-    /// Creates a new `PreprocessingOptions` struct with defaults, then applies the update.
-    /// Fields not specified in the update keep their default values.
-    ///
-    /// # Arguments
-    ///
-    /// * `update` - Partial preprocessing options update
-    ///
-    /// # Returns
-    ///
-    /// New `PreprocessingOptions` with specified updates applied to defaults
-    #[must_use]
-    pub fn from_update(update: PreprocessingOptionsUpdate) -> Self {
-        let mut options = Self::default();
-        options.apply_update(update);
-        options
-    }
-}
-
-impl From<PreprocessingOptionsUpdate> for PreprocessingOptions {
-    fn from(update: PreprocessingOptionsUpdate) -> Self {
-        Self::from_update(update)
-    }
-}
-
-#[cfg(any(feature = "serde", feature = "metadata"))]
-mod serde_impls {
-    use super::PreprocessingPreset;
-    use serde::{Deserialize, Serializer};
-
-    impl<'de> Deserialize<'de> for PreprocessingPreset {
-        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-        where
-            D: serde::Deserializer<'de>,
-        {
-            let value = String::deserialize(deserializer)?;
-            Ok(Self::parse(&value))
-        }
-    }
-
-    impl serde::Serialize for PreprocessingPreset {
-        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        where
-            S: Serializer,
-        {
-            let s = match self {
-                Self::Minimal => "minimal",
-                Self::Standard => "standard",
-                Self::Aggressive => "aggressive",
-            };
-            serializer.serialize_str(s)
-        }
-    }
-}
-
-#[cfg(all(test, any(feature = "serde", feature = "metadata")))]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_preprocessing_options_serde() {
-        let options = PreprocessingOptions {
-            enabled: true,
-            preset: PreprocessingPreset::Aggressive,
-            remove_navigation: false,
-            ..Default::default()
-        };
-
-        // Serialize to JSON
-        let json = serde_json::to_string(&options).expect("Failed to serialize");
-
-        // Deserialize back
-        let deserialized: PreprocessingOptions = serde_json::from_str(&json).expect("Failed to deserialize");
-
-        // Verify values
-        assert!(deserialized.enabled);
-        assert_eq!(deserialized.preset, PreprocessingPreset::Aggressive);
-        assert!(!deserialized.remove_navigation);
-    }
-}

data/vendor/html-to-markdown-rs/src/options/validation.rs

@@ -1,416 +0,0 @@
-//! Validation and parsing utilities for option enums.
-//!
-//! This module provides parsing and serialization logic for configuration
-//! enums (HeadingStyle, ListIndentType, etc.) with string conversion support.
-
-/// Heading style options for Markdown output.
-///
-/// Controls how headings (h1-h6) are rendered in the output Markdown.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
-pub enum HeadingStyle {
-    /// Underlined style (=== for h1, --- for h2).
-    Underlined,
-    /// ATX style (# for h1, ## for h2, etc.). Default.
-    #[default]
-    Atx,
-    /// ATX closed style (# title #, with closing hashes).
-    AtxClosed,
-}
-
-impl HeadingStyle {
-    /// Parse a heading style from a string.
-    ///
-    /// Accepts "atx", "atxclosed", or defaults to Underlined.
-    /// Input is normalized (lowercased, alphanumeric only).
-    #[must_use]
-    pub fn parse(value: &str) -> Self {
-        match normalize_token(value).as_str() {
-            "atx" => Self::Atx,
-            "atxclosed" => Self::AtxClosed,
-            _ => Self::Underlined,
-        }
-    }
-}
-
-/// List indentation character type.
-///
-/// Controls whether list items are indented with spaces or tabs.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
-pub enum ListIndentType {
-    /// Use spaces for indentation. Default. Width controlled by `list_indent_width`.
-    #[default]
-    Spaces,
-    /// Use tabs for indentation.
-    Tabs,
-}
-
-impl ListIndentType {
-    /// Parse a list indentation type from a string.
-    ///
-    /// Accepts "tabs" or defaults to Spaces.
-    /// Input is normalized (lowercased, alphanumeric only).
-    #[must_use]
-    pub fn parse(value: &str) -> Self {
-        match normalize_token(value).as_str() {
-            "tabs" => Self::Tabs,
-            _ => Self::Spaces,
-        }
-    }
-}
-
-/// Whitespace handling strategy during conversion.
-///
-/// Determines how sequences of whitespace characters (spaces, tabs, newlines) are processed.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
-pub enum WhitespaceMode {
-    /// Collapse multiple whitespace characters to single spaces. Default. Matches browser behavior.
-    #[default]
-    Normalized,
-    /// Preserve all whitespace exactly as it appears in the HTML.
-    Strict,
-}
-
-impl WhitespaceMode {
-    /// Parse a whitespace mode from a string.
-    ///
-    /// Accepts "strict" or defaults to Normalized.
-    /// Input is normalized (lowercased, alphanumeric only).
-    #[must_use]
-    pub fn parse(value: &str) -> Self {
-        match normalize_token(value).as_str() {
-            "strict" => Self::Strict,
-            _ => Self::Normalized,
-        }
-    }
-}
-
-/// Line break syntax in Markdown output.
-///
-/// Controls how soft line breaks (from `<br>` or line breaks in source) are rendered.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
-pub enum NewlineStyle {
-    /// Two trailing spaces at end of line. Default. Standard Markdown syntax.
-    #[default]
-    Spaces,
-    /// Backslash at end of line. Alternative Markdown syntax.
-    Backslash,
-}
-
-impl NewlineStyle {
-    /// Parse a newline style from a string.
-    ///
-    /// Accepts "backslash" or defaults to Spaces.
-    /// Input is normalized (lowercased, alphanumeric only).
-    #[must_use]
-    pub fn parse(value: &str) -> Self {
-        match normalize_token(value).as_str() {
-            "backslash" => Self::Backslash,
-            _ => Self::Spaces,
-        }
-    }
-}
-
-/// Code block fence style in Markdown output.
-///
-/// Determines how code blocks (`<pre><code>`) are rendered in Markdown.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
-pub enum CodeBlockStyle {
-    /// Indented code blocks (4 spaces). `CommonMark` standard.
-    Indented,
-    /// Fenced code blocks with backticks (```). Default (GFM). Supports language hints.
-    #[default]
-    Backticks,
-    /// Fenced code blocks with tildes (~~~). Supports language hints.
-    Tildes,
-}
-
-impl CodeBlockStyle {
-    /// Parse a code block style from a string.
-    ///
-    /// Accepts "backticks", "tildes", or defaults to Indented.
-    /// Input is normalized (lowercased, alphanumeric only).
-    #[must_use]
-    pub fn parse(value: &str) -> Self {
-        match normalize_token(value).as_str() {
-            "backticks" => Self::Backticks,
-            "tildes" => Self::Tildes,
-            _ => Self::Indented,
-        }
-    }
-}
-
-/// Highlight rendering style for `<mark>` elements.
-///
-/// Controls how highlighted text is rendered in Markdown output.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
-pub enum HighlightStyle {
-    /// Double equals syntax (==text==). Default. Pandoc-compatible.
-    #[default]
-    DoubleEqual,
-    /// Preserve as HTML (==text==). Original HTML tag.
-    Html,
-    /// Render as bold (**text**). Uses strong emphasis.
-    Bold,
-    /// Strip formatting, render as plain text. No markup.
-    None,
-}
-
-impl HighlightStyle {
-    /// Parse a highlight style from a string.
-    ///
-    /// Accepts "doubleequal", "html", "bold", "none", or defaults to None.
-    /// Input is normalized (lowercased, alphanumeric only).
-    #[must_use]
-    pub fn parse(value: &str) -> Self {
-        match normalize_token(value).as_str() {
-            "doubleequal" => Self::DoubleEqual,
-            "html" => Self::Html,
-            "bold" => Self::Bold,
-            "none" => Self::None,
-            _ => Self::None,
-        }
-    }
-}
-
-/// Link rendering style in Markdown output.
-///
-/// Controls whether links and images use inline `[text](url)` syntax or
-/// reference-style `[text][1]` syntax with definitions collected at the end.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
-pub enum LinkStyle {
-    /// Inline links: `[text](url)`. Default.
-    #[default]
-    Inline,
-    /// Reference-style links: `[text][1]` with `[1]: url` at end of document.
-    Reference,
-}
-
-impl LinkStyle {
-    /// Parse a link style from a string.
-    ///
-    /// Accepts "reference" or defaults to Inline.
-    /// Input is normalized (lowercased, alphanumeric only).
-    #[must_use]
-    pub fn parse(value: &str) -> Self {
-        match normalize_token(value).as_str() {
-            "reference" => Self::Reference,
-            _ => Self::Inline,
-        }
-    }
-}
-
-/// Output format for conversion.
-///
-/// Specifies the target markup language format for the conversion output.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
-pub enum OutputFormat {
-    /// Standard Markdown (CommonMark compatible). Default.
-    #[default]
-    Markdown,
-    /// Djot lightweight markup language.
-    Djot,
-    /// Plain text output (no markup, visible text only).
-    Plain,
-}
-
-impl OutputFormat {
-    /// Parse an output format from a string.
-    ///
-    /// Accepts "djot" or defaults to Markdown.
-    /// Input is normalized (lowercased, alphanumeric only).
-    #[must_use]
-    pub fn parse(value: &str) -> Self {
-        match normalize_token(value).as_str() {
-            "djot" => Self::Djot,
-            "plain" | "plaintext" | "text" => Self::Plain,
-            _ => Self::Markdown,
-        }
-    }
-}
-
-/// Normalize a configuration string by lowercasing and removing non-alphanumeric characters.
-pub(crate) fn normalize_token(value: &str) -> String {
-    let mut out = String::with_capacity(value.len());
-    for ch in value.chars() {
-        if ch.is_ascii_alphanumeric() {
-            out.push(ch.to_ascii_lowercase());
-        }
-    }
-    out
-}
-
-#[cfg(any(feature = "serde", feature = "metadata"))]
-mod serde_impls {
-    use super::{
-        CodeBlockStyle, HeadingStyle, HighlightStyle, LinkStyle, ListIndentType, NewlineStyle, OutputFormat,
-        WhitespaceMode,
-    };
-    use serde::{Deserialize, Serialize, Serializer};
-
-    macro_rules! impl_deserialize_from_parse {
-        ($ty:ty, $parser:expr) => {
-            impl<'de> Deserialize<'de> for $ty {
-                fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-                where
-                    D: serde::Deserializer<'de>,
-                {
-                    let value = String::deserialize(deserializer)?;
-                    Ok($parser(&value))
-                }
-            }
-        };
-    }
-
-    impl_deserialize_from_parse!(HeadingStyle, HeadingStyle::parse);
-    impl_deserialize_from_parse!(ListIndentType, ListIndentType::parse);
-    impl_deserialize_from_parse!(WhitespaceMode, WhitespaceMode::parse);
-    impl_deserialize_from_parse!(NewlineStyle, NewlineStyle::parse);
-    impl_deserialize_from_parse!(CodeBlockStyle, CodeBlockStyle::parse);
-    impl_deserialize_from_parse!(HighlightStyle, HighlightStyle::parse);
-    impl_deserialize_from_parse!(LinkStyle, LinkStyle::parse);
-    impl_deserialize_from_parse!(OutputFormat, OutputFormat::parse);
-
-    // Serialize implementations that convert enum variants to their string representations
-    impl Serialize for HeadingStyle {
-        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        where
-            S: Serializer,
-        {
-            let s = match self {
-                Self::Underlined => "underlined",
-                Self::Atx => "atx",
-                Self::AtxClosed => "atxclosed",
-            };
-            serializer.serialize_str(s)
-        }
-    }
-
-    impl Serialize for ListIndentType {
-        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        where
-            S: Serializer,
-        {
-            let s = match self {
-                Self::Spaces => "spaces",
-                Self::Tabs => "tabs",
-            };
-            serializer.serialize_str(s)
-        }
-    }
-
-    impl Serialize for WhitespaceMode {
-        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        where
-            S: Serializer,
-        {
-            let s = match self {
-                Self::Normalized => "normalized",
-                Self::Strict => "strict",
-            };
-            serializer.serialize_str(s)
-        }
-    }
-
-    impl Serialize for NewlineStyle {
-        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        where
-            S: Serializer,
-        {
-            let s = match self {
-                Self::Spaces => "spaces",
-                Self::Backslash => "backslash",
-            };
-            serializer.serialize_str(s)
-        }
-    }
-
-    impl Serialize for CodeBlockStyle {
-        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        where
-            S: Serializer,
-        {
-            let s = match self {
-                Self::Indented => "indented",
-                Self::Backticks => "backticks",
-                Self::Tildes => "tildes",
-            };
-            serializer.serialize_str(s)
-        }
-    }
-
-    impl Serialize for HighlightStyle {
-        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        where
-            S: Serializer,
-        {
-            let s = match self {
-                Self::DoubleEqual => "doubleequal",
-                Self::Html => "html",
-                Self::Bold => "bold",
-                Self::None => "none",
-            };
-            serializer.serialize_str(s)
-        }
-    }
-
-    impl Serialize for LinkStyle {
-        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        where
-            S: Serializer,
-        {
-            let s = match self {
-                Self::Inline => "inline",
-                Self::Reference => "reference",
-            };
-            serializer.serialize_str(s)
-        }
-    }
-
-    impl Serialize for OutputFormat {
-        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        where
-            S: Serializer,
-        {
-            let s = match self {
-                Self::Markdown => "markdown",
-                Self::Djot => "djot",
-                Self::Plain => "plain",
-            };
-            serializer.serialize_str(s)
-        }
-    }
-}
-
-#[cfg(all(test, any(feature = "serde", feature = "metadata")))]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_enum_serialization() {
-        // Test that enums serialize to lowercase strings
-        let heading = HeadingStyle::AtxClosed;
-        let json = serde_json::to_string(&heading).expect("Failed to serialize");
-        assert_eq!(json, r#""atxclosed""#);
-
-        let list_indent = ListIndentType::Tabs;
-        let json = serde_json::to_string(&list_indent).expect("Failed to serialize");
-        assert_eq!(json, r#""tabs""#);
-
-        let whitespace = WhitespaceMode::Strict;
-        let json = serde_json::to_string(&whitespace).expect("Failed to serialize");
-        assert_eq!(json, r#""strict""#);
-    }
-
-    #[test]
-    fn test_enum_deserialization() {
-        // Test that enums deserialize from strings (case insensitive)
-        let heading: HeadingStyle = serde_json::from_str(r#""atxclosed""#).expect("Failed");
-        assert_eq!(heading, HeadingStyle::AtxClosed);
-
-        let heading: HeadingStyle = serde_json::from_str(r#""ATXCLOSED""#).expect("Failed");
-        assert_eq!(heading, HeadingStyle::AtxClosed);
-
-        let list_indent: ListIndentType = serde_json::from_str(r#""tabs""#).expect("Failed");
-        assert_eq!(list_indent, ListIndentType::Tabs);
-    }
-}

data/vendor/html-to-markdown-rs/src/prelude.rs

@@ -1 +0,0 @@
-//! Prelude module for convenient internal imports.