rumdl 0.0.58__tar.gz → 0.0.60__tar.gz

{rumdl-0.0.58 → rumdl-0.0.60}/Cargo.lock

@@ -917,6 +917,15 @@ version = "2.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
 
+[[package]]
+name = "memmap2"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd3f7eed9d3848f8b98834af67102b720745c4ec028fcd0aa0239277e7de374f"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "memoffset"
 version = "0.9.1"
@@ -1368,7 +1377,7 @@ dependencies = [
 
 [[package]]
 name = "rumdl"
-version = "0.0.58"
+version = "0.0.60"
 dependencies = [
  "anyhow",
  "assert_cmd",
@@ -1388,6 +1397,7 @@ dependencies = [
  "lazy_static",
  "log",
  "markdown",
+ "memmap2",
  "once_cell",
  "predicates",
  "pretty_assertions",
@@ -1396,6 +1406,7 @@ dependencies = [
  "rand 0.9.1",
  "rayon",
  "regex",
+ "seahash",
  "serde",
  "serde_json",
  "serde_yaml",
@@ -1404,6 +1415,7 @@ dependencies = [
  "thiserror 2.0.12",
  "toml",
  "toml_edit",
+ "unicode-normalization",
  "url",
  "walkdir",
 ]
@@ -1465,6 +1477,12 @@ dependencies = [
  "winapi-util",
 ]
 
+[[package]]
+name = "seahash"
+version = "4.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1c107b6f4780854c8b126e228ea8869f4d7b71260f962fefb57b996b8959ba6b"
+
 [[package]]
 name = "serde"
 version = "1.0.219"
@@ -1670,6 +1688,21 @@ dependencies = [
  "serde_json",
 ]
 
+[[package]]
+name = "tinyvec"
+version = "1.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09b3661f17e86524eccd4371ab0429194e0d7c008abb45f7a7495b1719463c71"
+dependencies = [
+ "tinyvec_macros",
+]
+
+[[package]]
+name = "tinyvec_macros"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
+
 [[package]]
 name = "toml"
 version = "0.8.22"
@@ -1747,6 +1780,15 @@ version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512"
 
+[[package]]
+name = "unicode-normalization"
+version = "0.1.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5033c97c4262335cded6d6fc3e5c18ab755e1a3dc96376350f3d8e9f009ad956"
+dependencies = [
+ "tinyvec",
+]
+
 [[package]]
 name = "unicode-segmentation"
 version = "1.12.0"

{rumdl-0.0.58 → rumdl-0.0.60}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rumdl"
-version = "0.0.58"
+version = "0.0.60"
 edition = "2021"
 description = "A fast Markdown linter written in Rust (Ru(st) MarkDown Linter)"
 authors = ["Ruben J. Jongejan <ruben.jongejan@gmail.com>"]
@@ -44,15 +44,17 @@ anyhow = "1.0"
 console = "0.15.11"
 dialoguer = "0.11.0"
 indicatif = "0.17.11"
-
 log = "0.4.27"
 pretty_assertions = "1.4"
-markdown = "1.0.0"
+markdown = "1.0"
 config = "0.15"
-regex = "1.11.1"
+regex = "1.11"
 toml_edit = "0.22"
 dyn-clone = "1"
 url = { version = "2", features = ["serde"] }
+unicode-normalization = "0.1"
+memmap2 = "0.9"
+seahash = "4.1"
 
 [features]
 default = ["parallel", "profiling"]
@@ -70,7 +72,6 @@ glob = "0.3.2"
 proptest = "1.6.0"
 criterion = { version = "0.5", features = ["html_reports"] }
 rand = "0.9.1"
-
 pretty_assertions = "1.4"
 
 [[bench]]

{rumdl-0.0.58 → rumdl-0.0.60}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rumdl
-Version: 0.0.58
+Version: 0.0.60
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers

{rumdl-0.0.58 → rumdl-0.0.60}/src/config.rs

@@ -209,21 +209,35 @@ pub enum ConfigError {
 }
 
 /// Get a rule-specific configuration value
+/// Automatically tries both the original key and normalized variants (kebab-case ↔ snake_case)
+/// for better markdownlint compatibility
 pub fn get_rule_config_value<T: serde::de::DeserializeOwned>(
     config: &Config,
     rule_name: &str,
     key: &str,
 ) -> Option<T> {
-    let norm_key = normalize_key(key);
     let norm_rule_name = rule_name.to_ascii_uppercase(); // Use uppercase for lookup
-    config
-        .rules
-        .get(&norm_rule_name)
-        .and_then(|rule_config| rule_config.values.get(&norm_key))
-        .and_then(|value| {
-            let result = T::deserialize(value.clone()).ok();
-            result
-        })
+
+    let rule_config = config.rules.get(&norm_rule_name)?;
+
+    // Try multiple key variants to support both underscore and kebab-case formats
+    let key_variants = [
+        key.to_string(),                              // Original key as provided
+        normalize_key(key),                           // Normalized key (lowercase, kebab-case)
+        key.replace('-', "_"),                        // Convert kebab-case to snake_case
+        key.replace('_', "-"),                        // Convert snake_case to kebab-case
+    ];
+
+    // Try each variant until we find a match
+    for variant in &key_variants {
+        if let Some(value) = rule_config.values.get(variant) {
+            if let Ok(result) = T::deserialize(value.clone()) {
+                return Some(result);
+            }
+        }
+    }
+
+    None
 }
 
 /// Generate default rumdl configuration for pyproject.toml
@@ -904,16 +918,52 @@ impl RuleRegistry {
         self.rule_schemas.keys().cloned().collect()
     }
 
-    /// Get valid config keys for a rule
+    /// Get the valid configuration keys for a rule, including both original and normalized variants
     pub fn config_keys_for(&self, rule: &str) -> Option<std::collections::BTreeSet<String>> {
-        self.rule_schemas
-            .get(rule)
-            .map(|m| m.keys().cloned().collect())
+        self.rule_schemas.get(rule).map(|schema| {
+            let mut all_keys = std::collections::BTreeSet::new();
+
+            // Add original keys from schema
+            for key in schema.keys() {
+                all_keys.insert(key.clone());
+            }
+
+            // Add normalized variants for markdownlint compatibility
+            for key in schema.keys() {
+                // Add kebab-case variant
+                all_keys.insert(key.replace('_', "-"));
+                // Add snake_case variant
+                all_keys.insert(key.replace('-', "_"));
+                // Add normalized variant
+                all_keys.insert(normalize_key(key));
+            }
+
+            all_keys
+        })
     }
 
-    /// Get the expected TOML value for a rule's config key (for type checking)
+    /// Get the expected value type for a rule's configuration key, trying variants
     pub fn expected_value_for(&self, rule: &str, key: &str) -> Option<&toml::Value> {
-        self.rule_schemas.get(rule).and_then(|m| m.get(key))
+        if let Some(schema) = self.rule_schemas.get(rule) {
+            // Try the original key first
+            if let Some(value) = schema.get(key) {
+                return Some(value);
+            }
+
+            // Try key variants
+            let key_variants = [
+                key.replace('-', "_"),              // Convert kebab-case to snake_case
+                key.replace('_', "-"),              // Convert snake_case to kebab-case
+                normalize_key(key),                 // Normalized key (lowercase, kebab-case)
+            ];
+
+            for variant in &key_variants {
+                if let Some(value) = schema.get(variant) {
+                    return Some(value);
+                }
+            }
+        }
+        None
     }
 }
 

rumdl-0.0.60/src/lib.rs

@@ -0,0 +1,273 @@
+pub mod config;
+pub mod init;
+pub mod lint_context;
+pub mod markdownlint_config;
+pub mod profiling;
+pub mod rule;
+pub mod rules;
+pub mod utils;
+
+#[cfg(feature = "python")]
+pub mod python;
+
+pub use rules::heading_utils::{Heading, HeadingStyle};
+pub use rules::*;
+
+pub use crate::lint_context::LintContext;
+use crate::rule::{LintResult, Rule, RuleCategory};
+use crate::utils::document_structure::DocumentStructure;
+use std::time::Instant;
+
+/// Content characteristics for efficient rule filtering
+#[derive(Debug, Default)]
+struct ContentCharacteristics {
+    has_headings: bool,      // # or setext headings
+    has_lists: bool,         // *, -, +, 1. etc
+    has_links: bool,         // [text](url) or [text][ref]
+    has_code: bool,          // ``` or ~~~ or indented code
+    has_emphasis: bool,      // * or _ for emphasis
+    has_html: bool,          // < > tags
+    has_tables: bool,        // | pipes
+    has_blockquotes: bool,   // > markers
+    has_images: bool,        // ![alt](url)
+    line_count: usize,
+}
+
+impl ContentCharacteristics {
+    fn analyze(content: &str) -> Self {
+        let mut chars = Self::default();
+        chars.line_count = content.lines().count();
+
+        // Quick single-pass analysis
+        let mut has_atx_heading = false;
+        let mut has_setext_heading = false;
+
+        for line in content.lines() {
+            let trimmed = line.trim();
+
+            // Headings: ATX (#) or Setext (underlines)
+            if !has_atx_heading && trimmed.starts_with('#') {
+                has_atx_heading = true;
+            }
+            if !has_setext_heading && (trimmed.chars().all(|c| c == '=' || c == '-') && trimmed.len() > 1) {
+                has_setext_heading = true;
+            }
+
+            // Quick character-based detection (more efficient than regex)
+            if !chars.has_lists && (line.contains("* ") || line.contains("- ") || line.contains("+ ")) {
+                chars.has_lists = true;
+            }
+            if !chars.has_lists && line.chars().next().map_or(false, |c| c.is_ascii_digit()) && line.contains(". ") {
+                chars.has_lists = true;
+            }
+            if !chars.has_links && line.contains('[') {
+                chars.has_links = true;
+            }
+            if !chars.has_images && line.contains("![") {
+                chars.has_images = true;
+            }
+            if !chars.has_code && (line.contains('`') || line.contains("~~~")) {
+                chars.has_code = true;
+            }
+            if !chars.has_emphasis && (line.contains('*') || line.contains('_')) {
+                chars.has_emphasis = true;
+            }
+            if !chars.has_html && line.contains('<') {
+                chars.has_html = true;
+            }
+            if !chars.has_tables && line.contains('|') {
+                chars.has_tables = true;
+            }
+            if !chars.has_blockquotes && line.starts_with('>') {
+                chars.has_blockquotes = true;
+            }
+        }
+
+        chars.has_headings = has_atx_heading || has_setext_heading;
+        chars
+    }
+
+    /// Check if a rule should be skipped based on content characteristics
+    fn should_skip_rule(&self, rule: &dyn Rule) -> bool {
+        match rule.category() {
+            RuleCategory::Heading => !self.has_headings,
+            RuleCategory::List => !self.has_lists,
+            RuleCategory::Link => !self.has_links && !self.has_images,
+            RuleCategory::Image => !self.has_images,
+            RuleCategory::CodeBlock => !self.has_code,
+            RuleCategory::Html => !self.has_html,
+            RuleCategory::Emphasis => !self.has_emphasis,
+            RuleCategory::Blockquote => !self.has_blockquotes,
+            RuleCategory::Table => !self.has_tables,
+            // Always check these categories as they apply to all content
+            RuleCategory::Whitespace | RuleCategory::FrontMatter | RuleCategory::Other => false,
+        }
+    }
+}
+
+/// Lint a file against the given rules with intelligent rule filtering
+/// Assumes the provided `rules` vector contains the final,
+/// configured, and filtered set of rules to be executed.
+pub fn lint(content: &str, rules: &[Box<dyn Rule>], _verbose: bool) -> LintResult {
+    let mut warnings = Vec::new();
+    let _overall_start = Instant::now();
+
+    // Early return for empty content
+    if content.is_empty() {
+        return Ok(warnings);
+    }
+
+    // Analyze content characteristics for rule filtering
+    let characteristics = ContentCharacteristics::analyze(content);
+
+    // Filter rules based on content characteristics
+    let applicable_rules: Vec<_> = rules
+        .iter()
+        .filter(|rule| !characteristics.should_skip_rule(rule.as_ref()))
+        .collect();
+
+    // Calculate skipped rules count before consuming applicable_rules
+    let _total_rules = rules.len();
+    let _applicable_count = applicable_rules.len();
+
+    // Parse DocumentStructure once
+    let structure = DocumentStructure::new(content);
+
+    // Parse AST once for rules that can benefit from it
+    let ast_rules_count = applicable_rules.iter().filter(|rule| rule.uses_ast()).count();
+    let ast = if ast_rules_count > 0 {
+        Some(crate::utils::ast_utils::get_cached_ast(content))
+    } else {
+        None
+    };
+
+    // Parse LintContext once (migration step)
+    let lint_ctx = crate::lint_context::LintContext::new(content);
+
+    for rule in applicable_rules {
+        let _rule_start = Instant::now();
+
+        // Try optimized paths in order of preference
+        let result = if rule.uses_ast() && ast.is_some() {
+            // 1. AST-based path
+            rule.as_maybe_ast()
+                .and_then(|ext| ext.check_with_ast_opt(&lint_ctx, ast.as_ref().unwrap()))
+                .unwrap_or_else(|| rule.check_with_ast(&lint_ctx, ast.as_ref().unwrap()))
+        } else {
+            // 2. Document structure path
+            rule.as_maybe_document_structure()
+                .and_then(|ext| ext.check_with_structure_opt(&lint_ctx, &structure))
+                .unwrap_or_else(|| rule.check(&lint_ctx))
+        };
+
+        match result {
+            Ok(rule_warnings) => {
+                warnings.extend(rule_warnings);
+            }
+            Err(e) => {
+                log::error!("Error checking rule {}: {}", rule.name(), e);
+                return Err(e);
+            }
+        }
+
+        #[cfg(not(test))]
+        if _verbose {
+            let rule_duration = _rule_start.elapsed();
+            if rule_duration.as_millis() > 500 {
+                log::debug!("Rule {} took {:?}", rule.name(), rule_duration);
+            }
+        }
+    }
+
+    #[cfg(not(test))]
+    if _verbose {
+        let skipped_rules = _total_rules - _applicable_count;
+        if skipped_rules > 0 {
+            log::debug!("Skipped {} of {} rules based on content analysis", skipped_rules, _total_rules);
+        }
+        if ast.is_some() {
+            log::debug!("Used shared AST for {} rules", ast_rules_count);
+        }
+    }
+
+    Ok(warnings)
+}
+
+/// Get the profiling report
+pub fn get_profiling_report() -> String {
+    profiling::get_report()
+}
+
+/// Reset the profiling data
+pub fn reset_profiling() {
+    profiling::reset()
+}
+
+/// Get regex cache statistics for performance monitoring
+pub fn get_regex_cache_stats() -> std::collections::HashMap<String, u64> {
+    crate::utils::regex_cache::get_cache_stats()
+}
+
+/// Get AST cache statistics for performance monitoring
+pub fn get_ast_cache_stats() -> std::collections::HashMap<u64, u64> {
+    crate::utils::ast_utils::get_ast_cache_stats()
+}
+
+/// Clear all caches (useful for testing and memory management)
+pub fn clear_all_caches() {
+    crate::utils::ast_utils::clear_ast_cache();
+    // Note: Regex cache is intentionally not cleared as it's global and shared
+}
+
+/// Get comprehensive cache performance report
+pub fn get_cache_performance_report() -> String {
+    let regex_stats = get_regex_cache_stats();
+    let ast_stats = get_ast_cache_stats();
+
+    let mut report = String::new();
+
+    report.push_str("=== Cache Performance Report ===\n\n");
+
+    // Regex cache statistics
+    report.push_str("Regex Cache:\n");
+    if regex_stats.is_empty() {
+        report.push_str("  No regex patterns cached\n");
+    } else {
+        let total_usage: u64 = regex_stats.values().sum();
+        report.push_str(&format!("  Total patterns: {}\n", regex_stats.len()));
+        report.push_str(&format!("  Total usage: {}\n", total_usage));
+
+        // Show top 5 most used patterns
+        let mut sorted_patterns: Vec<_> = regex_stats.iter().collect();
+        sorted_patterns.sort_by(|a, b| b.1.cmp(a.1));
+
+        report.push_str("  Top patterns by usage:\n");
+        for (pattern, count) in sorted_patterns.iter().take(5) {
+            let truncated_pattern = if pattern.len() > 50 {
+                format!("{}...", &pattern[..47])
+            } else {
+                pattern.to_string()
+            };
+            report.push_str(&format!("    {} ({}x): {}\n", count, pattern.len().min(50), truncated_pattern));
+        }
+    }
+
+    report.push_str("\n");
+
+    // AST cache statistics
+    report.push_str("AST Cache:\n");
+    if ast_stats.is_empty() {
+        report.push_str("  No AST nodes cached\n");
+    } else {
+        let total_usage: u64 = ast_stats.values().sum();
+        report.push_str(&format!("  Total ASTs: {}\n", ast_stats.len()));
+        report.push_str(&format!("  Total usage: {}\n", total_usage));
+
+        if total_usage > ast_stats.len() as u64 {
+            let cache_hit_rate = ((total_usage - ast_stats.len() as u64) as f64 / total_usage as f64) * 100.0;
+            report.push_str(&format!("  Cache hit rate: {:.1}%\n", cache_hit_rate));
+        }
+    }
+
+    report
+}