rumdl 0.0.55__tar.gz → 0.0.57__tar.gz

{rumdl-0.0.55 → rumdl-0.0.57}/Cargo.lock

@@ -1385,7 +1385,7 @@ dependencies = [
 
 [[package]]
 name = "rumdl"
-version = "0.0.55"
+version = "0.0.57"
 dependencies = [
  "anyhow",
  "assert_cmd",

{rumdl-0.0.55 → rumdl-0.0.57}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rumdl"
-version = "0.0.55"
+version = "0.0.57"
 edition = "2021"
 description = "A fast Markdown linter written in Rust (Ru(st) MarkDown Linter)"
 authors = ["Ruben J. Jongejan <ruben.jongejan@gmail.com>"]

{rumdl-0.0.55 → rumdl-0.0.57}/PKG-INFO

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

{rumdl-0.0.55 → rumdl-0.0.57}/benches/rule_performance.rs

@@ -1,8 +1,8 @@
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use rumdl::rule::Rule;
 use rumdl::rules::{
-    MD013LineLength, MD015NoMissingSpaceAfterListMarker, MD033NoInlineHtml, MD037NoSpaceInEmphasis,
-    MD044ProperNames, MD051LinkFragments, MD053LinkImageReferenceDefinitions,
+    MD013LineLength, MD033NoInlineHtml, MD037NoSpaceInEmphasis, MD044ProperNames, MD051LinkFragments,
+    MD053LinkImageReferenceDefinitions,
 };
 
 /// Benchmark MD013 rule on a large content with long lines
@@ -16,20 +16,11 @@ fn bench_md013(c: &mut Criterion) {
     let rule = MD013LineLength::default();
 
     c.bench_function("MD013 check 100 long lines", |b| {
-        b.iter(|| rule.check(black_box(&content)))
+        b.iter(|| rule.check(&rumdl::lint_context::LintContext::new(&content)))
     });
 
     c.bench_function("MD013 fix 100 long lines", |b| {
-        b.iter(|| rule.fix(black_box(&content)))
-    });
-}
-
-/// Benchmark MD015 rule on a large content with list items
-fn bench_md015(c: &mut Criterion) {
-    let rule = MD015NoMissingSpaceAfterListMarker::new();
-    let content = "-Item 1\n*Item 2\n+Item 3".repeat(1000);
-    c.bench_function("MD015 fix 1000 items", |b| {
-        b.iter(|| rule.fix(black_box(&content)))
+        b.iter(|| rule.fix(&rumdl::lint_context::LintContext::new(&content)))
     });
 }
 
@@ -44,7 +35,7 @@ fn bench_md033(c: &mut Criterion) {
     let rule = MD033NoInlineHtml::default();
 
     c.bench_function("MD033 check 500 HTML tags", |b| {
-        b.iter(|| rule.check(black_box(&content)))
+        b.iter(|| rule.check(&rumdl::lint_context::LintContext::new(&content)))
     });
 }
 
@@ -68,11 +59,11 @@ fn bench_md037(c: &mut Criterion) {
     let rule = MD037NoSpaceInEmphasis;
 
     c.bench_function("MD037 check 500 emphasis markers", |b| {
-        b.iter(|| rule.check(black_box(&content)))
+        b.iter(|| rule.check(&rumdl::lint_context::LintContext::new(&content)))
     });
 
     c.bench_function("MD037 fix 500 emphasis markers", |b| {
-        b.iter(|| rule.fix(black_box(&content)))
+        b.iter(|| rule.fix(&rumdl::lint_context::LintContext::new(&content)))
     });
 }
 
@@ -117,11 +108,11 @@ fn bench_md044(c: &mut Criterion) {
     let rule = MD044ProperNames::new(proper_names, true); // true = exclude code blocks
 
     c.bench_function("MD044 check 500 proper name occurrences", |b| {
-        b.iter(|| rule.check(black_box(&content)))
+        b.iter(|| rule.check(&rumdl::lint_context::LintContext::new(&content)))
     });
 
     c.bench_function("MD044 fix 500 proper name occurrences", |b| {
-        b.iter(|| rule.fix(black_box(&content)))
+        b.iter(|| rule.fix(&rumdl::lint_context::LintContext::new(&content)))
     });
 }
 
@@ -155,7 +146,7 @@ fn bench_md051(c: &mut Criterion) {
     let rule = MD051LinkFragments::new();
 
     c.bench_function("MD051 check 500 link fragments", |b| {
-        b.iter(|| rule.check(black_box(&content)))
+        b.iter(|| rule.check(&rumdl::lint_context::LintContext::new(&content)))
     });
 }
 
@@ -190,7 +181,7 @@ fn bench_md053(c: &mut Criterion) {
     c.bench_function("MD053 check cold cache", |b| {
         b.iter_with_setup(
             MD053LinkImageReferenceDefinitions::default, // Create a new instance for each iteration
-            |r| r.check(black_box(&content)),
+            |r| r.check(&rumdl::lint_context::LintContext::new(&content)),
         )
     });
 
@@ -198,21 +189,20 @@ fn bench_md053(c: &mut Criterion) {
     c.bench_function("MD053 check warm cache", |b| {
         // First, prime the cache
         let primed_rule = rule.clone();
-        let _ = primed_rule.check(&content);
+        let _ = primed_rule.check(&rumdl::lint_context::LintContext::new(&content));
 
         // Then benchmark with warm cache
-        b.iter(|| primed_rule.check(black_box(&content)))
+        b.iter(|| primed_rule.check(&rumdl::lint_context::LintContext::new(&content)))
     });
 
     c.bench_function("MD053 fix unused references", |b| {
-        b.iter(|| rule.fix(black_box(&content)))
+        b.iter(|| rule.fix(&rumdl::lint_context::LintContext::new(&content)))
     });
 }
 
 criterion_group!(
     benches,
     bench_md013,
-    bench_md015,
     bench_md033,
     bench_md037,
     bench_md044,

{rumdl-0.0.55 → rumdl-0.0.57}/docs/RULES.md

@@ -82,7 +82,7 @@ Each rule has a brief description and a link to its detailed documentation.
 
 | Rule ID | Rule Name | Description |
 |---------|-----------|-------------|
-| [MD014](md014.md) | Commands show output | Dollar signs used before commands without showing output |
+| [MD014](md014.md) | Commands show output | Code blocks should show output when appropriate |
 | [MD040](md040.md) | Fenced code language | Fenced code blocks should have a language specified |
 | [MD046](md046.md) | Code block style | Code block style |
 | [MD048](md048.md) | Code fence style | Code fence style |
@@ -111,7 +111,6 @@ Each rule has a brief description and a link to its detailed documentation.
 
 | Rule ID | Rule Name | Description |
 |---------|-----------|-------------|
-| [MD015](md015.md) | No multiple space list | Multiple spaces after list marker |
 | [MD057](md057.md) | Relative links | Relative links should exist |
 
 ## Using Rules

{rumdl-0.0.55 → rumdl-0.0.57}/docs/md030.md

@@ -2,10 +2,12 @@
 
 ## Description
 
-This rule ensures that there is a consistent number of spaces between list markers and the list content.  
-By default, ordered lists should have one space after the list marker, and unordered lists should have  
+This rule ensures that there is a consistent number of spaces between list markers and the list content.
+By default, ordered lists should have one space after the list marker, and unordered lists should have
 one space after the list marker.
 
+**Note:** This rule covers multiple spaces (e.g., `*  Item`) after list markers, but does **not** warn for missing space (e.g., `*Item`) after the marker. Lines like `*Item` are not considered valid list items per CommonMark and markdownlint, and are ignored.
+
 Consistent spacing improves readability and ensures proper rendering across different Markdown processors.
 
 <!-- markdownlint-disable -->

rumdl-0.0.57/parity_check.py

@@ -0,0 +1,211 @@
+#!/usr/bin/env python3
+import subprocess
+import json
+import sys
+from pathlib import Path
+import os
+
+PARITY_CORPUS = Path(__file__).parent / "parity_corpus"
+RUMDL_BIN = "cargo run --bin rumdl --"
+MARKDOWNLINT_BIN = "markdownlint"
+
+
+def run_rumdl(md_file):
+    # Use --no-config to ensure no config is loaded (use built-in defaults only)
+    cmd = f"{RUMDL_BIN} check '{md_file}' -o json --no-config"
+    result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
+    if result.returncode != 0 and not result.stdout.strip():
+        print(f"[rumdl] Error running on {md_file}: {result.stderr}")
+        return []
+    try:
+        return json.loads(result.stdout)
+    except Exception as e:
+        print(f"[rumdl] Failed to parse JSON for {md_file}: {e}")
+        return []
+
+def run_markdownlint(md_file):
+    cmd = ["npx", MARKDOWNLINT_BIN, str(md_file), "--json"]
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if result.returncode not in (0, 1):
+        print(f"[markdownlint] Error running on {md_file}: {result.stderr}")
+        return []
+
+    # markdownlint outputs JSON to stderr when using --json flag
+    output = result.stderr.strip() if result.stderr.strip() else result.stdout.strip()
+    if output:
+        try:
+            return json.loads(output)
+        except Exception as e:
+            print(f"[markdownlint] Failed to parse JSON for {md_file}: {e}")
+            print(f"[markdownlint] output for {md_file}:")
+            print(output)
+    return []
+
+def normalize_rumdl(warning, file):
+    """Normalize rumdl warning to common format"""
+    return {
+        "file": str(file.relative_to(Path.cwd())),  # Convert to relative path
+        "line": warning.get("line"),
+        "column": warning.get("column", 1),
+        "rule": warning.get("rule_name"),
+        "message": warning.get("message"),
+        "fix": warning.get("fix"),
+    }
+
+def normalize_markdownlint(warning):
+    """Normalize markdownlint warning to common format"""
+    file_path = warning.get("fileName")
+    # Convert absolute paths to relative if possible
+    if file_path and file_path.startswith('/'):
+        try:
+            file_path = str(Path(file_path).relative_to(Path.cwd()))
+        except ValueError:
+            # If the path is not relative to cwd, keep it as is
+            pass
+
+    return {
+        "file": file_path,
+        "line": warning.get("lineNumber"),
+        "column": (warning.get("errorRange") or [1])[0] if warning.get("errorRange") else 1,
+        "rule": warning.get("ruleNames", [None])[0],
+        "message": warning.get("ruleDescription"),
+        "fix": warning.get("fixInfo"),
+    }
+
+def compare_warnings(rumdl_warnings, markdownlint_warnings):
+    # Sort by (line, rule) for comparison - ignore column and message differences
+    def key(w):
+        return (
+            w.get("line", 0),
+            w.get("rule", "")
+        )
+    r_sorted = sorted(rumdl_warnings, key=key)
+    m_sorted = sorted(markdownlint_warnings, key=key)
+
+    # Compare based on file, line, and rule only
+    def warning_key(w):
+        return (w.get("file"), w.get("line"), w.get("rule"))
+
+    r_set = set(warning_key(w) for w in r_sorted)
+    m_set = set(warning_key(w) for w in m_sorted)
+
+    only_in_rumdl = r_set - m_set
+    only_in_markdownlint = m_set - r_set
+    common = r_set & m_set
+
+    if not only_in_rumdl and not only_in_markdownlint:
+        print("All warnings match!")
+        return True
+
+    if only_in_rumdl:
+        print(f"  Warnings only in rumdl ({len(only_in_rumdl)}):")
+        for key in list(only_in_rumdl)[:3]:  # Show fewer to reduce noise
+            file, line, rule = key
+            # Find the actual warning for context
+            warning = next((w for w in rumdl_warnings if w.get('file') == file and w.get('line') == line and w.get('rule') == rule), None)
+            message = warning.get('message', 'No message') if warning else 'No message'
+            print(f"    Line {line}: {rule} - {message}")
+        if len(only_in_rumdl) > 3:
+            print(f"    ...and {len(only_in_rumdl) - 3} more.")
+    if only_in_markdownlint:
+        print(f"  Warnings only in markdownlint ({len(only_in_markdownlint)}):")
+        for key in list(only_in_markdownlint)[:3]:  # Show fewer to reduce noise
+            file, line, rule = key
+            # Find the actual warning for context
+            warning = next((w for w in markdownlint_warnings if w.get('file') == file and w.get('line') == line and w.get('rule') == rule), None)
+            message = warning.get('message', 'No message') if warning else 'No message'
+            print(f"    Line {line}: {rule} - {message}")
+        if len(only_in_markdownlint) > 3:
+            print(f"    ...and {len(only_in_markdownlint) - 3} more.")
+    print(f"  Common warnings: {len(r_set & m_set)}")
+    return False
+
+def main():
+    md_files = sorted(PARITY_CORPUS.glob("*.md"))
+    if not md_files:
+        print("No markdown files found in parity_corpus/")
+        sys.exit(1)
+
+    all_passed = True
+    total_common = 0
+    total_rumdl_only = 0
+    total_markdownlint_only = 0
+
+    for md_file in md_files:
+        print(f"\n=== {md_file} ===")
+        rumdl_raw = run_rumdl(md_file)
+        markdownlint_raw = run_markdownlint(md_file)
+
+        rumdl_norm = [normalize_rumdl(w, md_file) for w in rumdl_raw]
+        markdownlint_norm = [normalize_markdownlint(w) for w in markdownlint_raw]
+
+        # Filter markdownlint warnings to only include the current file
+        file_relative = str(md_file.relative_to(Path.cwd()))
+        file_absolute = str(md_file.absolute())
+        markdownlint_norm = [w for w in markdownlint_norm if w.get("file") in (file_relative, file_absolute)]
+
+        # Sort by (line, rule) for comparison - ignore column and message differences
+        def key(w):
+            return (
+                w.get("line", 0),
+                w.get("rule", "")
+            )
+        r_sorted = sorted(rumdl_norm, key=key)
+        m_sorted = sorted(markdownlint_norm, key=key)
+
+        # Compare based on file, line, and rule only
+        def warning_key(w):
+            return (w.get("file"), w.get("line"), w.get("rule"))
+
+        r_set = set(warning_key(w) for w in r_sorted)
+        m_set = set(warning_key(w) for w in m_sorted)
+
+        only_in_rumdl = r_set - m_set
+        only_in_markdownlint = m_set - r_set
+        common = r_set & m_set
+
+        total_common += len(common)
+        total_rumdl_only += len(only_in_rumdl)
+        total_markdownlint_only += len(only_in_markdownlint)
+
+        if not only_in_rumdl and not only_in_markdownlint:
+            print("✓ All warnings match!")
+        else:
+            print("✗ Mismatches found:")
+            if only_in_rumdl:
+                print(f"  Warnings only in rumdl ({len(only_in_rumdl)}):")
+                for key in list(only_in_rumdl)[:3]:  # Show fewer to reduce noise
+                    file, line, rule = key
+                    # Find the actual warning for context
+                    warning = next((w for w in rumdl_norm if w.get('file') == file and w.get('line') == line and w.get('rule') == rule), None)
+                    message = warning.get('message', 'No message') if warning else 'No message'
+                    print(f"    Line {line}: {rule} - {message}")
+                if len(only_in_rumdl) > 3:
+                    print(f"    ...and {len(only_in_rumdl) - 3} more.")
+            if only_in_markdownlint:
+                print(f"  Warnings only in markdownlint ({len(only_in_markdownlint)}):")
+                for key in list(only_in_markdownlint)[:3]:  # Show fewer to reduce noise
+                    file, line, rule = key
+                    # Find the actual warning for context
+                    warning = next((w for w in markdownlint_norm if w.get('file') == file and w.get('line') == line and w.get('rule') == rule), None)
+                    message = warning.get('message', 'No message') if warning else 'No message'
+                    print(f"    Line {line}: {rule} - {message}")
+                if len(only_in_markdownlint) > 3:
+                    print(f"    ...and {len(only_in_markdownlint) - 3} more.")
+            print(f"  Common warnings: {len(common)}")
+            all_passed = False
+
+    print(f"\n=== SUMMARY ===")
+    print(f"Total common warnings: {total_common}")
+    print(f"Total rumdl-only warnings: {total_rumdl_only}")
+    print(f"Total markdownlint-only warnings: {total_markdownlint_only}")
+
+    if all_passed:
+        print("✓ All files match between rumdl and markdownlint!")
+        sys.exit(0)
+    else:
+        print("✗ Some files have mismatches.")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()