mdbook-lint-core 0.14.3

Core linting engine for mdbook-lint - library for markdown linting with mdBook support
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

//! Core configuration types for mdbook-lint-core
//!
//! This module contains the minimal configuration types needed by the core
//! linting engine. The full configuration is handled by the CLI crate.

use serde::{Deserialize, Serialize};
use std::collections::HashMap;

/// Core configuration for the linting engine
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Config {
    /// List of enabled rule categories
    #[serde(rename = "enabled-categories", default)]
    pub enabled_categories: Vec<String>,

    /// List of disabled rule categories
    #[serde(rename = "disabled-categories", default)]
    pub disabled_categories: Vec<String>,

    /// List of explicitly enabled rules
    #[serde(rename = "enabled-rules", default)]
    pub enabled_rules: Vec<String>,

    /// List of explicitly disabled rules
    #[serde(rename = "disabled-rules", default)]
    pub disabled_rules: Vec<String>,

    /// How to handle deprecated rule warnings
    #[serde(rename = "deprecated-warning", default)]
    pub deprecated_warning: DeprecatedWarningLevel,

    /// Enable markdownlint compatibility mode (disables rules that are disabled by default in markdownlint)
    #[serde(rename = "markdownlint-compatible", default)]
    pub markdownlint_compatible: bool,

    /// Global auto-fix setting (default: true when --fix is used)
    /// Can be overridden per-rule in rule-specific configuration
    #[serde(rename = "auto-fix", default = "default_auto_fix")]
    pub auto_fix: bool,

    /// Rule-specific configuration
    #[serde(flatten)]
    pub rule_configs: HashMap<String, toml::Value>,
}

fn default_auto_fix() -> bool {
    true
}

impl Default for Config {
    fn default() -> Self {
        Self {
            enabled_categories: Vec::new(),
            disabled_categories: Vec::new(),
            enabled_rules: Vec::new(),
            disabled_rules: Vec::new(),
            deprecated_warning: DeprecatedWarningLevel::default(),
            markdownlint_compatible: false,
            auto_fix: true, // Default to true - fixes are applied when --fix is used
            rule_configs: HashMap::new(),
        }
    }
}

/// How to handle deprecated rule warnings
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
#[serde(rename_all = "lowercase")]
pub enum DeprecatedWarningLevel {
    /// Show warning messages for deprecated rules (default)
    #[default]
    Warn,
    /// Show info messages for deprecated rules
    Info,
    /// Don't show any messages for deprecated rules
    Silent,
}

impl Config {
    /// Check if a rule should be run based on configuration
    pub fn should_run_rule(
        &self,
        rule_id: &str,
        rule_category: &str,
        rule_enabled_by_default: bool,
    ) -> bool {
        // Explicit rule configuration takes precedence
        if self.enabled_rules.contains(&rule_id.to_string()) {
            return true;
        }
        if self.disabled_rules.contains(&rule_id.to_string()) {
            return false;
        }

        // Category configuration takes precedence over default
        if self.enabled_categories.contains(&rule_category.to_string()) {
            return true;
        }
        if self
            .disabled_categories
            .contains(&rule_category.to_string())
        {
            return false;
        }

        // Use default enabled state
        rule_enabled_by_default
    }

    /// Check if auto-fix is enabled for a specific rule
    ///
    /// Returns true if:
    /// 1. The rule has `auto-fix = true` in its config, OR
    /// 2. The rule has no `auto-fix` setting and global `auto-fix` is true (default)
    ///
    /// Returns false if:
    /// 1. The rule has `auto-fix = false` in its config, OR
    /// 2. The rule has no `auto-fix` setting and global `auto-fix` is false
    pub fn should_auto_fix_rule(&self, rule_id: &str) -> bool {
        // Check for rule-specific auto-fix setting
        if let Some(rule_config) = self.rule_configs.get(rule_id)
            && let Some(auto_fix) = rule_config.get("auto-fix").and_then(|v| v.as_bool())
        {
            return auto_fix;
        }

        // Fall back to global setting
        self.auto_fix
    }
}