rumdl_lib/config/
types.rs

1use crate::types::LineLength;
2use globset::{Glob, GlobBuilder, GlobMatcher, GlobSet, GlobSetBuilder};
3use indexmap::IndexMap;
4use serde::{Deserialize, Serialize};
5use std::collections::BTreeMap;
6use std::collections::{HashMap, HashSet};
7use std::fs;
8use std::io;
9use std::path::Path;
10use std::sync::{Arc, OnceLock};
11
12use super::flavor::{MarkdownFlavor, normalize_key};
13
14/// Represents a rule-specific configuration
15#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, schemars::JsonSchema)]
16pub struct RuleConfig {
17    /// Severity override for this rule (Error, Warning, or Info)
18    #[serde(default, skip_serializing_if = "Option::is_none")]
19    pub severity: Option<crate::rule::Severity>,
20
21    /// Configuration values for the rule
22    #[serde(flatten)]
23    #[schemars(schema_with = "arbitrary_value_schema")]
24    pub values: BTreeMap<String, toml::Value>,
25}
26
27/// Generate a JSON schema for arbitrary configuration values
28fn arbitrary_value_schema(_gen: &mut schemars::SchemaGenerator) -> schemars::Schema {
29    schemars::json_schema!({
30        "type": "object",
31        "additionalProperties": true
32    })
33}
34
35/// Represents the complete configuration loaded from rumdl.toml
36#[derive(Debug, Clone, Serialize, Deserialize, Default, schemars::JsonSchema)]
37#[schemars(
38    description = "rumdl configuration for linting Markdown files. Rules can be configured individually using [MD###] sections with rule-specific options."
39)]
40pub struct Config {
41    /// Path to a base config file to inherit settings from.
42    /// Supports relative paths, absolute paths, and `~/` for home directory.
43    /// Example: `extends = "../base.rumdl.toml"`
44    #[serde(default, skip_serializing_if = "Option::is_none")]
45    pub extends: Option<String>,
46
47    /// Global configuration options
48    #[serde(default)]
49    pub global: GlobalConfig,
50
51    /// Per-file rule ignores: maps file patterns to lists of rules to ignore
52    /// Example: { "README.md": ["MD033"], "docs/**/*.md": ["MD013"] }
53    #[serde(default, rename = "per-file-ignores")]
54    pub per_file_ignores: HashMap<String, Vec<String>>,
55
56    /// Per-file flavor overrides: maps file patterns to Markdown flavors
57    /// Example: { "docs/**/*.md": MkDocs, "**/*.mdx": MDX }
58    /// Uses IndexMap to preserve config file order for "first match wins" semantics
59    #[serde(default, rename = "per-file-flavor")]
60    #[schemars(with = "HashMap<String, MarkdownFlavor>")]
61    pub per_file_flavor: IndexMap<String, MarkdownFlavor>,
62
63    /// Code block tools configuration for per-language linting and formatting
64    /// using external tools like ruff, prettier, shellcheck, etc.
65    #[serde(default, rename = "code-block-tools")]
66    pub code_block_tools: crate::code_block_tools::CodeBlockToolsConfig,
67
68    /// Rule-specific configurations (e.g., MD013, MD007, MD044)
69    /// Each rule section can contain options specific to that rule.
70    ///
71    /// Common examples:
72    /// - MD013: line_length, code_blocks, tables, headings
73    /// - MD007: indent
74    /// - MD003: style ("atx", "atx-closed", "setext")
75    /// - MD044: names (array of proper names to check)
76    ///
77    /// See <https://github.com/rvben/rumdl> for full rule documentation.
78    #[serde(flatten)]
79    pub rules: BTreeMap<String, RuleConfig>,
80
81    /// Project root directory, used for resolving relative paths in per-file-ignores
82    #[serde(skip)]
83    pub project_root: Option<std::path::PathBuf>,
84
85    #[serde(skip)]
86    #[schemars(skip)]
87    pub(super) per_file_ignores_cache: Arc<OnceLock<PerFileIgnoreCache>>,
88
89    #[serde(skip)]
90    #[schemars(skip)]
91    pub(super) per_file_flavor_cache: Arc<OnceLock<PerFileFlavorCache>>,
92}
93
94impl PartialEq for Config {
95    fn eq(&self, other: &Self) -> bool {
96        self.global == other.global
97            && self.per_file_ignores == other.per_file_ignores
98            && self.per_file_flavor == other.per_file_flavor
99            && self.code_block_tools == other.code_block_tools
100            && self.rules == other.rules
101            && self.project_root == other.project_root
102    }
103}
104
105#[derive(Debug)]
106pub(super) struct PerFileIgnoreCache {
107    globset: GlobSet,
108    rules: Vec<Vec<String>>,
109}
110
111#[derive(Debug)]
112pub(super) struct PerFileFlavorCache {
113    matchers: Vec<(GlobMatcher, MarkdownFlavor)>,
114}
115
116impl Config {
117    /// Check if the Markdown flavor is set to MkDocs
118    pub fn is_mkdocs_flavor(&self) -> bool {
119        self.global.flavor == MarkdownFlavor::MkDocs
120    }
121
122    // Future methods for when GFM and CommonMark are implemented:
123    // pub fn is_gfm_flavor(&self) -> bool
124    // pub fn is_commonmark_flavor(&self) -> bool
125
126    /// Get the configured Markdown flavor
127    pub fn markdown_flavor(&self) -> MarkdownFlavor {
128        self.global.flavor
129    }
130
131    /// Legacy method for backwards compatibility - redirects to is_mkdocs_flavor
132    pub fn is_mkdocs_project(&self) -> bool {
133        self.is_mkdocs_flavor()
134    }
135
136    /// Apply per-rule `enabled` config to the global enable/disable lists.
137    ///
138    /// For `[MD060] enabled = true`: adds the rule to `extend_enable` and
139    /// removes it from `disable` and `extend_disable`, ensuring the rule is active.
140    ///
141    /// For `[MD041] enabled = false`: adds the rule to `disable` and
142    /// removes it from `extend_enable`, ensuring the rule is inactive.
143    ///
144    /// Per-rule `enabled` takes precedence over global lists when there
145    /// is a conflict, since it represents a more specific intent.
146    pub fn apply_per_rule_enabled(&mut self) {
147        let mut to_enable: Vec<String> = Vec::new();
148        let mut to_disable: Vec<String> = Vec::new();
149
150        for (name, cfg) in &self.rules {
151            match cfg.values.get("enabled") {
152                Some(toml::Value::Boolean(true)) => {
153                    to_enable.push(name.clone());
154                }
155                Some(toml::Value::Boolean(false)) => {
156                    to_disable.push(name.clone());
157                }
158                _ => {}
159            }
160        }
161
162        for name in to_enable {
163            if !self.global.extend_enable.contains(&name) {
164                self.global.extend_enable.push(name.clone());
165            }
166            self.global.disable.retain(|n| n != &name);
167            self.global.extend_disable.retain(|n| n != &name);
168        }
169
170        for name in to_disable {
171            if !self.global.disable.contains(&name) {
172                self.global.disable.push(name.clone());
173            }
174            self.global.extend_enable.retain(|n| n != &name);
175        }
176    }
177
178    /// Get the severity override for a specific rule, if configured
179    pub fn get_rule_severity(&self, rule_name: &str) -> Option<crate::rule::Severity> {
180        self.rules.get(rule_name).and_then(|r| r.severity)
181    }
182
183    /// Get the set of rules that should be ignored for a specific file based on per-file-ignores configuration
184    /// Returns a HashSet of rule names (uppercase, e.g., "MD033") that match the given file path
185    pub fn get_ignored_rules_for_file(&self, file_path: &Path) -> HashSet<String> {
186        let mut ignored_rules = HashSet::new();
187
188        if self.per_file_ignores.is_empty() {
189            return ignored_rules;
190        }
191
192        // Normalize the file path to be relative to project_root for pattern matching
193        // This ensures patterns like ".github/file.md" work with absolute paths
194        let path_for_matching: std::borrow::Cow<'_, Path> = if let Some(ref root) = self.project_root {
195            if let Ok(canonical_path) = file_path.canonicalize() {
196                if let Ok(canonical_root) = root.canonicalize() {
197                    if let Ok(relative) = canonical_path.strip_prefix(&canonical_root) {
198                        std::borrow::Cow::Owned(relative.to_path_buf())
199                    } else {
200                        std::borrow::Cow::Borrowed(file_path)
201                    }
202                } else {
203                    std::borrow::Cow::Borrowed(file_path)
204                }
205            } else {
206                std::borrow::Cow::Borrowed(file_path)
207            }
208        } else {
209            std::borrow::Cow::Borrowed(file_path)
210        };
211
212        let cache = self
213            .per_file_ignores_cache
214            .get_or_init(|| PerFileIgnoreCache::new(&self.per_file_ignores));
215
216        // Match the file path against all patterns
217        for match_idx in cache.globset.matches(path_for_matching.as_ref()) {
218            if let Some(rules) = cache.rules.get(match_idx) {
219                for rule in rules {
220                    // Normalize rule names to uppercase (MD033, md033 -> MD033)
221                    ignored_rules.insert(rule.clone());
222                }
223            }
224        }
225
226        ignored_rules
227    }
228
229    /// Get the MarkdownFlavor for a specific file based on per-file-flavor configuration.
230    /// Returns the first matching pattern's flavor, or falls back to global flavor,
231    /// or auto-detects from extension, or defaults to Standard.
232    pub fn get_flavor_for_file(&self, file_path: &Path) -> MarkdownFlavor {
233        // If no per-file patterns, use fallback logic
234        if self.per_file_flavor.is_empty() {
235            return self.resolve_flavor_fallback(file_path);
236        }
237
238        // Normalize path for matching (same logic as get_ignored_rules_for_file)
239        let path_for_matching: std::borrow::Cow<'_, Path> = if let Some(ref root) = self.project_root {
240            if let Ok(canonical_path) = file_path.canonicalize() {
241                if let Ok(canonical_root) = root.canonicalize() {
242                    if let Ok(relative) = canonical_path.strip_prefix(&canonical_root) {
243                        std::borrow::Cow::Owned(relative.to_path_buf())
244                    } else {
245                        std::borrow::Cow::Borrowed(file_path)
246                    }
247                } else {
248                    std::borrow::Cow::Borrowed(file_path)
249                }
250            } else {
251                std::borrow::Cow::Borrowed(file_path)
252            }
253        } else {
254            std::borrow::Cow::Borrowed(file_path)
255        };
256
257        let cache = self
258            .per_file_flavor_cache
259            .get_or_init(|| PerFileFlavorCache::new(&self.per_file_flavor));
260
261        // Iterate in config order and return first match (IndexMap preserves order)
262        for (matcher, flavor) in &cache.matchers {
263            if matcher.is_match(path_for_matching.as_ref()) {
264                return *flavor;
265            }
266        }
267
268        // No pattern matched, use fallback
269        self.resolve_flavor_fallback(file_path)
270    }
271
272    /// Fallback flavor resolution: global flavor → auto-detect → Standard
273    fn resolve_flavor_fallback(&self, file_path: &Path) -> MarkdownFlavor {
274        // If global flavor is explicitly set to non-Standard, use it
275        if self.global.flavor != MarkdownFlavor::Standard {
276            return self.global.flavor;
277        }
278        // Auto-detect from extension
279        MarkdownFlavor::from_path(file_path)
280    }
281
282    /// Merge inline configuration overrides into a copy of this config
283    ///
284    /// This enables automatic inline config support - the engine can merge
285    /// inline overrides and recreate rules without any per-rule changes.
286    ///
287    /// Returns a new Config with the inline overrides merged in.
288    /// If there are no inline overrides, returns a clone of self.
289    pub fn merge_with_inline_config(&self, inline_config: &crate::inline_config::InlineConfig) -> Self {
290        let overrides = inline_config.get_all_rule_configs();
291        if overrides.is_empty() {
292            return self.clone();
293        }
294
295        let mut merged = self.clone();
296
297        for (rule_name, json_override) in overrides {
298            // Get or create the rule config entry
299            let rule_config = merged.rules.entry(rule_name.clone()).or_default();
300
301            // Merge JSON values into the rule's config
302            if let Some(obj) = json_override.as_object() {
303                for (key, value) in obj {
304                    // Normalize key to kebab-case for consistency
305                    let normalized_key = key.replace('_', "-");
306
307                    // Convert JSON value to TOML value
308                    if let Some(toml_value) = json_to_toml(value) {
309                        rule_config.values.insert(normalized_key, toml_value);
310                    }
311                }
312            }
313        }
314
315        merged
316    }
317}
318
319/// Convert a serde_json::Value to a toml::Value
320pub(super) fn json_to_toml(json: &serde_json::Value) -> Option<toml::Value> {
321    match json {
322        serde_json::Value::Null => None,
323        serde_json::Value::Bool(b) => Some(toml::Value::Boolean(*b)),
324        serde_json::Value::Number(n) => n
325            .as_i64()
326            .map(toml::Value::Integer)
327            .or_else(|| n.as_f64().map(toml::Value::Float)),
328        serde_json::Value::String(s) => Some(toml::Value::String(s.clone())),
329        serde_json::Value::Array(arr) => {
330            let toml_arr: Vec<toml::Value> = arr.iter().filter_map(json_to_toml).collect();
331            Some(toml::Value::Array(toml_arr))
332        }
333        serde_json::Value::Object(obj) => {
334            let mut table = toml::map::Map::new();
335            for (k, v) in obj {
336                if let Some(tv) = json_to_toml(v) {
337                    table.insert(k.clone(), tv);
338                }
339            }
340            Some(toml::Value::Table(table))
341        }
342    }
343}
344
345impl PerFileIgnoreCache {
346    fn new(per_file_ignores: &HashMap<String, Vec<String>>) -> Self {
347        let mut builder = GlobSetBuilder::new();
348        let mut rules = Vec::new();
349
350        for (pattern, rules_list) in per_file_ignores {
351            if let Ok(glob) = Glob::new(pattern) {
352                builder.add(glob);
353                rules.push(rules_list.iter().map(|rule| normalize_key(rule)).collect());
354            } else {
355                log::warn!("Invalid glob pattern in per-file-ignores: {pattern}");
356            }
357        }
358
359        let globset = builder.build().unwrap_or_else(|e| {
360            log::error!("Failed to build globset for per-file-ignores: {e}");
361            GlobSetBuilder::new().build().unwrap()
362        });
363
364        Self { globset, rules }
365    }
366}
367
368impl PerFileFlavorCache {
369    fn new(per_file_flavor: &IndexMap<String, MarkdownFlavor>) -> Self {
370        let mut matchers = Vec::new();
371
372        for (pattern, flavor) in per_file_flavor {
373            if let Ok(glob) = GlobBuilder::new(pattern).literal_separator(true).build() {
374                matchers.push((glob.compile_matcher(), *flavor));
375            } else {
376                log::warn!("Invalid glob pattern in per-file-flavor: {pattern}");
377            }
378        }
379
380        Self { matchers }
381    }
382}
383
384/// Global configuration options
385#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, schemars::JsonSchema)]
386#[serde(default, rename_all = "kebab-case")]
387pub struct GlobalConfig {
388    /// Enabled rules
389    #[serde(default)]
390    pub enable: Vec<String>,
391
392    /// Disabled rules
393    #[serde(default)]
394    pub disable: Vec<String>,
395
396    /// Files to exclude
397    #[serde(default)]
398    pub exclude: Vec<String>,
399
400    /// Files to include
401    #[serde(default)]
402    pub include: Vec<String>,
403
404    /// Respect .gitignore files when scanning directories
405    #[serde(default = "default_respect_gitignore", alias = "respect_gitignore")]
406    pub respect_gitignore: bool,
407
408    /// Global line length setting (used by MD013 and other rules if not overridden)
409    #[serde(default, alias = "line_length")]
410    pub line_length: LineLength,
411
412    /// Output format for linting results (e.g., "text", "json", "pylint", etc.)
413    #[serde(skip_serializing_if = "Option::is_none", alias = "output_format")]
414    pub output_format: Option<String>,
415
416    /// Rules that are allowed to be fixed when --fix is used
417    /// If specified, only these rules will be fixed
418    #[serde(default)]
419    pub fixable: Vec<String>,
420
421    /// Rules that should never be fixed, even when --fix is used
422    /// Takes precedence over fixable
423    #[serde(default)]
424    pub unfixable: Vec<String>,
425
426    /// Markdown flavor/dialect to use (mkdocs, gfm, commonmark, etc.)
427    /// When set, adjusts parsing and validation rules for that specific Markdown variant
428    #[serde(default)]
429    pub flavor: MarkdownFlavor,
430
431    /// \[DEPRECATED\] Whether to enforce exclude patterns for explicitly passed paths.
432    /// This option is deprecated as of v0.0.156 and has no effect.
433    /// Exclude patterns are now always respected, even for explicitly provided files.
434    /// This prevents duplication between rumdl config and tool configs like pre-commit.
435    #[serde(default, alias = "force_exclude")]
436    #[deprecated(since = "0.0.156", note = "Exclude patterns are now always respected")]
437    pub force_exclude: bool,
438
439    /// Directory to store cache files (default: .rumdl_cache)
440    /// Can also be set via --cache-dir CLI flag or RUMDL_CACHE_DIR environment variable
441    #[serde(default, alias = "cache_dir", skip_serializing_if = "Option::is_none")]
442    pub cache_dir: Option<String>,
443
444    /// Whether caching is enabled (default: true)
445    /// Can also be disabled via --no-cache CLI flag
446    #[serde(default = "default_true")]
447    pub cache: bool,
448
449    /// Additional rules to enable on top of the base set (additive)
450    #[serde(default, alias = "extend_enable")]
451    pub extend_enable: Vec<String>,
452
453    /// Additional rules to disable on top of the base set (additive)
454    #[serde(default, alias = "extend_disable")]
455    pub extend_disable: Vec<String>,
456
457    /// Whether the enable list was explicitly set (even if empty).
458    /// Used to distinguish "no enable list configured" from "enable list is empty"
459    /// (e.g., markdownlint `default: false` with no rules enabled).
460    #[serde(skip)]
461    pub enable_is_explicit: bool,
462}
463
464fn default_respect_gitignore() -> bool {
465    true
466}
467
468fn default_true() -> bool {
469    true
470}
471
472// Add the Default impl
473impl Default for GlobalConfig {
474    #[allow(deprecated)]
475    fn default() -> Self {
476        Self {
477            enable: Vec::new(),
478            disable: Vec::new(),
479            exclude: Vec::new(),
480            include: Vec::new(),
481            respect_gitignore: true,
482            line_length: LineLength::default(),
483            output_format: None,
484            fixable: Vec::new(),
485            unfixable: Vec::new(),
486            flavor: MarkdownFlavor::default(),
487            force_exclude: false,
488            cache_dir: None,
489            cache: true,
490            extend_enable: Vec::new(),
491            extend_disable: Vec::new(),
492            enable_is_explicit: false,
493        }
494    }
495}
496
497/// Names of rumdl-native config files, searched in precedence order when
498/// walking up a directory tree.
499///
500/// This is the single source of truth for config discovery. Both the CLI
501/// (`SourcedConfig::discover_config_upward`, `discover_config_for_dir`) and
502/// the LSP (`RumdlLanguageServer::resolve_config_for_file`) must use this
503/// list; any deviation causes silent config-not-found bugs where the CLI
504/// recognises a config but the LSP does not (or vice versa).
505///
506/// See `src/lsp/tests.rs::test_lsp_cli_resolver_parity_on_fixtures` for
507/// the side-by-side resolver parity test that pins this invariant across
508/// several directory layouts.
509pub const RUMDL_CONFIG_FILES: &[&str] = &[".rumdl.toml", "rumdl.toml", ".config/rumdl.toml", "pyproject.toml"];
510
511pub const MARKDOWNLINT_CONFIG_FILES: &[&str] = &[
512    ".markdownlint-cli2.jsonc",
513    ".markdownlint-cli2.yaml",
514    ".markdownlint-cli2.yml",
515    ".markdownlint.json",
516    ".markdownlint.jsonc",
517    ".markdownlint.yaml",
518    ".markdownlint.yml",
519    "markdownlint.json",
520    "markdownlint.jsonc",
521    "markdownlint.yaml",
522    "markdownlint.yml",
523];
524
525/// Create a default configuration file at the specified path
526pub fn create_default_config(path: &str) -> Result<(), ConfigError> {
527    create_preset_config("default", path)
528}
529
530/// Create a configuration file with a specific style preset
531pub fn create_preset_config(preset: &str, path: &str) -> Result<(), ConfigError> {
532    if Path::new(path).exists() {
533        return Err(ConfigError::FileExists { path: path.to_string() });
534    }
535
536    let config_content = match preset {
537        "default" => generate_default_preset(),
538        "google" => generate_google_preset(),
539        "relaxed" => generate_relaxed_preset(),
540        _ => {
541            return Err(ConfigError::UnknownPreset {
542                name: preset.to_string(),
543            });
544        }
545    };
546
547    match fs::write(path, config_content) {
548        Ok(_) => Ok(()),
549        Err(err) => Err(ConfigError::IoError {
550            source: err,
551            path: path.to_string(),
552        }),
553    }
554}
555
556/// Generate the default preset configuration content.
557/// Returns the same content as `create_default_config`.
558fn generate_default_preset() -> String {
559    r#"# rumdl configuration file
560
561# Inherit settings from another config file (relative to this file's directory)
562# extends = "../base.rumdl.toml"
563
564# Global configuration options
565[global]
566# List of rules to disable (uncomment and modify as needed)
567# disable = ["MD013", "MD033"]
568
569# List of rules to enable exclusively (replaces defaults; only these rules will run)
570# enable = ["MD001", "MD003", "MD004"]
571
572# Additional rules to enable on top of defaults (additive, does not replace)
573# Use this to activate opt-in rules like MD060, MD063, MD072, MD073, MD074
574# extend-enable = ["MD060", "MD063"]
575
576# Additional rules to disable on top of the disable list (additive)
577# extend-disable = ["MD041"]
578
579# List of file/directory patterns to include for linting (if provided, only these will be linted)
580# include = [
581#    "docs/*.md",
582#    "src/**/*.md",
583#    "README.md"
584# ]
585
586# List of file/directory patterns to exclude from linting
587exclude = [
588    # Common directories to exclude
589    ".git",
590    ".github",
591    "node_modules",
592    "vendor",
593    "dist",
594    "build",
595
596    # Specific files or patterns
597    "CHANGELOG.md",
598    "LICENSE.md",
599]
600
601# Respect .gitignore files when scanning directories (default: true)
602respect-gitignore = true
603
604# Markdown flavor/dialect (uncomment to enable)
605# Options: standard (default), gfm, commonmark, mkdocs, mdx, quarto
606# flavor = "mkdocs"
607
608# Rule-specific configurations (uncomment and modify as needed)
609
610# [MD003]
611# style = "atx"  # Heading style (atx, atx_closed, setext)
612
613# [MD004]
614# style = "asterisk"  # Unordered list style (asterisk, plus, dash, consistent)
615
616# [MD007]
617# indent = 4  # Unordered list indentation
618
619# [MD013]
620# line-length = 100  # Line length
621# code-blocks = false  # Exclude code blocks from line length check
622# tables = false  # Exclude tables from line length check
623# headings = true  # Include headings in line length check
624
625# [MD044]
626# names = ["rumdl", "Markdown", "GitHub"]  # Proper names that should be capitalized correctly
627# code-blocks = false  # Check code blocks for proper names (default: false, skips code blocks)
628"#
629    .to_string()
630}
631
632/// Generate Google developer documentation style preset.
633/// Based on https://google.github.io/styleguide/docguide/style.html
634fn generate_google_preset() -> String {
635    r#"# rumdl configuration - Google developer documentation style
636# Based on https://google.github.io/styleguide/docguide/style.html
637
638[global]
639exclude = [
640    ".git",
641    ".github",
642    "node_modules",
643    "vendor",
644    "dist",
645    "build",
646    "CHANGELOG.md",
647    "LICENSE.md",
648]
649respect-gitignore = true
650
651# ATX-style headings required
652[MD003]
653style = "atx"
654
655# Unordered list style: dash
656[MD004]
657style = "dash"
658
659# 4-space indent for nested lists
660[MD007]
661indent = 4
662
663# Strict mode: no trailing spaces allowed (Google uses backslash for line breaks)
664[MD009]
665strict = true
666
667# 80-character line length
668[MD013]
669line-length = 80
670code-blocks = false
671tables = false
672
673# No trailing punctuation in headings
674[MD026]
675punctuation = ".,;:!。，；：！"
676
677# Fenced code blocks only (no indented code blocks)
678[MD046]
679style = "fenced"
680
681# Emphasis with underscores
682[MD049]
683style = "underscore"
684
685# Strong with asterisks
686[MD050]
687style = "asterisk"
688"#
689    .to_string()
690}
691
692/// Generate relaxed preset for existing projects adopting rumdl incrementally.
693/// Longer line lengths, fewer rules, lenient settings to minimize initial warnings.
694fn generate_relaxed_preset() -> String {
695    r#"# rumdl configuration - Relaxed preset
696# Lenient settings for existing projects adopting rumdl incrementally.
697# Minimizes initial warnings while still catching important issues.
698
699[global]
700exclude = [
701    ".git",
702    ".github",
703    "node_modules",
704    "vendor",
705    "dist",
706    "build",
707    "CHANGELOG.md",
708    "LICENSE.md",
709]
710respect-gitignore = true
711
712# Disable rules that produce the most noise on existing projects
713disable = [
714    "MD013",  # Line length - most existing files exceed 80 chars
715    "MD033",  # Inline HTML - commonly used in real-world markdown
716    "MD041",  # First line heading - not all files need it
717]
718
719# Consistent heading style (any style, just be consistent)
720[MD003]
721style = "consistent"
722
723# Consistent list style
724[MD004]
725style = "consistent"
726
727# Consistent emphasis style
728[MD049]
729style = "consistent"
730
731# Consistent strong style
732[MD050]
733style = "consistent"
734"#
735    .to_string()
736}
737
738/// Errors that can occur when loading configuration
739#[derive(Debug, thiserror::Error)]
740pub enum ConfigError {
741    /// Failed to read the configuration file
742    #[error("Failed to read config file at {path}: {source}")]
743    IoError { source: io::Error, path: String },
744
745    /// Failed to parse the configuration content (TOML or JSON)
746    #[error("Failed to parse config: {0}")]
747    ParseError(String),
748
749    /// Configuration file already exists
750    #[error("Configuration file already exists at {path}")]
751    FileExists { path: String },
752
753    /// Circular extends reference detected
754    #[error("Circular extends reference: {path} already in chain {chain:?}")]
755    CircularExtends { path: String, chain: Vec<String> },
756
757    /// Extends chain exceeds maximum depth
758    #[error("Extends chain exceeds maximum depth of {max_depth} at {path}")]
759    ExtendsDepthExceeded { path: String, max_depth: usize },
760
761    /// Extends target file not found
762    #[error("extends target not found: {path} (referenced from {from})")]
763    ExtendsNotFound { path: String, from: String },
764
765    /// Unknown preset name
766    #[error("Unknown preset: {name}. Valid presets: default, google, relaxed")]
767    UnknownPreset { name: String },
768}
769
770/// Get a rule-specific configuration value
771/// Automatically tries both the original key and normalized variants (kebab-case ↔ snake_case)
772/// for better markdownlint compatibility
773pub fn get_rule_config_value<T: serde::de::DeserializeOwned>(config: &Config, rule_name: &str, key: &str) -> Option<T> {
774    let norm_rule_name = rule_name.to_ascii_uppercase(); // Use uppercase for lookup
775
776    let rule_config = config.rules.get(&norm_rule_name)?;
777
778    // Try multiple key variants to support both underscore and kebab-case formats
779    let key_variants = [
780        key.to_string(),       // Original key as provided
781        normalize_key(key),    // Normalized key (lowercase, kebab-case)
782        key.replace('-', "_"), // Convert kebab-case to snake_case
783        key.replace('_', "-"), // Convert snake_case to kebab-case
784    ];
785
786    // Try each variant until we find a match
787    for variant in &key_variants {
788        if let Some(value) = rule_config.values.get(variant)
789            && let Ok(result) = T::deserialize(value.clone())
790        {
791            return Some(result);
792        }
793    }
794
795    None
796}
797
798/// Generate preset configuration for pyproject.toml format.
799/// Converts the .rumdl.toml preset to pyproject.toml section format.
800pub fn generate_pyproject_preset_config(preset: &str) -> Result<String, ConfigError> {
801    match preset {
802        "default" => Ok(generate_pyproject_config()),
803        other => {
804            let rumdl_config = match other {
805                "google" => generate_google_preset(),
806                "relaxed" => generate_relaxed_preset(),
807                _ => {
808                    return Err(ConfigError::UnknownPreset {
809                        name: other.to_string(),
810                    });
811                }
812            };
813            Ok(convert_rumdl_to_pyproject(&rumdl_config))
814        }
815    }
816}
817
818/// Convert a .rumdl.toml config string to pyproject.toml format.
819/// Rewrites `[global]` → `[tool.rumdl]` and `[MDXXX]` → `[tool.rumdl.MDXXX]`.
820fn convert_rumdl_to_pyproject(rumdl_config: &str) -> String {
821    let mut output = String::with_capacity(rumdl_config.len() + 128);
822    for line in rumdl_config.lines() {
823        let trimmed = line.trim();
824        if trimmed.starts_with('[') && trimmed.ends_with(']') && !trimmed.starts_with("# [") {
825            let section = &trimmed[1..trimmed.len() - 1];
826            if section == "global" {
827                output.push_str("[tool.rumdl]");
828            } else {
829                output.push_str(&format!("[tool.rumdl.{section}]"));
830            }
831        } else {
832            output.push_str(line);
833        }
834        output.push('\n');
835    }
836    output
837}
838
839/// Generate default rumdl configuration for pyproject.toml
840pub fn generate_pyproject_config() -> String {
841    let config_content = r#"
842[tool.rumdl]
843# Global configuration options
844line-length = 100
845disable = []
846# extend-enable = ["MD060"]  # Add opt-in rules (additive, keeps defaults)
847# extend-disable = []  # Additional rules to disable (additive)
848exclude = [
849    # Common directories to exclude
850    ".git",
851    ".github",
852    "node_modules",
853    "vendor",
854    "dist",
855    "build",
856]
857respect-gitignore = true
858
859# Rule-specific configurations (uncomment and modify as needed)
860
861# [tool.rumdl.MD003]
862# style = "atx"  # Heading style (atx, atx_closed, setext)
863
864# [tool.rumdl.MD004]
865# style = "asterisk"  # Unordered list style (asterisk, plus, dash, consistent)
866
867# [tool.rumdl.MD007]
868# indent = 4  # Unordered list indentation
869
870# [tool.rumdl.MD013]
871# line-length = 100  # Line length
872# code-blocks = false  # Exclude code blocks from line length check
873# tables = false  # Exclude tables from line length check
874# headings = true  # Include headings in line length check
875
876# [tool.rumdl.MD044]
877# names = ["rumdl", "Markdown", "GitHub"]  # Proper names that should be capitalized correctly
878# code-blocks = false  # Check code blocks for proper names (default: false, skips code blocks)
879"#;
880
881    config_content.to_string()
882}
rumdl_lib/config/types.rs

rumdl_lib/config/
types.rs
