rumdl 0.0.114__tar.gz → 0.0.116__tar.gz

{rumdl-0.0.114 → rumdl-0.0.116}/.config/nextest.toml

@@ -22,6 +22,10 @@ status-level = "pass"
 
 [profile.ci]
 
+# Skip performance tests in CI (they're flaky due to resource variability)
+# Exclude specific integration test binaries and performance-related test functions
+default-filter = 'not (package(rumdl) and binary(deeply_nested_lists_performance_test)) and not (package(rumdl) and binary(performance_validation_tests)) and not (package(rumdl) and binary(perf_check)) and not test(/performance|benchmark/)'
+
 # More conservative in CI
 test-threads = "num-cpus"
 
@@ -80,3 +84,23 @@ retries = 0
 
 # Fail fast on first failure
 fail-fast = true
+
+# Performance testing profile - for scheduled/manual runs
+[profile.performance]
+
+# Only run performance and benchmark tests
+default-filter = 'test(performance) or test(benchmark) or test(deeply_nested)'
+
+# Run tests serially to reduce noise
+test-threads = 1
+
+# Show detailed output
+failure-output = "immediate"
+success-output = "immediate"
+status-level = "all"
+
+# Allow retries for flaky tests
+retries = { backoff = "exponential", count = 3, delay = "1s", max-delay = "10s" }
+
+# Don't fail fast - run all performance tests
+fail-fast = false

{rumdl-0.0.114 → rumdl-0.0.116}/CHANGELOG.md

@@ -7,6 +7,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.116] - 2025-08-13
+
+### Added
+- Kramdown-style custom header IDs support (#44)
+  - Headers can now have custom IDs using the `{#custom-id}` syntax
+  - Custom IDs are preserved when fixing MD051 (link fragments)
+  - MD026 (trailing punctuation) now ignores headers with custom IDs
+  - Safe character validation: accepts Unicode letters/numbers, hyphens, underscores, and colons
+  - Rejects problematic characters like spaces, quotes, brackets, and HTML/CSS special chars
+
+### Fixed
+- Pre-release script now correctly handles dynamic versioning in pyproject.toml
+- Added Cargo.lock validation and `cargo publish --dry-run` checks to prevent release failures
+
+## [0.0.115] - 2025-08-12
+
 ## [0.0.114] - 2025-08-09
 
 ## [0.0.113] - 2025-08-09
@@ -308,7 +324,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Initial implementation of remaining rules for markdownlint parity
 
-[Unreleased]: https://github.com/rvben/rumdl/compare/v0.0.114...HEAD
+[Unreleased]: https://github.com/rvben/rumdl/compare/v0.0.116...HEAD
+[0.0.116]: https://github.com/rvben/rumdl/compare/v0.0.115...v0.0.116
+[0.0.115]: https://github.com/rvben/rumdl/compare/v0.0.114...v0.0.115
 [0.0.114]: https://github.com/rvben/rumdl/compare/v0.0.113...v0.0.114
 [0.0.113]: https://github.com/rvben/rumdl/compare/v0.0.112...v0.0.113
 [0.0.112]: https://github.com/rvben/rumdl/compare/v0.0.111...v0.0.112

{rumdl-0.0.114 → rumdl-0.0.116}/Cargo.lock

@@ -99,9 +99,9 @@ dependencies = [
 
 [[package]]
 name = "anyhow"
-version = "1.0.98"
+version = "1.0.99"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e16d2d3311acee920a9eb8d33b8cbc1787ce4a264e85f964c2404b969bdcd487"
+checksum = "b0674a1ddeecb70197781e945de4b3b8ffb61fa939a5597bcf48503737663100"
 
 [[package]]
 name = "assert_cmd"
@@ -277,9 +277,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.5.43"
+version = "4.5.45"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50fd97c9dc2399518aa331917ac6f274280ec5eb34e555dd291899745c48ec6f"
+checksum = "1fc0e74a703892159f5ae7d3aac52c8e6c392f5ae5f359c70b5881d60aaac318"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -287,9 +287,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.43"
+version = "4.5.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c35b5830294e1fa0462034af85cc95225a4cb07092c088c55bda3147cfcd8f65"
+checksum = "b3e7f4214277f3c7aa526a59dd3fbe306a370daee1f8b7b8c987069cd8e888a8"
 dependencies = [
  "anstream",
  "anstyle",
@@ -299,9 +299,9 @@ dependencies = [
 
 [[package]]
 name = "clap_derive"
-version = "4.5.41"
+version = "4.5.45"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ef4f52386a59ca4c860f7393bcf8abd8dfd91ecccc0f774635ff68e92eeef491"
+checksum = "14cb31bb0a7d536caef2639baa7fad459e15c3144efefa6dbd1c84562c4739f6"
 dependencies = [
  "heck",
  "proc-macro2",
@@ -951,9 +951,9 @@ checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 
 [[package]]
 name = "libc"
-version = "0.2.174"
+version = "0.2.175"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1171693293099992e19cddea4e8b849964e9846f4acee11b3948bcc337be8776"
+checksum = "6a82ae493e598baaea5209805c49bbf2ea7de956d50d7da0da1164f9c6d28543"
 
 [[package]]
 name = "linux-raw-sys"
@@ -1265,9 +1265,9 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.95"
+version = "1.0.97"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02b3e5e68a3a1a02aad3ec490a98007cbc13c37cbe84a3cd7b8e406d76e7f778"
+checksum = "d61789d7719defeb74ea5fe81f2fdfdbd28a803847077cecce2ff14e1472f6f1"
 dependencies = [
  "unicode-ident",
 ]
@@ -1493,7 +1493,7 @@ checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 
 [[package]]
 name = "rumdl"
-version = "0.0.114"
+version = "0.0.116"
 dependencies = [
  "anyhow",
  "assert_cmd",
@@ -1770,18 +1770,18 @@ checksum = "8f50febec83f5ee1df3015341d8bd429f2d1cc62bcba7ea2076759d315084683"
 
 [[package]]
 name = "thiserror"
-version = "2.0.12"
+version = "2.0.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "567b8a2dae586314f7be2a752ec7474332959c6460e02bde30d702a66d488708"
+checksum = "0b0949c3a6c842cbde3f1686d6eea5a010516deb7085f79db747562d4102f41e"
 dependencies = [
  "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "2.0.12"
+version = "2.0.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f7cf42b4507d8ea322120659672cf1b9dbb93f8f2d4ecfd6e51350ff5b17a1d"
+checksum = "cc5b44b4ab9c2fdd0e0512e6bece8388e214c0749f5862b114cc5b7a25daf227"
 dependencies = [
  "proc-macro2",
  "quote",

{rumdl-0.0.114 → rumdl-0.0.116}/Cargo.toml

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

{rumdl-0.0.114 → rumdl-0.0.116}/Makefile

@@ -101,6 +101,11 @@ test-push:
 test-ci:
 	cargo nextest run --profile ci
 
+test-performance:
+	@echo "Running performance tests (this may take a few minutes)..."
+	@echo "Tests run serially to reduce noise - be patient!"
+	cargo nextest run --profile performance
+
 clean:
 	cargo clean
 

{rumdl-0.0.114 → rumdl-0.0.116}/PKG-INFO

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

{rumdl-0.0.114 → rumdl-0.0.116}/scripts/pre-release.sh

@@ -73,15 +73,24 @@ run_check "Release build" "cargo build --release"
 echo "6. Checking documentation..."
 run_check "Documentation" "cargo doc --no-deps"
 
-# 7. Verify Cargo.toml version
+# 7. Verify Cargo.toml version (pyproject.toml uses dynamic versioning from Cargo.toml)
 echo "7. Checking version consistency..."
 CARGO_VERSION=$(grep '^version' Cargo.toml | head -1 | cut -d'"' -f2)
-PY_VERSION=$(grep '^version' pyproject.toml | head -1 | cut -d'"' -f2)
-if [ "$CARGO_VERSION" != "$PY_VERSION" ]; then
-    echo -e "${RED}Version mismatch: Cargo.toml ($CARGO_VERSION) vs pyproject.toml ($PY_VERSION)${NC}"
-    FAILED=1
+# pyproject.toml uses dynamic = ["version"] to read from Cargo.toml
+if grep -q 'dynamic = \["version"\]' pyproject.toml; then
+    echo -e "${GREEN}✓${NC} Version $CARGO_VERSION (pyproject.toml uses dynamic versioning)"
 else
-    echo -e "${GREEN}✓${NC} Version $CARGO_VERSION is consistent"
+    # Fallback: check if there's a static version in pyproject.toml
+    PY_VERSION=$(grep '^version' pyproject.toml | head -1 | cut -d'"' -f2)
+    if [ -z "$PY_VERSION" ]; then
+        echo -e "${YELLOW}⚠${NC} pyproject.toml should use dynamic = [\"version\"] for version"
+        # Not a failure, just a warning
+    elif [ "$CARGO_VERSION" != "$PY_VERSION" ]; then
+        echo -e "${RED}Version mismatch: Cargo.toml ($CARGO_VERSION) vs pyproject.toml ($PY_VERSION)${NC}"
+        FAILED=1
+    else
+        echo -e "${GREEN}✓${NC} Version $CARGO_VERSION is consistent"
+    fi
 fi
 
 # 8. Check for uncommitted changes
@@ -111,6 +120,20 @@ else
     echo -e "${GREEN}✓${NC} Tag $TAG_VERSION is available"
 fi
 
+# 11. Verify Cargo.lock is up to date
+echo "11. Verifying Cargo.lock is up to date..."
+if cargo update --workspace --dry-run 2>&1 | grep -q "Updating"; then
+    echo -e "${RED}✗ Cargo.lock needs updating${NC}"
+    echo "   Run: cargo update --workspace"
+    FAILED=1
+else
+    echo -e "${GREEN}✓${NC} Cargo.lock is up to date"
+fi
+
+# 12. Test cargo publish with --dry-run
+echo "12. Testing cargo publish (dry run)..."
+run_check "Cargo publish dry-run" "cargo publish --dry-run --locked"
+
 echo ""
 echo "====================================="
 if [ $FAILED -eq 0 ]; then

{rumdl-0.0.114 → rumdl-0.0.116}/src/config.rs

@@ -90,6 +90,16 @@ pub struct GlobalConfig {
     /// Output format for linting results (e.g., "text", "json", "pylint", etc.)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub output_format: Option<String>,
+
+    /// Rules that are allowed to be fixed when --fix is used
+    /// If specified, only these rules will be fixed
+    #[serde(default)]
+    pub fixable: Vec<String>,
+
+    /// Rules that should never be fixed, even when --fix is used
+    /// Takes precedence over fixable
+    #[serde(default)]
+    pub unfixable: Vec<String>,
 }
 
 fn default_respect_gitignore() -> bool {
@@ -111,6 +121,8 @@ impl Default for GlobalConfig {
             respect_gitignore: true,
             line_length: 80,
             output_format: None,
+            fixable: Vec::new(),
+            unfixable: Vec::new(),
         }
     }
 }
@@ -999,6 +1011,8 @@ pub struct SourcedGlobalConfig {
     pub respect_gitignore: SourcedValue<bool>,
     pub line_length: SourcedValue<u64>,
     pub output_format: Option<SourcedValue<String>>,
+    pub fixable: SourcedValue<Vec<String>>,
+    pub unfixable: SourcedValue<Vec<String>>,
 }
 
 impl Default for SourcedGlobalConfig {
@@ -1011,6 +1025,8 @@ impl Default for SourcedGlobalConfig {
             respect_gitignore: SourcedValue::new(true, ConfigSource::Default),
             line_length: SourcedValue::new(80, ConfigSource::Default),
             output_format: None,
+            fixable: SourcedValue::new(Vec::new(), ConfigSource::Default),
+            unfixable: SourcedValue::new(Vec::new(), ConfigSource::Default),
         }
     }
 }
@@ -1077,6 +1093,29 @@ impl SourcedConfig {
                 .and_then(|o| o.file.clone()),
             fragment.global.respect_gitignore.overrides.first().and_then(|o| o.line),
         );
+        self.global.line_length.merge_override(
+            fragment.global.line_length.value,
+            fragment.global.line_length.source,
+            fragment
+                .global
+                .line_length
+                .overrides
+                .first()
+                .and_then(|o| o.file.clone()),
+            fragment.global.line_length.overrides.first().and_then(|o| o.line),
+        );
+        self.global.fixable.merge_override(
+            fragment.global.fixable.value,
+            fragment.global.fixable.source,
+            fragment.global.fixable.overrides.first().and_then(|o| o.file.clone()),
+            fragment.global.fixable.overrides.first().and_then(|o| o.line),
+        );
+        self.global.unfixable.merge_override(
+            fragment.global.unfixable.value,
+            fragment.global.unfixable.source,
+            fragment.global.unfixable.overrides.first().and_then(|o| o.file.clone()),
+            fragment.global.unfixable.overrides.first().and_then(|o| o.line),
+        );
 
         // Merge output_format if present
         if let Some(output_format_fragment) = fragment.global.output_format {
@@ -1269,6 +1308,14 @@ impl SourcedConfig {
                 None,
                 None,
             );
+            sourced_config
+                .global
+                .fixable
+                .merge_override(cli.fixable.value.clone(), ConfigSource::Cli, None, None);
+            sourced_config
+                .global
+                .unfixable
+                .merge_override(cli.unfixable.value.clone(), ConfigSource::Cli, None, None);
             // No rule-specific CLI overrides implemented yet
         }
 
@@ -1298,6 +1345,8 @@ impl From<SourcedConfig> for Config {
             respect_gitignore: sourced.global.respect_gitignore.value,
             line_length: sourced.global.line_length.value,
             output_format: sourced.global.output_format.as_ref().map(|v| v.value.clone()),
+            fixable: sourced.global.fixable.value,
+            unfixable: sourced.global.unfixable.value,
         };
         Config { global, rules }
     }
@@ -1549,6 +1598,24 @@ fn parse_pyproject_toml(content: &str, path: &str) -> Result<Option<SourcedConfi
                     .push_override(value, source, file.clone(), None);
             }
         }
+        if let Some(fixable) = rumdl_table.get("fixable")
+            && let Ok(values) = Vec::<String>::deserialize(fixable.clone())
+        {
+            let normalized_values = values.into_iter().map(|s| normalize_key(&s)).collect();
+            fragment
+                .global
+                .fixable
+                .push_override(normalized_values, source, file.clone(), None);
+        }
+        if let Some(unfixable) = rumdl_table.get("unfixable")
+            && let Ok(values) = Vec::<String>::deserialize(unfixable.clone())
+        {
+            let normalized_values = values.into_iter().map(|s| normalize_key(&s)).collect();
+            fragment
+                .global
+                .unfixable
+                .push_override(normalized_values, source, file.clone(), None);
+        }
 
         // --- Re-introduce special line-length handling ---
         let mut found_line_length_val: Option<toml::Value> = None;
@@ -1590,6 +1657,8 @@ fn parse_pyproject_toml(content: &str, path: &str) -> Result<Option<SourcedConfi
                 "line-length",
                 "output_format",
                 "output-format",
+                "fixable",
+                "unfixable",
             ]
             .contains(&norm_rule_key.as_str())
             {
@@ -1683,6 +1752,9 @@ fn parse_pyproject_toml(content: &str, path: &str) -> Result<Option<SourcedConfi
         || !fragment.global.disable.value.is_empty()
         || !fragment.global.include.value.is_empty()
         || !fragment.global.exclude.value.is_empty()
+        || !fragment.global.fixable.value.is_empty()
+        || !fragment.global.unfixable.value.is_empty()
+        || fragment.global.output_format.is_some()
         || !fragment.rules.is_empty();
     if has_any { Ok(Some(fragment)) } else { Ok(None) }
 }
@@ -1820,6 +1892,46 @@ fn parse_rumdl_toml(content: &str, path: &str) -> Result<SourcedConfigFragment,
                         );
                     }
                 }
+                "fixable" => {
+                    if let Some(toml_edit::Value::Array(formatted_array)) = value_item.as_value() {
+                        let values: Vec<String> = formatted_array
+                            .iter()
+                            .filter_map(|item| item.as_str())
+                            .map(normalize_key)
+                            .collect();
+                        fragment
+                            .global
+                            .fixable
+                            .push_override(values, source, file.clone(), None);
+                    } else {
+                        log::warn!(
+                            "[WARN] Expected array for global key '{}' in {}, found {}",
+                            key,
+                            path,
+                            value_item.type_name()
+                        );
+                    }
+                }
+                "unfixable" => {
+                    if let Some(toml_edit::Value::Array(formatted_array)) = value_item.as_value() {
+                        let values: Vec<String> = formatted_array
+                            .iter()
+                            .filter_map(|item| item.as_str())
+                            .map(normalize_key)
+                            .collect();
+                        fragment
+                            .global
+                            .unfixable
+                            .push_override(values, source, file.clone(), None);
+                    } else {
+                        log::warn!(
+                            "[WARN] Expected array for global key '{}' in {}, found {}",
+                            key,
+                            path,
+                            value_item.type_name()
+                        );
+                    }
+                }
                 _ => {
                     // Add to unknown_keys for potential validation later
                     // fragment.unknown_keys.push(("[global]".to_string(), key.to_string()));

{rumdl-0.0.114 → rumdl-0.0.116}/src/lint_context.rs

@@ -197,8 +197,12 @@ pub struct HeadingInfo {
     pub marker_column: usize,
     /// Column where heading text starts
     pub content_column: usize,
-    /// The heading text (without markers)
+    /// The heading text (without markers and without custom ID syntax)
     pub text: String,
+    /// Custom header ID if present (e.g., from {#custom-id} syntax)
+    pub custom_id: Option<String>,
+    /// Original heading text including custom ID syntax
+    pub raw_text: String,
     /// Whether it has a closing sequence (for ATX)
     pub has_closing_sequence: bool,
     /// The closing sequence if present
@@ -1088,10 +1092,23 @@ impl<'a> LintContext<'a> {
                 let level = hashes.len() as u8;
                 let marker_column = leading_spaces.len();
 
-                // Check for closing sequence
+                // Check for closing sequence, but handle custom IDs that might come after
                 let (text, has_closing, closing_seq) = {
-                    // Find the start of a potential closing sequence
-                    let trimmed_rest = rest.trim_end();
+                    // First check if there's a custom ID at the end
+                    let (rest_without_id, custom_id_part) = if let Some(id_start) = rest.rfind(" {#") {
+                        // Check if this looks like a valid custom ID (ends with })
+                        if rest[id_start..].trim_end().ends_with('}') {
+                            // Split off the custom ID
+                            (&rest[..id_start], &rest[id_start..])
+                        } else {
+                            (rest, "")
+                        }
+                    } else {
+                        (rest, "")
+                    };
+
+                    // Now look for closing hashes in the part before the custom ID
+                    let trimmed_rest = rest_without_id.trim_end();
                     if let Some(last_hash_pos) = trimmed_rest.rfind('#') {
                         // Look for the start of the hash sequence
                         let mut start_of_hashes = last_hash_pos;
@@ -1099,32 +1116,55 @@ impl<'a> LintContext<'a> {
                             start_of_hashes -= 1;
                         }
 
-                        // Check if this is a valid closing sequence (all hashes to end of line)
+                        // Check if there's at least one space before the closing hashes
+                        let has_space_before = start_of_hashes == 0
+                            || trimmed_rest
+                                .chars()
+                                .nth(start_of_hashes - 1)
+                                .is_some_and(|c| c.is_whitespace());
+
+                        // Check if this is a valid closing sequence (all hashes to end of trimmed part)
                         let potential_closing = &trimmed_rest[start_of_hashes..];
                         let is_all_hashes = potential_closing.chars().all(|c| c == '#');
 
-                        if is_all_hashes {
-                            // This is a closing sequence, regardless of spacing
+                        if is_all_hashes && has_space_before {
+                            // This is a closing sequence
                             let closing_hashes = potential_closing.to_string();
-                            let text_part = rest[..start_of_hashes].trim_end();
-                            (text_part.to_string(), true, closing_hashes)
+                            // The text is everything before the closing hashes
+                            // Don't include the custom ID here - it will be extracted later
+                            let text_part = if !custom_id_part.is_empty() {
+                                // If we have a custom ID, append it back to get the full rest
+                                // This allows the extract_header_id function to handle it properly
+                                format!("{}{}", rest_without_id[..start_of_hashes].trim_end(), custom_id_part)
+                            } else {
+                                rest_without_id[..start_of_hashes].trim_end().to_string()
+                            };
+                            (text_part, true, closing_hashes)
                         } else {
+                            // Not a valid closing sequence, return the full content
                             (rest.to_string(), false, String::new())
                         }
                     } else {
+                        // No hashes found, return the full content
                         (rest.to_string(), false, String::new())
                     }
                 };
 
                 let content_column = marker_column + hashes.len() + spaces_after.len();
 
+                // Extract custom header ID if present
+                let raw_text = text.trim().to_string();
+                let (clean_text, custom_id) = crate::utils::kramdown_utils::extract_header_id(&raw_text);
+
                 lines[i].heading = Some(HeadingInfo {
                     level,
                     style: HeadingStyle::ATX,
                     marker: hashes.to_string(),
                     marker_column,
                     content_column,
-                    text: text.trim().to_string(),
+                    text: clean_text,
+                    custom_id,
+                    raw_text,
                     has_closing_sequence: has_closing,
                     closing_sequence: closing_seq,
                 });
@@ -1146,13 +1186,19 @@ impl<'a> LintContext<'a> {
                         HeadingStyle::Setext2
                     };
 
+                    // Extract custom header ID if present
+                    let raw_text = line.trim().to_string();
+                    let (clean_text, custom_id) = crate::utils::kramdown_utils::extract_header_id(&raw_text);
+
                     lines[i].heading = Some(HeadingInfo {
                         level,
                         style,
                         marker: underline.to_string(),
                         marker_column: next_line.len() - next_line.trim_start().len(),
                         content_column: lines[i].indent,
-                        text: line.trim().to_string(),
+                        text: clean_text,
+                        custom_id,
+                        raw_text,
                         has_closing_sequence: false,
                         closing_sequence: String::new(),
                     });

{rumdl-0.0.114 → rumdl-0.0.116}/src/main.rs

@@ -2044,6 +2044,7 @@ fn run_check(args: &CheckArgs, global_config_path: Option<&str>, no_config: bool
                         quiet,
                         &output_format,
                         &output_writer,
+                        &config,
                     )
                 })
                 .collect();
@@ -2098,6 +2099,7 @@ fn run_check(args: &CheckArgs, global_config_path: Option<&str>, no_config: bool
                         quiet,
                         &output_format,
                         &output_writer,
+                        &config,
                     );
 
                 total_files_processed += 1;
@@ -2354,6 +2356,7 @@ fn print_statistics(warnings: &[rumdl::rule::LintWarning]) {
 }
 
 // Process file with output formatter
+#[allow(clippy::too_many_arguments)]
 fn process_file_with_formatter(
     file_path: &str,
     rules: &[Box<dyn Rule>],
@@ -2362,6 +2365,7 @@ fn process_file_with_formatter(
     quiet: bool,
     output_format: &rumdl::output::OutputFormat,
     output_writer: &rumdl::output::OutputWriter,
+    config: &rumdl_config::Config,
 ) -> (bool, usize, usize, usize, Vec<rumdl::rule::LintWarning>) {
     let formatter = output_format.create_formatter();
 
@@ -2387,7 +2391,7 @@ fn process_file_with_formatter(
     // Fix issues if requested
     let mut warnings_fixed = 0;
     if _fix {
-        warnings_fixed = apply_fixes(rules, &all_warnings, &mut content, file_path, quiet);
+        warnings_fixed = apply_fixes(rules, &all_warnings, &mut content, file_path, quiet, config);
 
         // In fix mode, show warnings with [fixed] for issues that were fixed
         if !quiet {
@@ -2528,6 +2532,7 @@ fn apply_fixes(
     content: &mut String,
     file_path: &str,
     quiet: bool,
+    config: &rumdl_config::Config,
 ) -> usize {
     let mut warnings_fixed = 0;
 
@@ -2549,6 +2554,26 @@ fn apply_fixes(
             });
 
             if has_non_disabled_warnings {
+                // Check fixable/unfixable configuration
+                let rule_name = rule.name();
+
+                // If unfixable list contains this rule, skip fixing
+                if config
+                    .global
+                    .unfixable
+                    .iter()
+                    .any(|r| r.eq_ignore_ascii_case(rule_name))
+                {
+                    continue;
+                }
+
+                // If fixable list is specified and doesn't contain this rule, skip fixing
+                if !config.global.fixable.is_empty()
+                    && !config.global.fixable.iter().any(|r| r.eq_ignore_ascii_case(rule_name))
+                {
+                    continue;
+                }
+
                 let ctx = LintContext::new(content);
                 match rule.fix(&ctx) {
                     Ok(fixed_content) => {