flowmark 0.3.1

A Markdown auto-formatter for clean diffs and semantic line breaks
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

//! Configuration types for file resolution.

use super::defaults::{DEFAULT_EXCLUDES, DEFAULT_INCLUDES};

/// Configuration for file discovery and filtering.
///
/// `tool_name` determines the ignore file name (e.g., `.flowmarkignore`).
/// `exclude = None` means use `DEFAULT_EXCLUDES`; providing a list replaces them entirely.
/// `files_max_size = 0` disables the size limit.
#[derive(Debug, Clone)]
pub struct FileResolverConfig {
    /// Tool name, determines ignore file name (e.g., `.flowmarkignore`).
    pub tool_name: String,
    /// Base include patterns.
    pub include: Vec<String>,
    /// Additional include patterns.
    pub extend_include: Vec<String>,
    /// Override default exclude patterns. `None` = use `DEFAULT_EXCLUDES`.
    pub exclude: Option<Vec<String>>,
    /// Additional exclude patterns.
    pub extend_exclude: Vec<String>,
    /// Whether to respect `.gitignore` files.
    pub respect_gitignore: bool,
    /// Apply exclusions to explicitly named files.
    pub force_exclude: bool,
    /// Maximum file size in bytes. 0 = no limit.
    pub files_max_size: u64,
}

impl Default for FileResolverConfig {
    fn default() -> Self {
        Self {
            tool_name: "flowmark".to_string(),
            include: DEFAULT_INCLUDES.iter().map(|s| (*s).to_string()).collect(),
            extend_include: Vec::new(),
            exclude: None,
            extend_exclude: Vec::new(),
            respect_gitignore: true,
            force_exclude: false,
            files_max_size: 1_048_576, // 1 MiB
        }
    }
}

impl FileResolverConfig {
    /// Combined include patterns: `include + extend_include`.
    pub fn effective_include(&self) -> Vec<String> {
        let mut result = self.include.clone();
        result.extend(self.extend_include.clone());
        result
    }

    /// Combined exclude patterns: defaults (or `exclude`) + `extend_exclude`.
    pub fn effective_exclude(&self) -> Vec<String> {
        let base: Vec<String> = if let Some(ref exclude) = self.exclude {
            exclude.clone()
        } else {
            DEFAULT_EXCLUDES.iter().map(|s| (*s).to_string()).collect()
        };
        let mut result = base;
        result.extend(self.extend_exclude.clone());
        result
    }
}