rumdl 0.0.156__tar.gz → 0.0.157__tar.gz

{rumdl-0.0.156 → rumdl-0.0.157}/CHANGELOG.md

@@ -7,6 +7,191 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.157] - 2025-10-13 (unreleased)
+
+### Added
+
+- **MD042**: Full support for MkDocs paragraph anchors (#100)
+  - Recognize Python-Markdown `attr_list` extension syntax: `[](){ #anchor }`
+  - Support for both anchor IDs (`#id`) and CSS classes (`.class`)
+  - Support optional colon syntax: `[](){: #anchor }`
+  - UTF-8 boundary validation and DoS prevention (500 char limit)
+  - 28 comprehensive tests covering edge cases
+  - Complete documentation with links to official Python-Markdown specs
+  - References: [attr_list](https://python-markdown.github.io/extensions/attr_list/), [mkdocs-autorefs](https://mkdocstrings.github.io/autorefs/)
+
+- **MD042**: Smart URL detection in empty links (#104)
+  - When link text looks like a URL (e.g., `[https://example.com]()`), use it as the destination
+  - Supports http://, https://, ftp://, ftps:// protocols
+  - More intelligent fixes than placeholder URLs
+
+- **Always respect exclude patterns by default** (#99)
+  - Exclude patterns now always respected, even for explicitly provided files
+  - Matches behavior of ESLint, Pylint, Mypy
+  - Added `--no-exclude` flag to disable all exclusions when needed
+  - LSP support for exclude patterns
+  - Shows warnings with actionable hints when excluding files
+
+- **Hidden directory scanning** (#102)
+  - Now scans hidden directories (like `.documentation`) by default
+  - More thorough markdown file discovery
+
+### Fixed
+
+- **MD033**: Code blocks in blockquotes false positives (#105)
+  - Fixed incorrect flagging of HTML tags inside fenced code blocks within blockquotes
+  - Properly strips blockquote markers before detecting fence markers
+  - 25 new tests covering nested blockquotes and edge cases
+
+- **MD034**: Empty link construct false positives (#104)
+  - Fixed incorrect flagging of URLs in `[url]()` and `[url][]` patterns
+  - Prevents text corruption during formatting
+  - Added patterns to properly exclude empty link constructs
+
+- **MD042**: Improved fix quality
+  - Removed "useless" placeholder fixes that just create new problems
+  - Only provides fixes when we have enough information for valid links
+  - No longer auto-fixes `[]()` or `[text]()` with placeholders
+
+### Changed
+
+- **BREAKING**: Exclude patterns now always respected by default
+  - Previously: `--force-exclude` flag needed to respect excludes for explicit files
+  - Now: Excludes always respected by default
+  - Migration: Use `--no-exclude` flag if you need the old behavior
+
+## [0.0.156] - 2025-10-08
+
+### Fixed
+
+- **Build**: Removed feature-gated benchmark binaries that were causing unnecessary reinstalls
+  - Benchmark binaries now only built when explicitly requested
+  - Reduces package size and installation time
+
+## [0.0.155] - 2025-10-08
+
+### Fixed
+
+- **PyPI Package**: Fixed package structure by removing unused cdylib and dependencies
+  - Removed unnecessary C dynamic library configuration
+  - Cleaner Python package distribution
+
+## [0.0.154] - 2025-10-08
+
+### Fixed
+
+- **MD013**: Implemented segment-based reflow to preserve hard breaks
+  - Properly handles double-space line breaks
+  - Integration tests updated for new behavior
+
+### Performance
+
+- **MD034**: Reuse buffers to reduce per-line allocations
+- **MD005**: Eliminate LineIndex creation overhead
+- **MD030**: Eliminate O(n²) complexity by caching line collection
+
+### Documentation
+
+- Organized LintContext optimization documentation
+
+## [0.0.153] - 2025-10-07
+
+### Performance
+
+- **Major optimization**: 54 rules now use LintContext character frequency caching
+  - Significant performance improvement across the board
+  - Reduced redundant scanning of document content
+
+- **MD051**: Optimized link fragment validation
+  - Faster processing of heading anchors and fragments
+
+### Fixed
+
+- **MD013**: Improved nested list handling in reflow mode
+  - Better preservation of list structure during reformatting
+
+## [0.0.152] - 2025-10-06
+
+### Fixed
+
+- **MD013**: Multi-paragraph list reflow improvements and refactoring
+  - Better handling of complex list structures
+  - More reliable paragraph detection within lists
+
+## [0.0.151] - 2025-10-05
+
+### Fixed
+
+- **MD007**: Fixed tab indentation and cascade behavior
+  - Properly handles tabs in list indentation
+  - Correct cascade behavior matching markdownlint
+
+## [0.0.150] - 2025-10-04
+
+### Fixed
+
+- **MD007**: Multiple fixes for list indentation
+  - Correct blockquote list handling
+  - Fixed text-aligned indentation to match markdownlint cascade behavior
+  - Updated test expectations for cascade behavior
+
+## [0.0.149] - 2025-10-03
+
+### Added
+
+- **Configuration**: JSON Schema for rumdl.toml configuration (#89)
+  - IDE autocomplete and validation support
+  - Better configuration documentation
+
+- **Configuration**: Per-file rule ignores (#92)
+  - Glob pattern support for ignoring rules on specific files
+  - Example: `[per-file-ignores] "docs/*.md" = ["MD013"]`
+
+## [0.0.148] - 2025-10-02
+
+### Fixed
+
+- **MD042**: Display improvements
+  - Show exact source text in error messages
+  - Correct display of shorthand reference links
+
+- **MkDocs**: Strip backticks from MkDocs auto-references (#97)
+  - Prevents false positives on `` [`module.Class`][] `` patterns
+
+## [0.0.147] - 2025-10-01
+
+### Added
+
+- **MkDocs**: Added mkdocstrings support (#94)
+  - Recognizes mkdocstrings YAML options
+  - Multiple rules migrated to use LintContext for better MkDocs handling
+
+### Fixed
+
+- **MD041**: Removed auto-fix capability (#93)
+  - Auto-fixing front-heading violations was unreliable
+  - Now only reports issues without attempting fixes
+
+- **MD026**: Corrected documentation to match implementation (#95)
+  - Documentation now accurately reflects punctuation handling
+
+- **Jinja2**: Added Jinja2 template support (#96)
+  - Prevents false positives in template syntax
+  - Better support for MkDocs projects using Jinja2
+
+- **MD013**: Prevent false positives for already-reflowed content
+  - Smarter detection of intentional line breaks
+
+- **MD034**: Properly excludes URLs/emails in code spans and HTML
+  - No more false positives on inline code URLs
+
+- **MD054**: Fixed column indexing bug
+  - Correct error position reporting
+
+- **MD033 & MD032**: Resolved false positives (#90, #91)
+  - More accurate HTML tag detection
+  - Better handling of code blocks
+
 ## [0.0.146] - 2025-09-24
 
 ### Added

{rumdl-0.0.156 → rumdl-0.0.157}/Cargo.lock

@@ -1566,7 +1566,7 @@ checksum = "caf4aa5b0f434c91fe5c7f1ecb6a5ece2130b02ad2a590589dda5146df959001"
 
 [[package]]
 name = "rumdl"
-version = "0.0.156"
+version = "0.0.157"
 dependencies = [
  "anyhow",
  "assert_cmd",

{rumdl-0.0.156 → rumdl-0.0.157}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rumdl"
-version = "0.0.156"
+version = "0.0.157"
 edition = "2024"
 rust-version = "1.89.0"
 description = "A fast Markdown linter written in Rust (Ru(st) MarkDown Linter)"

{rumdl-0.0.156 → rumdl-0.0.157}/PKG-INFO

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

{rumdl-0.0.156 → rumdl-0.0.157}/docs/md042.md

@@ -67,6 +67,34 @@ When enabled, this rule will:
 - Reference-style links are checked for both parts
 - Links with only whitespace are considered empty
 
+### MkDocs mode
+
+When using MkDocs flavor (`flavor = "mkdocs"`), this rule recognizes valid MkDocs-specific syntax:
+
+**Auto-references** (backtick-wrapped Python identifiers):
+
+```markdown
+[`module.Class`][]        <!-- Valid MkDocs auto-reference -->
+[`str`][]                 <!-- Valid Python type reference -->
+[`api.function`][]        <!-- Valid API reference -->
+```
+
+**Paragraph anchors** (using Python-Markdown attr_list extension):
+
+```markdown
+[](){ #my-anchor }        <!-- Valid anchor point -->
+[](){ #anchor .class }    <!-- Valid anchor with CSS class -->
+[](){: #anchor }          <!-- Valid with colon syntax -->
+```
+
+These patterns create anchor points in documentation and are widely used in MkDocs projects with the `attr_list` extension.
+
+**References:**
+
+- [Python-Markdown attr_list extension](https://python-markdown.github.io/extensions/attr_list/)
+- [mkdocs-autorefs plugin](https://mkdocstrings.github.io/autorefs/)
+- [MkDocs auto-references discussion](https://github.com/mkdocs/mkdocs/discussions/3754)
+
 ## Learn more
 
 - [CommonMark specification for links](https://spec.commonmark.org/0.31.2/#links)

{rumdl-0.0.156 → rumdl-0.0.157}/src/config.rs

@@ -251,11 +251,12 @@ pub struct GlobalConfig {
     #[serde(default)]
     pub flavor: MarkdownFlavor,
 
-    /// Whether to enforce exclude and extend-exclude patterns even for paths that are passed explicitly.
-    /// By default (false), rumdl will lint any paths passed in directly, even if they would typically be excluded.
-    /// Setting this to true will cause rumdl to respect exclusions unequivocally.
-    /// This is useful for pre-commit, which explicitly passes all changed files.
+    /// [DEPRECATED] Whether to enforce exclude patterns for explicitly passed paths.
+    /// This option is deprecated as of v0.0.156 and has no effect.
+    /// Exclude patterns are now always respected, even for explicitly provided files.
+    /// This prevents duplication between rumdl config and tool configs like pre-commit.
     #[serde(default)]
+    #[deprecated(since = "0.0.156", note = "Exclude patterns are now always respected")]
     pub force_exclude: bool,
 }
 
@@ -269,6 +270,7 @@ fn default_line_length() -> u64 {
 
 // Add the Default impl
 impl Default for GlobalConfig {
+    #[allow(deprecated)]
     fn default() -> Self {
         Self {
             enable: Vec::new(),
@@ -1962,6 +1964,7 @@ impl From<SourcedConfig> for Config {
             }
             rules.insert(normalized_rule_name, RuleConfig { values });
         }
+        #[allow(deprecated)]
         let global = GlobalConfig {
             enable: sourced.global.enable.value,
             disable: sourced.global.disable.value,

{rumdl-0.0.156 → rumdl-0.0.157}/src/lsp/server.rs

@@ -41,7 +41,8 @@ pub struct RumdlLanguageServer {
     /// Configuration for the LSP server
     config: Arc<RwLock<RumdlLspConfig>>,
     /// Rumdl core configuration
-    rumdl_config: Arc<RwLock<Config>>,
+    #[cfg_attr(test, allow(dead_code))]
+    pub(crate) rumdl_config: Arc<RwLock<Config>>,
     /// Document store for open files and cached disk files
     documents: Arc<RwLock<HashMap<Url, DocumentEntry>>>,
 }
@@ -118,8 +119,63 @@ impl RumdlLanguageServer {
         filtered_rules
     }
 
+    /// Check if a file URI should be excluded based on exclude patterns
+    async fn should_exclude_uri(&self, uri: &Url) -> bool {
+        // Try to convert URI to file path
+        let file_path = match uri.to_file_path() {
+            Ok(path) => path,
+            Err(_) => return false, // If we can't get a path, don't exclude
+        };
+
+        let rumdl_config = self.rumdl_config.read().await;
+        let exclude_patterns = &rumdl_config.global.exclude;
+
+        // If no exclude patterns, don't exclude
+        if exclude_patterns.is_empty() {
+            return false;
+        }
+
+        // Convert path to relative path for pattern matching
+        // This matches the CLI behavior in find_markdown_files
+        let path_to_check = if file_path.is_absolute() {
+            // Try to make it relative to the current directory
+            if let Ok(cwd) = std::env::current_dir() {
+                // Canonicalize both paths to handle symlinks
+                if let (Ok(canonical_cwd), Ok(canonical_path)) = (cwd.canonicalize(), file_path.canonicalize()) {
+                    if let Ok(relative) = canonical_path.strip_prefix(&canonical_cwd) {
+                        relative.to_string_lossy().to_string()
+                    } else {
+                        // Path is absolute but not under cwd
+                        file_path.to_string_lossy().to_string()
+                    }
+                } else {
+                    // Canonicalization failed
+                    file_path.to_string_lossy().to_string()
+                }
+            } else {
+                file_path.to_string_lossy().to_string()
+            }
+        } else {
+            // Already relative
+            file_path.to_string_lossy().to_string()
+        };
+
+        // Check if path matches any exclude pattern
+        for pattern in exclude_patterns {
+            if let Ok(glob) = globset::Glob::new(pattern) {
+                let matcher = glob.compile_matcher();
+                if matcher.is_match(&path_to_check) {
+                    log::debug!("Excluding file from LSP linting: {path_to_check}");
+                    return true;
+                }
+            }
+        }
+
+        false
+    }
+
     /// Lint a document and return diagnostics
-    async fn lint_document(&self, uri: &Url, text: &str) -> Result<Vec<Diagnostic>> {
+    pub(crate) async fn lint_document(&self, uri: &Url, text: &str) -> Result<Vec<Diagnostic>> {
         let config_guard = self.config.read().await;
 
         // Skip linting if disabled
@@ -130,6 +186,11 @@ impl RumdlLanguageServer {
         let lsp_config = config_guard.clone();
         drop(config_guard); // Release config lock early
 
+        // Check if file should be excluded based on exclude patterns
+        if self.should_exclude_uri(uri).await {
+            return Ok(Vec::new());
+        }
+
         // Get rumdl configuration
         let rumdl_config = self.rumdl_config.read().await;
         let all_rules = rules::all_rules(&rumdl_config);
@@ -168,7 +229,12 @@ impl RumdlLanguageServer {
     }
 
     /// Apply all available fixes to a document
-    async fn apply_all_fixes(&self, _uri: &Url, text: &str) -> Result<Option<String>> {
+    async fn apply_all_fixes(&self, uri: &Url, text: &str) -> Result<Option<String>> {
+        // Check if file should be excluded based on exclude patterns
+        if self.should_exclude_uri(uri).await {
+            return Ok(None);
+        }
+
         let config_guard = self.config.read().await;
         let lsp_config = config_guard.clone();
         drop(config_guard);

{rumdl-0.0.156 → rumdl-0.0.157}/src/main.rs

@@ -254,6 +254,10 @@ struct CheckArgs {
     #[arg(long)]
     exclude: Option<String>,
 
+    /// Disable all exclude patterns (lint all files regardless of exclude configuration)
+    #[arg(long, help = "Disable all exclude patterns")]
+    no_exclude: bool,
+
     /// Include only specific files or directories (comma-separated glob patterns).
     #[arg(long)]
     include: Option<String>,
@@ -532,8 +536,10 @@ fn find_markdown_files(
         Vec::new()
     };
 
-    // Exclude patterns: CLI > Config
-    let final_exclude_patterns: Vec<String> = if let Some(cli_exclude) = args.exclude.as_deref() {
+    // Exclude patterns: CLI > Config (but disabled if --no-exclude is set)
+    let final_exclude_patterns: Vec<String> = if args.no_exclude {
+        Vec::new() // Disable all exclusions
+    } else if let Some(cli_exclude) = args.exclude.as_deref() {
         cli_exclude
             .split(',')
             .map(|p| p.trim().to_string())
@@ -599,7 +605,7 @@ fn find_markdown_files(
     walk_builder.git_global(use_gitignore); // Enable/disable global gitignore
     walk_builder.git_exclude(use_gitignore); // Enable/disable .git/info/exclude
     walk_builder.parents(use_gitignore); // Enable/disable parent ignores
-    walk_builder.hidden(true); // Keep hidden files ignored unconditionally
+    walk_builder.hidden(false); // Include hidden files and directories
     walk_builder.require_git(false); // Process git ignores even if no repo detected
 
     // Add support for .markdownlintignore file
@@ -608,8 +614,7 @@ fn find_markdown_files(
     // --- Pre-check for explicit file paths ---
     // If not in discovery mode, validate that specified paths exist
     if !is_discovery_mode {
-        // Check if we should apply excludes to explicitly provided files
-        let should_force_exclude = args.force_exclude || config.global.force_exclude;
+        let mut processed_explicit_files = false;
 
         for path_str in paths {
             let path = Path::new(path_str);
@@ -621,42 +626,68 @@ fn find_markdown_files(
                 && let Some(ext) = path.extension()
                 && (ext == "md" || ext == "markdown")
             {
-                let cleaned_path = if let Some(stripped) = path_str.strip_prefix("./") {
+                processed_explicit_files = true;
+                // Convert to relative path for pattern matching
+                // This ensures patterns like "docs/*" work with both relative and absolute paths
+                let cleaned_path = if path.is_absolute() {
+                    // Try to make it relative to the current directory
+                    // Use canonicalized paths to handle symlinks (e.g., /tmp -> /private/tmp on macOS)
+                    if let Ok(cwd) = std::env::current_dir() {
+                        // Canonicalize both paths to resolve symlinks
+                        if let (Ok(canonical_cwd), Ok(canonical_path)) = (cwd.canonicalize(), path.canonicalize()) {
+                            if let Ok(relative) = canonical_path.strip_prefix(&canonical_cwd) {
+                                relative.to_string_lossy().to_string()
+                            } else {
+                                // Path is absolute but not under cwd, keep as-is
+                                path_str.clone()
+                            }
+                        } else {
+                            // Canonicalization failed, keep path as-is
+                            path_str.clone()
+                        }
+                    } else {
+                        path_str.clone()
+                    }
+                } else if let Some(stripped) = path_str.strip_prefix("./") {
                     stripped.to_string()
                 } else {
                     path_str.clone()
                 };
 
-                // If force_exclude is enabled, check if this file should be excluded
-                if should_force_exclude && !final_exclude_patterns.is_empty() {
-                    let mut should_exclude = false;
+                // Check if this file should be excluded based on exclude patterns
+                // This is the default behavior to match user expectations and avoid
+                // duplication between rumdl config and pre-commit config (issue #99)
+                if !final_exclude_patterns.is_empty() {
+                    let mut matching_pattern: Option<&str> = None;
                     for pattern in &final_exclude_patterns {
                         // Use globset for pattern matching
                         if let Ok(glob) = globset::Glob::new(pattern) {
                             let matcher = glob.compile_matcher();
                             if matcher.is_match(&cleaned_path) {
-                                should_exclude = true;
-                                if args.verbose {
-                                    eprintln!(
-                                        "Excluding explicitly provided file due to force_exclude: {cleaned_path}"
-                                    );
-                                }
+                                matching_pattern = Some(pattern);
                                 break;
                             }
                         }
                     }
-                    if !should_exclude {
+                    if let Some(pattern) = matching_pattern {
+                        // Always print a warning when excluding explicitly provided files
+                        // This matches ESLint's behavior and helps users understand why the file wasn't linted
+                        eprintln!(
+                            "warning: {cleaned_path} ignored because of exclude pattern '{pattern}'. Use --no-exclude to override"
+                        );
+                    } else {
                         file_paths.push(cleaned_path);
                     }
                 } else {
-                    // Default behavior: add all explicitly provided files
+                    // No exclude patterns, add the file
                     file_paths.push(cleaned_path);
                 }
             }
         }
 
-        // If we found files directly, skip the walker
-        if !file_paths.is_empty() || should_force_exclude {
+        // If we processed explicit files, return the results (even if empty due to exclusions)
+        // This prevents the walker from running when explicit files were provided
+        if processed_explicit_files {
             file_paths.sort();
             file_paths.dedup();
             return Ok(file_paths);
@@ -2532,6 +2563,16 @@ fn run_check(args: &CheckArgs, global_config_path: Option<&str>, isolated: bool)
         exit::tool_error();
     }
 
+    // Warn about deprecated --force-exclude flag
+    if args.force_exclude {
+        eprintln!(
+            "{}: --force-exclude is deprecated and has no effect",
+            "warning".yellow().bold()
+        );
+        eprintln!("Exclude patterns are now always respected by default (as of v0.0.156)");
+        eprintln!("Use --no-exclude if you want to disable exclusions");
+    }
+
     // Check for watch mode
     if args.watch {
         run_watch_mode(args, global_config_path, isolated, quiet);

{rumdl-0.0.156 → rumdl-0.0.157}/src/rules/md034_no_bare_urls.rs

@@ -11,6 +11,8 @@ use crate::lint_context::LintContext;
 const URL_QUICK_CHECK_STR: &str = r#"(?:https?|ftps?)://|@"#;
 const CUSTOM_PROTOCOL_PATTERN_STR: &str = r#"(?:grpc|ws|wss|ssh|git|svn|file|data|javascript|vscode|chrome|about|slack|discord|matrix|irc|redis|mongodb|postgresql|mysql|kafka|nats|amqp|mqtt|custom|app|api|service)://"#;
 const MARKDOWN_LINK_PATTERN_STR: &str = r#"\[(?:[^\[\]]|\[[^\]]*\])*\]\(([^)\s]+)(?:\s+(?:\"[^\"]*\"|\'[^\']*\'))?\)"#;
+const MARKDOWN_EMPTY_LINK_PATTERN_STR: &str = r#"\[(?:[^\[\]]|\[[^\]]*\])*\]\(\)"#;
+const MARKDOWN_EMPTY_REF_PATTERN_STR: &str = r#"\[(?:[^\[\]]|\[[^\]]*\])*\]\[\]"#;
 const ANGLE_LINK_PATTERN_STR: &str =
     r#"<((?:https?|ftps?)://(?:\[[0-9a-fA-F:]+(?:%[a-zA-Z0-9]+)?\]|[^>]+)|[^@\s]+@[^@\s]+\.[^@\s>]+)>"#;
 const BADGE_LINK_LINE_STR: &str = r#"^\s*\[!\[[^\]]*\]\([^)]*\)\]\([^)]*\)\s*$"#;
@@ -163,6 +165,19 @@ impl MD034NoBareUrls {
             }
         }
 
+        // Also include empty link patterns like [text]() and [text][]
+        if let Ok(re) = get_cached_regex(MARKDOWN_EMPTY_LINK_PATTERN_STR) {
+            for mat in re.find_iter(line) {
+                buffers.markdown_link_ranges.push((mat.start(), mat.end()));
+            }
+        }
+
+        if let Ok(re) = get_cached_regex(MARKDOWN_EMPTY_REF_PATTERN_STR) {
+            for mat in re.find_iter(line) {
+                buffers.markdown_link_ranges.push((mat.start(), mat.end()));
+            }
+        }
+
         if let Ok(re) = get_cached_regex(ANGLE_LINK_PATTERN_STR) {
             for cap in re.captures_iter(line) {
                 if let Some(mat) = cap.get(0) {