rumdl 0.0.85__tar.gz → 0.0.86__tar.gz

{rumdl-0.0.85 → rumdl-0.0.86}/CHANGELOG.md

@@ -7,6 +7,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.86] - 2025-06-14
+
 ## [0.0.85] - 2025-06-11
 
 ## [0.0.84] - 2025-06-10
@@ -57,7 +59,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Added
 - Initial implementation of remaining rules for markdownlint parity
 
-[Unreleased]: https://github.com/rvben/rumdl/compare/v0.0.85...HEAD
+[Unreleased]: https://github.com/rvben/rumdl/compare/v0.0.86...HEAD
+[0.0.86]: https://github.com/rvben/rumdl/compare/v0.0.85...v0.0.86
 [0.0.85]: https://github.com/rvben/rumdl/compare/v0.0.84...v0.0.85
 [0.0.84]: https://github.com/rvben/rumdl/compare/v0.0.83...v0.0.84
 [0.0.84]: https://github.com/rvben/rumdl/compare/v0.0.83...v0.0.84

{rumdl-0.0.85 → rumdl-0.0.86}/Cargo.lock

@@ -1753,7 +1753,7 @@ dependencies = [
 
 [[package]]
 name = "rumdl"
-version = "0.0.85"
+version = "0.0.86"
 dependencies = [
  "anyhow",
  "assert_cmd",

{rumdl-0.0.85 → rumdl-0.0.86}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rumdl"
-version = "0.0.85"
+version = "0.0.86"
 edition = "2021"
 rust-version = "1.87.0"
 description = "A fast Markdown linter written in Rust (Ru(st) MarkDown Linter)"

{rumdl-0.0.85 → rumdl-0.0.86}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rumdl
-Version: 0.0.85
+Version: 0.0.86
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
@@ -58,6 +58,7 @@ Project-URL: Repository, https://github.com/rvben/rumdl.git
     - [Using Cargo (Rust)](#using-cargo-rust)
     - [Using pip (Python)](#using-pip-python)
     - [Download binary](#download-binary)
+    - [VS Code Extension](#vs-code-extension)
   - [Usage](#usage)
   - [Pre-commit Integration](#pre-commit-integration)
   - [Rules](#rules)
@@ -137,6 +138,30 @@ Invoke-WebRequest -Uri "https://github.com/rvben/rumdl/releases/latest/download/
 Expand-Archive -Path "rumdl.zip" -DestinationPath "$env:USERPROFILE\.rumdl"
 ```
 
+### VS Code Extension
+
+For the best development experience, install the rumdl VS Code extension directly from the command line:
+
+```bash
+# Install the VS Code extension
+rumdl vscode
+
+# Check if the extension is installed
+rumdl vscode --status
+
+# Force reinstall the extension
+rumdl vscode --force
+```
+
+The extension provides:
+- 🔍 Real-time linting as you type
+- 💡 Quick fixes for common issues
+- 🎨 Code formatting on save
+- 📋 Hover tooltips with rule documentation
+- ⚡ Lightning-fast performance with zero lag
+
+The CLI will automatically detect VS Code, Cursor, or Windsurf and install the appropriate extension. See the [VS Code extension documentation](https://github.com/rvben/rumdl/blob/main/docs/vscode-extension.md) for more details.
+
 ## Usage
 
 Getting started with rumdl is simple:
@@ -303,6 +328,14 @@ Start the Language Server Protocol server for editor integration
 - `--stdio`: Use stdio for communication (default)
 - `-v, --verbose`: Enable verbose logging
 
+#### `vscode [OPTIONS]`
+
+Install the rumdl VS Code extension
+
+**Options:**
+- `--force`: Force reinstall even if already installed
+- `--status`: Show installation status without installing
+
 #### `version`
 
 Show version information

{rumdl-0.0.85 → rumdl-0.0.86}/README.md

@@ -28,6 +28,7 @@
     - [Using Cargo (Rust)](#using-cargo-rust)
     - [Using pip (Python)](#using-pip-python)
     - [Download binary](#download-binary)
+    - [VS Code Extension](#vs-code-extension)
   - [Usage](#usage)
   - [Pre-commit Integration](#pre-commit-integration)
   - [Rules](#rules)
@@ -107,6 +108,30 @@ Invoke-WebRequest -Uri "https://github.com/rvben/rumdl/releases/latest/download/
 Expand-Archive -Path "rumdl.zip" -DestinationPath "$env:USERPROFILE\.rumdl"
 ```
 
+### VS Code Extension
+
+For the best development experience, install the rumdl VS Code extension directly from the command line:
+
+```bash
+# Install the VS Code extension
+rumdl vscode
+
+# Check if the extension is installed
+rumdl vscode --status
+
+# Force reinstall the extension
+rumdl vscode --force
+```
+
+The extension provides:
+- 🔍 Real-time linting as you type
+- 💡 Quick fixes for common issues
+- 🎨 Code formatting on save
+- 📋 Hover tooltips with rule documentation
+- ⚡ Lightning-fast performance with zero lag
+
+The CLI will automatically detect VS Code, Cursor, or Windsurf and install the appropriate extension. See the [VS Code extension documentation](https://github.com/rvben/rumdl/blob/main/docs/vscode-extension.md) for more details.
+
 ## Usage
 
 Getting started with rumdl is simple:
@@ -273,6 +298,14 @@ Start the Language Server Protocol server for editor integration
 - `--stdio`: Use stdio for communication (default)
 - `-v, --verbose`: Enable verbose logging
 
+#### `vscode [OPTIONS]`
+
+Install the rumdl VS Code extension
+
+**Options:**
+- `--force`: Force reinstall even if already installed
+- `--status`: Show installation status without installing
+
 #### `version`
 
 Show version information

rumdl-0.0.86/docs/vscode-extension.md

@@ -0,0 +1,94 @@
+# Rumdl VS Code Extension
+
+The rumdl VS Code extension provides real-time Markdown linting directly in your editor, powered by the same fast Rust-based engine as the rumdl CLI. With the new `rumdl vscode` command, you can install and manage the extension directly from your terminal.
+
+## Installation
+
+### Method 1: Using the rumdl CLI (Recommended)
+
+If you have rumdl installed, you can install the VS Code extension directly from the command line:
+
+```bash
+# Install the extension
+rumdl vscode
+
+# Check installation status
+rumdl vscode --status
+
+# Force reinstall if needed
+rumdl vscode --force
+```
+
+### Method 2: From VS Code Marketplace
+
+1. Open VS Code
+2. Go to Extensions (Ctrl/Cmd+Shift+X)
+3. Search for "rumdl"
+4. Click Install
+
+### Method 3: From Command Line
+
+```bash
+code --install-extension rvben.rumdl
+```
+
+## Features
+
+- **Real-time Linting**: Get instant feedback on Markdown issues as you type
+- **Quick Fixes**: One-click fixes for auto-fixable violations
+- **Full Rule Coverage**: All 50+ rumdl rules with proper categorization
+- **High Performance**: 5x faster than markdownlint
+- **Configuration Support**: Respects your `.rumdl.toml` configuration files
+- **Easy Installation**: Install directly from the CLI with `rumdl vscode`
+- **Multiple Editor Support**: Works with VS Code, Cursor, and Windsurf
+
+## Requirements
+
+- VS Code 1.74.0 or higher
+- rumdl CLI (optional, but recommended for full functionality)
+
+## Configuration
+
+The extension will automatically detect and use your project's `.rumdl.toml` configuration file. You can also configure the extension through VS Code settings:
+
+```json
+{
+  "rumdl.enable": true,
+  "rumdl.configPath": ".rumdl.toml",
+  "rumdl.server.logLevel": "info"
+}
+```
+
+## Troubleshooting
+
+### Extension Not Working
+
+1. Check if the extension is installed:
+   ```bash
+   rumdl vscode --status
+   ```
+
+2. Ensure VS Code's `code` command is in your PATH:
+   - On macOS: Open VS Code, press Cmd+Shift+P, and run "Shell Command: Install 'code' command in PATH"
+   - On Windows: This should be automatic during VS Code installation
+   - On Linux: Add VS Code's bin directory to your PATH
+
+3. Check the extension logs:
+   - Open VS Code's Output panel (View → Output)
+   - Select "rumdl" from the dropdown
+
+### VS Code Not Found
+
+If you get a "VS Code not found" error, make sure:
+
+1. VS Code is installed
+2. The `code` command is available in your terminal:
+   ```bash
+   code --version
+   ```
+
+## Related Links
+
+- [rumdl GitHub Repository](https://github.com/rvben/rumdl)
+- [VS Code Marketplace](https://marketplace.visualstudio.com/items?itemName=rumdl.rumdl)
+- [Configuration Guide](./global-settings.md)

rumdl-0.0.86/src/inline_config.rs

@@ -0,0 +1,363 @@
+//! Inline configuration comment handling for markdownlint compatibility
+//! 
+//! Supports:
+//! - `<!-- markdownlint-disable -->` - Disable all rules from this point
+//! - `<!-- markdownlint-enable -->` - Re-enable all rules from this point
+//! - `<!-- markdownlint-disable MD001 MD002 -->` - Disable specific rules
+//! - `<!-- markdownlint-enable MD001 MD002 -->` - Re-enable specific rules
+//! - `<!-- markdownlint-disable-line MD001 -->` - Disable rules for current line
+//! - `<!-- markdownlint-disable-next-line MD001 -->` - Disable rules for next line
+//! - `<!-- markdownlint-capture -->` - Capture current configuration state
+//! - `<!-- markdownlint-restore -->` - Restore captured configuration state
+//! 
+//! Also supports rumdl-specific syntax with same semantics.
+
+use std::collections::{HashMap, HashSet};
+
+#[derive(Debug, Clone)]
+pub struct InlineConfig {
+    /// Rules that are disabled at each line (1-indexed line -> set of disabled rules)
+    disabled_at_line: HashMap<usize, HashSet<String>>,
+    /// Rules disabled for specific lines via disable-line (1-indexed)
+    line_disabled_rules: HashMap<usize, HashSet<String>>,
+}
+
+impl InlineConfig {
+    pub fn new() -> Self {
+        Self {
+            disabled_at_line: HashMap::new(),
+            line_disabled_rules: HashMap::new(),
+        }
+    }
+
+    /// Process all inline comments in the content and return the configuration state
+    pub fn from_content(content: &str) -> Self {
+        let mut config = Self::new();
+        let lines: Vec<&str> = content.lines().collect();
+        
+        // Track current state of disabled rules
+        let mut currently_disabled = HashSet::new();
+        let mut capture_stack: Vec<HashSet<String>> = Vec::new();
+
+        for (idx, line) in lines.iter().enumerate() {
+            let line_num = idx + 1; // 1-indexed
+            
+            // Store the current state for this line BEFORE processing comments
+            // This way, comments on a line don't affect that same line
+            config.disabled_at_line.insert(line_num, currently_disabled.clone());
+
+            // Process comments in order of specificity to avoid conflicts
+            
+            // Check for disable-next-line first (more specific than disable)
+            if let Some(rules) = parse_disable_next_line_comment(line) {
+                let next_line = line_num + 1;
+                let line_rules = config.line_disabled_rules.entry(next_line).or_insert_with(HashSet::new);
+                if rules.is_empty() {
+                    // Disable all rules for next line
+                    line_rules.insert("*".to_string());
+                } else {
+                    for rule in rules {
+                        line_rules.insert(rule.to_string());
+                    }
+                }
+            }
+            // Check for disable-line (more specific than disable)
+            else if let Some(rules) = parse_disable_line_comment(line) {
+                let line_rules = config.line_disabled_rules.entry(line_num).or_insert_with(HashSet::new);
+                if rules.is_empty() {
+                    // Disable all rules for current line
+                    line_rules.insert("*".to_string());
+                } else {
+                    for rule in rules {
+                        line_rules.insert(rule.to_string());
+                    }
+                }
+            }
+            // Check for capture
+            else if is_capture_comment(line) {
+                capture_stack.push(currently_disabled.clone());
+            }
+            // Check for restore
+            else if is_restore_comment(line) {
+                if let Some(captured) = capture_stack.pop() {
+                    currently_disabled = captured;
+                }
+            }
+            // Check for disable (persistent)
+            else if let Some(rules) = parse_disable_comment(line) {
+                if rules.is_empty() {
+                    // Disable all rules - we'll use "*" as a marker
+                    currently_disabled.clear();
+                    currently_disabled.insert("*".to_string());
+                } else {
+                    for rule in rules {
+                        currently_disabled.insert(rule.to_string());
+                    }
+                }
+            }
+            // Check for enable (persistent)
+            else if let Some(rules) = parse_enable_comment(line) {
+                if rules.is_empty() {
+                    // Enable all rules
+                    currently_disabled.clear();
+                } else {
+                    // Enable specific rules
+                    for rule in rules {
+                        currently_disabled.remove(rule);
+                    }
+                }
+            }
+        }
+
+        config
+    }
+
+    /// Check if a rule is disabled at a specific line
+    pub fn is_rule_disabled(&self, rule_name: &str, line_number: usize) -> bool {
+        // Check line-specific disables first (disable-line, disable-next-line)
+        if let Some(line_rules) = self.line_disabled_rules.get(&line_number) {
+            if line_rules.contains("*") || line_rules.contains(rule_name) {
+                return true;
+            }
+        }
+
+        // Check persistent disables at this line
+        if let Some(disabled_set) = self.disabled_at_line.get(&line_number) {
+            disabled_set.contains("*") || disabled_set.contains(rule_name)
+        } else {
+            false
+        }
+    }
+
+    /// Get all disabled rules at a specific line
+    pub fn get_disabled_rules(&self, line_number: usize) -> HashSet<String> {
+        let mut disabled = HashSet::new();
+        
+        // Add persistent disables
+        if let Some(disabled_set) = self.disabled_at_line.get(&line_number) {
+            for rule in disabled_set {
+                disabled.insert(rule.clone());
+            }
+        }
+        
+        // Add line-specific disables
+        if let Some(line_rules) = self.line_disabled_rules.get(&line_number) {
+            for rule in line_rules {
+                disabled.insert(rule.clone());
+            }
+        }
+
+        disabled
+    }
+}
+
+/// Parse a disable comment and return the list of rules (empty vec means all rules)
+pub fn parse_disable_comment(line: &str) -> Option<Vec<&str>> {
+    // Check for both rumdl-disable and markdownlint-disable
+    for prefix in &["<!-- rumdl-disable", "<!-- markdownlint-disable"] {
+        if let Some(start) = line.find(prefix) {
+            let after_prefix = &line[start + prefix.len()..];
+
+            // Global disable: <!-- markdownlint-disable -->
+            if after_prefix.trim_start().starts_with("-->") {
+                return Some(Vec::new()); // Empty vec means all rules
+            }
+
+            // Rule-specific disable: <!-- markdownlint-disable MD001 MD002 -->
+            if let Some(end) = after_prefix.find("-->") {
+                let rules_str = after_prefix[..end].trim();
+                if !rules_str.is_empty() {
+                    let rules: Vec<&str> = rules_str.split_whitespace().collect();
+                    return Some(rules);
+                }
+            }
+        }
+    }
+
+    None
+}
+
+/// Parse an enable comment and return the list of rules (empty vec means all rules)
+pub fn parse_enable_comment(line: &str) -> Option<Vec<&str>> {
+    // Check for both rumdl-enable and markdownlint-enable
+    for prefix in &["<!-- rumdl-enable", "<!-- markdownlint-enable"] {
+        if let Some(start) = line.find(prefix) {
+            let after_prefix = &line[start + prefix.len()..];
+
+            // Global enable: <!-- markdownlint-enable -->
+            if after_prefix.trim_start().starts_with("-->") {
+                return Some(Vec::new()); // Empty vec means all rules
+            }
+
+            // Rule-specific enable: <!-- markdownlint-enable MD001 MD002 -->
+            if let Some(end) = after_prefix.find("-->") {
+                let rules_str = after_prefix[..end].trim();
+                if !rules_str.is_empty() {
+                    let rules: Vec<&str> = rules_str.split_whitespace().collect();
+                    return Some(rules);
+                }
+            }
+        }
+    }
+
+    None
+}
+
+/// Parse a disable-line comment
+pub fn parse_disable_line_comment(line: &str) -> Option<Vec<&str>> {
+    // Check for both rumdl and markdownlint variants
+    for prefix in &["<!-- rumdl-disable-line", "<!-- markdownlint-disable-line"] {
+        if let Some(start) = line.find(prefix) {
+            let after_prefix = &line[start + prefix.len()..];
+
+            // Global disable-line: <!-- markdownlint-disable-line -->
+            if after_prefix.trim_start().starts_with("-->") {
+                return Some(Vec::new()); // Empty vec means all rules
+            }
+
+            // Rule-specific disable-line: <!-- markdownlint-disable-line MD001 MD002 -->
+            if let Some(end) = after_prefix.find("-->") {
+                let rules_str = after_prefix[..end].trim();
+                if !rules_str.is_empty() {
+                    let rules: Vec<&str> = rules_str.split_whitespace().collect();
+                    return Some(rules);
+                }
+            }
+        }
+    }
+
+    None
+}
+
+/// Parse a disable-next-line comment
+pub fn parse_disable_next_line_comment(line: &str) -> Option<Vec<&str>> {
+    // Check for both rumdl and markdownlint variants
+    for prefix in &["<!-- rumdl-disable-next-line", "<!-- markdownlint-disable-next-line"] {
+        if let Some(start) = line.find(prefix) {
+            let after_prefix = &line[start + prefix.len()..];
+
+            // Global disable-next-line: <!-- markdownlint-disable-next-line -->
+            if after_prefix.trim_start().starts_with("-->") {
+                return Some(Vec::new()); // Empty vec means all rules
+            }
+
+            // Rule-specific disable-next-line: <!-- markdownlint-disable-next-line MD001 MD002 -->
+            if let Some(end) = after_prefix.find("-->") {
+                let rules_str = after_prefix[..end].trim();
+                if !rules_str.is_empty() {
+                    let rules: Vec<&str> = rules_str.split_whitespace().collect();
+                    return Some(rules);
+                }
+            }
+        }
+    }
+
+    None
+}
+
+/// Check if line contains a capture comment
+pub fn is_capture_comment(line: &str) -> bool {
+    line.contains("<!-- markdownlint-capture -->") || line.contains("<!-- rumdl-capture -->")
+}
+
+/// Check if line contains a restore comment
+pub fn is_restore_comment(line: &str) -> bool {
+    line.contains("<!-- markdownlint-restore -->") || line.contains("<!-- rumdl-restore -->")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_disable_comment() {
+        // Global disable
+        assert_eq!(parse_disable_comment("<!-- markdownlint-disable -->"), Some(vec![]));
+        assert_eq!(parse_disable_comment("<!-- rumdl-disable -->"), Some(vec![]));
+
+        // Specific rules
+        assert_eq!(
+            parse_disable_comment("<!-- markdownlint-disable MD001 MD002 -->"),
+            Some(vec!["MD001", "MD002"])
+        );
+
+        // No comment
+        assert_eq!(parse_disable_comment("Some regular text"), None);
+    }
+
+    #[test]
+    fn test_parse_disable_line_comment() {
+        // Global disable-line
+        assert_eq!(parse_disable_line_comment("<!-- markdownlint-disable-line -->"), Some(vec![]));
+
+        // Specific rules
+        assert_eq!(
+            parse_disable_line_comment("<!-- markdownlint-disable-line MD013 -->"),
+            Some(vec!["MD013"])
+        );
+
+        // No comment
+        assert_eq!(parse_disable_line_comment("Some regular text"), None);
+    }
+
+    #[test]
+    fn test_inline_config_from_content() {
+        let content = r#"# Test Document
+
+<!-- markdownlint-disable MD013 -->
+This is a very long line that would normally trigger MD013 but it's disabled
+
+<!-- markdownlint-enable MD013 -->
+This line will be checked again
+
+<!-- markdownlint-disable-next-line MD001 -->
+# This heading will not be checked for MD001
+## But this one will
+
+Some text <!-- markdownlint-disable-line MD013 -->
+
+<!-- markdownlint-capture -->
+<!-- markdownlint-disable MD001 MD002 -->
+# Heading with MD001 disabled
+<!-- markdownlint-restore -->
+# Heading with MD001 enabled again
+"#;
+
+        let config = InlineConfig::from_content(content);
+        
+        // Line 4 should have MD013 disabled (line after disable comment on line 3)
+        assert!(config.is_rule_disabled("MD013", 4));
+        
+        // Line 7 should have MD013 enabled (line after enable comment on line 6)
+        assert!(!config.is_rule_disabled("MD013", 7));
+
+        // Line 10 should have MD001 disabled (from disable-next-line on line 9)
+        assert!(config.is_rule_disabled("MD001", 10));
+
+        // Line 11 should not have MD001 disabled
+        assert!(!config.is_rule_disabled("MD001", 11));
+
+        // Line 13 should have MD013 disabled (from disable-line)
+        assert!(config.is_rule_disabled("MD013", 13));
+
+        // After restore (line 18), MD001 should be enabled again on line 19
+        assert!(!config.is_rule_disabled("MD001", 19));
+    }
+
+    #[test]
+    fn test_capture_restore() {
+        let content = r#"<!-- markdownlint-disable MD001 -->
+<!-- markdownlint-capture -->
+<!-- markdownlint-disable MD002 MD003 -->
+<!-- markdownlint-restore -->
+Some content after restore
+"#;
+
+        let config = InlineConfig::from_content(content);
+
+        // After restore (line 4), line 5 should only have MD001 disabled
+        assert!(config.is_rule_disabled("MD001", 5));
+        assert!(!config.is_rule_disabled("MD002", 5));
+        assert!(!config.is_rule_disabled("MD003", 5));
+    }
+}

{rumdl-0.0.85 → rumdl-0.0.86}/src/lib.rs

@@ -1,5 +1,6 @@
 pub mod config;
 pub mod init;
+pub mod inline_config;
 pub mod lint_context;
 pub mod lsp;
 pub mod markdownlint_config;
@@ -7,6 +8,7 @@ pub mod parallel;
 pub mod performance;
 pub mod profiling;
 pub mod rule;
+pub mod vscode;
 #[macro_use]
 pub mod rule_config;
 #[macro_use]
@@ -131,6 +133,9 @@ pub fn lint(content: &str, rules: &[Box<dyn Rule>], _verbose: bool) -> LintResul
         return Ok(warnings);
     }
 
+    // Parse inline configuration comments once
+    let inline_config = crate::inline_config::InlineConfig::from_content(content);
+
     // Analyze content characteristics for rule filtering
     let characteristics = ContentCharacteristics::analyze(content);
 
@@ -186,14 +191,13 @@ pub fn lint(content: &str, rules: &[Box<dyn Rule>], _verbose: bool) -> LintResul
 
         match result {
             Ok(rule_warnings) => {
-                // Filter out warnings for rules disabled via comments
+                // Filter out warnings for rules disabled via inline comments
                 let filtered_warnings: Vec<_> = rule_warnings
                     .into_iter()
                     .filter(|warning| {
-                        !crate::rule::is_rule_disabled_at_line(
-                            content,
+                        !inline_config.is_rule_disabled(
                             rule.name(),
-                            warning.line.saturating_sub(1), // Convert to 0-based line index
+                            warning.line, // Already 1-indexed
                         )
                     })
                     .collect();