mod analyzer_configs;
mod processor_configs;
mod variables;
#[cfg(test)]
mod tests;
pub(crate) use analyzer_configs::*;
pub(crate) use processor_configs::*;
use anyhow::{Context, Result};
use serde::{Deserialize, Serialize};
use sha2::{Digest, Sha256};
use std::collections::HashMap;
use std::fs;
use std::path::{Path, PathBuf};
use crate::errors;
use crate::processors::names as processor_names;
use variables::substitute_variables;
const CONFIG_FILE: &str = "rsconstruct.toml";
pub(crate) trait KnownFields {
fn known_fields() -> &'static [&'static str];
}
pub(crate) fn resolve_extra_inputs(extra_inputs: &[String]) -> Result<Vec<PathBuf>> {
let mut resolved = Vec::new();
for p in extra_inputs {
let path = PathBuf::from(p);
if !path.exists() {
anyhow::bail!("extra_inputs file not found: {}", p);
}
resolved.push(path);
}
Ok(resolved)
}
pub(crate) fn config_hash(value: &impl Serialize) -> String {
let json = serde_json::to_string(value).expect(errors::CONFIG_SERIALIZE);
let hash = Sha256::digest(json.as_bytes());
hex::encode(hash)
}
#[derive(Debug, Deserialize, Serialize, Clone)]
pub(crate) struct ScanConfig {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub scan_dir: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub extensions: Option<Vec<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub exclude_dirs: Option<Vec<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub exclude_files: Option<Vec<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub exclude_paths: Option<Vec<String>>,
}
impl ScanConfig {
pub(crate) fn resolve(&mut self, scan_dir: &str, extensions: &[&str], exclude_dirs: &[&str]) {
if self.scan_dir.is_none() {
self.scan_dir = Some(scan_dir.to_string());
}
if self.extensions.is_none() {
self.extensions = Some(extensions.iter().map(|s| s.to_string()).collect());
}
if self.exclude_dirs.is_none() {
self.exclude_dirs = Some(exclude_dirs.iter().map(|s| s.to_string()).collect());
}
if self.exclude_files.is_none() {
self.exclude_files = Some(Vec::new());
}
if self.exclude_paths.is_none() {
self.exclude_paths = Some(Vec::new());
}
}
pub(crate) fn scan_dir(&self) -> &str {
self.scan_dir.as_deref().expect(errors::SCAN_CONFIG_NOT_RESOLVED)
}
pub(crate) fn extensions(&self) -> &[String] {
self.extensions.as_deref().expect(errors::SCAN_CONFIG_NOT_RESOLVED)
}
pub(crate) fn exclude_dirs(&self) -> &[String] {
self.exclude_dirs.as_deref().expect(errors::SCAN_CONFIG_NOT_RESOLVED)
}
pub(crate) fn exclude_files(&self) -> &[String] {
self.exclude_files.as_deref().expect(errors::SCAN_CONFIG_NOT_RESOLVED)
}
pub(crate) fn exclude_paths(&self) -> &[String] {
self.exclude_paths.as_deref().expect(errors::SCAN_CONFIG_NOT_RESOLVED)
}
}
const COMMON_EXCLUDE_DIRS: &[&str] = &["/.git/", "/out/", "/build/", "/dist/"];
const BUILD_TOOL_EXCLUDES: &[&str] = &[
"/.git/", "/out/", "/build/", "/dist/",
"/.rsconstruct/", "/node_modules/", "/target/", "/gems/",
];
const PYTHON_EXCLUDE_DIRS: &[&str] = &[
"/.git/", "/out/", "/build/", "/dist/",
"/.venv/", "/__pycache__/", "/node_modules/", "/.tox/", "/.eggs/",
];
const CC_EXCLUDE_DIRS: &[&str] = COMMON_EXCLUDE_DIRS;
const SPELLCHECK_EXCLUDE_DIRS: &[&str] = BUILD_TOOL_EXCLUDES;
const SHELL_EXCLUDE_DIRS: &[&str] = BUILD_TOOL_EXCLUDES;
const MARKDOWN_EXCLUDE_DIRS: &[&str] = BUILD_TOOL_EXCLUDES;
const MAKE_CARGO_EXCLUDES: &[&str] = &[
"/.git/", "/out/", "/build/", "/dist/",
"/.rsconstruct/", "/target/",
];
const DEFAULT_PLUGINS_DIR: &str = "plugins";
#[derive(Debug, Deserialize, Serialize, Clone)]
#[serde(deny_unknown_fields)]
pub(crate) struct PluginsConfig {
#[serde(default = "default_plugins_dir")]
pub dir: String,
}
fn default_plugins_dir() -> String {
DEFAULT_PLUGINS_DIR.into()
}
impl Default for PluginsConfig {
fn default() -> Self {
Self { dir: DEFAULT_PLUGINS_DIR.into() }
}
}
#[derive(Debug, Deserialize, Serialize, Default)]
#[serde(deny_unknown_fields)]
pub(crate) struct Config {
#[serde(default)]
pub build: BuildConfig,
#[serde(default)]
pub cache: CacheConfig,
#[serde(default)]
pub processor: ProcessorConfig,
#[serde(default)]
pub analyzer: AnalyzerConfig,
#[serde(default)]
pub completions: CompletionsConfig,
#[serde(default)]
pub graph: GraphConfig,
#[serde(default)]
pub plugins: PluginsConfig,
}
#[derive(Debug, Deserialize, Serialize, Clone)]
#[serde(deny_unknown_fields)]
pub(crate) struct BuildConfig {
#[serde(default = "default_parallel")]
pub parallel: usize,
#[serde(default)]
pub batch_size: Option<usize>,
}
fn default_parallel() -> usize {
1
}
impl Default for BuildConfig {
fn default() -> Self {
Self {
parallel: 1,
batch_size: Some(0), }
}
}
#[derive(Debug, Deserialize, Serialize, Clone, Copy, Default, PartialEq, Eq)]
#[serde(rename_all = "lowercase")]
pub(crate) enum RestoreMethod {
#[default]
Hardlink,
Copy,
}
#[derive(Debug, Deserialize, Serialize, Clone)]
#[serde(deny_unknown_fields)]
pub(crate) struct CacheConfig {
#[serde(default)]
pub restore_method: RestoreMethod,
#[serde(default)]
pub compression: bool,
#[serde(default)]
pub remote: Option<String>,
#[serde(default = "default_true")]
pub remote_push: bool,
#[serde(default = "default_true")]
pub remote_pull: bool,
#[serde(default = "default_true")]
pub mtime_check: bool,
}
impl Default for CacheConfig {
fn default() -> Self {
Self {
restore_method: RestoreMethod::default(),
compression: false,
remote: None,
remote_push: true,
remote_pull: true,
mtime_check: true,
}
}
}
pub(crate) fn default_true() -> bool {
true
}
pub(crate) fn default_processors() -> Vec<String> {
use crate::processors::names;
vec![
names::TERA.into(), names::RUFF.into(), names::PYLINT.into(),
names::MYPY.into(), names::PYREFLY.into(), names::CC_SINGLE_FILE.into(), names::CC.into(),
names::CPPCHECK.into(), names::CLANG_TIDY.into(),
names::SHELLCHECK.into(), names::LUACHECK.into(), names::SPELLCHECK.into(), names::MAKE.into(),
names::CARGO.into(), names::CLIPPY.into(), names::RUMDL.into(),
names::YAMLLINT.into(), names::JQ.into(), names::JSONLINT.into(), names::TAPLO.into(),
names::JSON_SCHEMA.into(),
names::TAGS.into(),
names::PIP.into(), names::SPHINX.into(), names::MDBOOK.into(), names::NPM.into(), names::GEM.into(),
names::MDL.into(), names::MARKDOWNLINT.into(),
names::ASPELL.into(), names::MARP.into(), names::PANDOC.into(), names::MARKDOWN.into(),
names::PDFLATEX.into(), names::A2X.into(), names::ASCII_CHECK.into(),
names::MAKO.into(),
names::MERMAID.into(), names::DRAWIO.into(), names::LIBREOFFICE.into(),
names::PDFUNITE.into(), names::SCRIPT_CHECK.into(),
names::LINUX_MODULE.into(),
names::CPPLINT.into(),
names::CHECKPATCH.into(),
names::OBJDUMP.into(),
]
}
pub(crate) fn default_cc_compiler() -> String {
"gcc".into()
}
pub(crate) fn default_cxx_compiler() -> String {
"g++".into()
}
pub(crate) fn default_output_suffix() -> String {
".elf".into()
}
#[derive(Debug, Deserialize, Serialize)]
pub(crate) struct ProcessorConfig {
#[serde(default = "default_true")]
pub auto_detect: bool,
#[serde(default = "default_processors")]
pub enabled: Vec<String>,
#[serde(default)]
pub tera: TeraConfig,
#[serde(default)]
pub ruff: RuffConfig,
#[serde(default)]
pub pylint: PylintConfig,
#[serde(default)]
pub cc_single_file: CcSingleFileConfig,
#[serde(default)]
pub cc: CcConfig,
#[serde(default)]
pub cppcheck: CppcheckConfig,
#[serde(default)]
pub clang_tidy: ClangTidyConfig,
#[serde(default)]
pub spellcheck: SpellcheckConfig,
#[serde(default)]
pub shellcheck: ShellcheckConfig,
#[serde(default)]
pub luacheck: LuacheckConfig,
#[serde(default)]
pub sleep: SleepConfig,
#[serde(default)]
pub make: MakeConfig,
#[serde(default)]
pub cargo: CargoConfig,
#[serde(default)]
pub clippy: ClippyConfig,
#[serde(default)]
pub rumdl: RumdlConfig,
#[serde(default)]
pub mypy: MypyConfig,
#[serde(default)]
pub pyrefly: PyreflyConfig,
#[serde(default)]
pub yamllint: YamllintConfig,
#[serde(default)]
pub jq: JqConfig,
#[serde(default)]
pub jsonlint: JsonlintConfig,
#[serde(default)]
pub taplo: TaploConfig,
#[serde(default)]
pub json_schema: JsonSchemaConfig,
#[serde(default)]
pub tags: TagsConfig,
#[serde(default)]
pub pip: PipConfig,
#[serde(default)]
pub sphinx: SphinxConfig,
#[serde(default)]
pub mdbook: MdbookConfig,
#[serde(default)]
pub npm: NpmConfig,
#[serde(default)]
pub gem: GemConfig,
#[serde(default)]
pub mdl: MdlConfig,
#[serde(default)]
pub markdownlint: MarkdownlintConfig,
#[serde(default)]
pub aspell: AspellConfig,
#[serde(default)]
pub marp: MarpConfig,
#[serde(default)]
pub pandoc: PandocConfig,
#[serde(default)]
pub markdown: MarkdownConfig,
#[serde(default)]
pub pdflatex: PdflatexConfig,
#[serde(default)]
pub a2x: A2xConfig,
#[serde(default)]
pub ascii_check: AsciiCheckConfig,
#[serde(default)]
pub mermaid: MermaidConfig,
#[serde(default)]
pub drawio: DrawioConfig,
#[serde(default)]
pub mako: MakoConfig,
#[serde(default)]
pub libreoffice: LibreofficeConfig,
#[serde(default)]
pub pdfunite: PdfuniteConfig,
#[serde(default)]
pub script_check: ScriptCheckConfig,
#[serde(default)]
pub linux_module: LinuxModuleConfig,
#[serde(default)]
pub cpplint: CpplintConfig,
#[serde(default)]
pub checkpatch: CheckpatchConfig,
#[serde(default)]
pub objdump: ObjdumpConfig,
#[serde(flatten)]
pub extra: HashMap<String, toml::Value>,
}
impl Default for ProcessorConfig {
fn default() -> Self {
Self {
auto_detect: true,
enabled: default_processors(),
tera: TeraConfig::default(),
ruff: RuffConfig::default(),
pylint: PylintConfig::default(),
cc_single_file: CcSingleFileConfig::default(),
cc: CcConfig::default(),
cppcheck: CppcheckConfig::default(),
clang_tidy: ClangTidyConfig::default(),
shellcheck: ShellcheckConfig::default(),
luacheck: LuacheckConfig::default(),
spellcheck: SpellcheckConfig::default(),
sleep: SleepConfig::default(),
make: MakeConfig::default(),
cargo: CargoConfig::default(),
clippy: ClippyConfig::default(),
rumdl: RumdlConfig::default(),
mypy: MypyConfig::default(),
pyrefly: PyreflyConfig::default(),
yamllint: YamllintConfig::default(),
jq: JqConfig::default(),
jsonlint: JsonlintConfig::default(),
taplo: TaploConfig::default(),
json_schema: JsonSchemaConfig::default(),
tags: TagsConfig::default(),
pip: PipConfig::default(),
sphinx: SphinxConfig::default(),
mdbook: MdbookConfig::default(),
npm: NpmConfig::default(),
gem: GemConfig::default(),
mdl: MdlConfig::default(),
markdownlint: MarkdownlintConfig::default(),
aspell: AspellConfig::default(),
marp: MarpConfig::default(),
pandoc: PandocConfig::default(),
markdown: MarkdownConfig::default(),
pdflatex: PdflatexConfig::default(),
a2x: A2xConfig::default(),
ascii_check: AsciiCheckConfig::default(),
mermaid: MermaidConfig::default(),
drawio: DrawioConfig::default(),
mako: MakoConfig::default(),
libreoffice: LibreofficeConfig::default(),
pdfunite: PdfuniteConfig::default(),
script_check: ScriptCheckConfig::default(),
linux_module: LinuxModuleConfig::default(),
cpplint: CpplintConfig::default(),
checkpatch: CheckpatchConfig::default(),
objdump: ObjdumpConfig::default(),
extra: HashMap::new(),
}
}
}
impl ProcessorConfig {
fn processor_enabled_field(&self, name: &str) -> bool {
match name {
"tera" => self.tera.enabled,
"ruff" => self.ruff.enabled,
"pylint" => self.pylint.enabled,
"cc_single_file" => self.cc_single_file.enabled,
"cc" => self.cc.enabled,
"cppcheck" => self.cppcheck.enabled,
"clang_tidy" => self.clang_tidy.enabled,
"shellcheck" => self.shellcheck.enabled,
"luacheck" => self.luacheck.enabled,
"spellcheck" => self.spellcheck.enabled,
"sleep" => self.sleep.enabled,
"make" => self.make.enabled,
"cargo" => self.cargo.enabled,
"clippy" => self.clippy.enabled,
"rumdl" => self.rumdl.enabled,
"mypy" => self.mypy.enabled,
"pyrefly" => self.pyrefly.enabled,
"yamllint" => self.yamllint.enabled,
"jq" => self.jq.enabled,
"jsonlint" => self.jsonlint.enabled,
"taplo" => self.taplo.enabled,
"json_schema" => self.json_schema.enabled,
"tags" => self.tags.enabled,
"pip" => self.pip.enabled,
"sphinx" => self.sphinx.enabled,
"mdbook" => self.mdbook.enabled,
"npm" => self.npm.enabled,
"gem" => self.gem.enabled,
"mdl" => self.mdl.enabled,
"markdownlint" => self.markdownlint.enabled,
"aspell" => self.aspell.enabled,
"marp" => self.marp.enabled,
"pandoc" => self.pandoc.enabled,
"markdown" => self.markdown.enabled,
"pdflatex" => self.pdflatex.enabled,
"a2x" => self.a2x.enabled,
"ascii_check" => self.ascii_check.enabled,
"mermaid" => self.mermaid.enabled,
"drawio" => self.drawio.enabled,
"mako" => self.mako.enabled,
"libreoffice" => self.libreoffice.enabled,
"pdfunite" => self.pdfunite.enabled,
"script_check" => self.script_check.enabled,
"linux_module" => self.linux_module.enabled,
"cpplint" => self.cpplint.enabled,
"checkpatch" => self.checkpatch.enabled,
"objdump" => self.objdump.enabled,
_ => true, }
}
pub(crate) fn is_enabled(&self, name: &str) -> bool {
self.enabled.iter().any(|p| p == name) && self.processor_enabled_field(name)
}
pub(crate) fn scan_dirs(&self) -> Vec<String> {
let scans = [
&self.tera.scan, &self.ruff.scan, &self.pylint.scan,
&self.cc_single_file.scan, &self.cc.scan, &self.cppcheck.scan, &self.clang_tidy.scan,
&self.shellcheck.scan, &self.luacheck.scan, &self.spellcheck.scan, &self.sleep.scan,
&self.make.scan, &self.cargo.scan, &self.clippy.scan, &self.rumdl.scan, &self.mypy.scan,
&self.pyrefly.scan, &self.yamllint.scan, &self.jq.scan, &self.jsonlint.scan,
&self.taplo.scan, &self.json_schema.scan, &self.tags.scan,
&self.pip.scan, &self.sphinx.scan, &self.mdbook.scan, &self.npm.scan, &self.gem.scan,
&self.mdl.scan, &self.markdownlint.scan,
&self.aspell.scan, &self.marp.scan, &self.pandoc.scan, &self.markdown.scan,
&self.pdflatex.scan, &self.a2x.scan, &self.ascii_check.scan,
&self.mako.scan,
&self.mermaid.scan, &self.drawio.scan, &self.libreoffice.scan,
&self.script_check.scan, &self.linux_module.scan,
&self.cpplint.scan, &self.checkpatch.scan, &self.objdump.scan,
];
let mut dirs: Vec<String> = scans.iter()
.filter_map(|s| s.scan_dir.as_deref())
.filter(|d| !d.is_empty())
.map(|d| d.to_string())
.collect();
dirs.sort();
dirs.dedup();
dirs
}
pub(crate) fn resolve_scan_defaults(&mut self) {
self.tera.scan.resolve("templates.tera", &[".tera"], &[]);
self.ruff.scan.resolve("", &[".py"], PYTHON_EXCLUDE_DIRS);
self.pylint.scan.resolve("", &[".py"], PYTHON_EXCLUDE_DIRS);
self.cc_single_file.scan.resolve("src", &[".c", ".cc"], &[]);
self.cc.scan.resolve("", &["cc.yaml"], CC_EXCLUDE_DIRS);
self.cppcheck.scan.resolve("src", &[".c", ".cc"], CC_EXCLUDE_DIRS);
self.clang_tidy.scan.resolve("src", &[".c", ".cc"], CC_EXCLUDE_DIRS);
self.shellcheck.scan.resolve("", &[".sh", ".bash"], SHELL_EXCLUDE_DIRS);
self.luacheck.scan.resolve("", &[".lua"], BUILD_TOOL_EXCLUDES);
self.spellcheck.scan.resolve("", &[".md"], SPELLCHECK_EXCLUDE_DIRS);
self.sleep.scan.resolve("sleep", &[".sleep"], &[]);
self.make.scan.resolve("", &["Makefile"], MAKE_CARGO_EXCLUDES);
self.cargo.scan.resolve("", &["Cargo.toml"], MAKE_CARGO_EXCLUDES);
self.clippy.scan.resolve("", &["Cargo.toml"], MAKE_CARGO_EXCLUDES);
self.rumdl.scan.resolve("", &[".md"], MARKDOWN_EXCLUDE_DIRS);
self.mypy.scan.resolve("", &[".py"], PYTHON_EXCLUDE_DIRS);
self.pyrefly.scan.resolve("", &[".py"], PYTHON_EXCLUDE_DIRS);
self.yamllint.scan.resolve("", &[".yml", ".yaml"], BUILD_TOOL_EXCLUDES);
self.jq.scan.resolve("", &[".json"], BUILD_TOOL_EXCLUDES);
self.jsonlint.scan.resolve("", &[".json"], BUILD_TOOL_EXCLUDES);
self.taplo.scan.resolve("", &[".toml"], BUILD_TOOL_EXCLUDES);
self.json_schema.scan.resolve("", &[".json"], BUILD_TOOL_EXCLUDES);
self.tags.scan.resolve("", &[".md"], MARKDOWN_EXCLUDE_DIRS);
self.pip.scan.resolve("", &["requirements.txt"], MAKE_CARGO_EXCLUDES);
self.sphinx.scan.resolve("", &["conf.py"], BUILD_TOOL_EXCLUDES);
self.mdbook.scan.resolve("", &["book.toml"], BUILD_TOOL_EXCLUDES);
self.npm.scan.resolve("", &["package.json"], MAKE_CARGO_EXCLUDES);
self.gem.scan.resolve("", &["Gemfile"], MAKE_CARGO_EXCLUDES);
self.mdl.scan.resolve("", &[".md"], MARKDOWN_EXCLUDE_DIRS);
self.markdownlint.scan.resolve("", &[".md"], MARKDOWN_EXCLUDE_DIRS);
self.aspell.scan.resolve("", &[".md"], MARKDOWN_EXCLUDE_DIRS);
self.marp.scan.resolve("", &[".md"], MARKDOWN_EXCLUDE_DIRS);
self.pandoc.scan.resolve("pandoc", &[".md"], MARKDOWN_EXCLUDE_DIRS);
self.markdown.scan.resolve("", &[".md"], MARKDOWN_EXCLUDE_DIRS);
self.pdflatex.scan.resolve("", &[".tex"], BUILD_TOOL_EXCLUDES);
self.a2x.scan.resolve("", &[".txt"], BUILD_TOOL_EXCLUDES);
self.ascii_check.scan.resolve("", &[".md"], MARKDOWN_EXCLUDE_DIRS);
self.mako.scan.resolve("templates.mako", &[".mako"], &[]);
self.mermaid.scan.resolve("", &[".mmd"], BUILD_TOOL_EXCLUDES);
self.drawio.scan.resolve("", &[".drawio"], BUILD_TOOL_EXCLUDES);
self.libreoffice.scan.resolve("", &[".odp"], BUILD_TOOL_EXCLUDES);
self.script_check.scan.resolve("", &[], &[]);
self.linux_module.scan.resolve("", &["linux-module.yaml"], BUILD_TOOL_EXCLUDES);
self.cpplint.scan.resolve("src", &[".c", ".cc", ".h", ".hh"], CC_EXCLUDE_DIRS);
self.checkpatch.scan.resolve("src", &[".c", ".h"], CC_EXCLUDE_DIRS);
self.objdump.scan.resolve("out/cc_single_file", &[".elf"], &[]);
}
}
#[derive(Debug, Deserialize, Serialize, Clone)]
#[serde(deny_unknown_fields)]
pub(crate) struct CompletionsConfig {
#[serde(default = "default_shells")]
pub shells: Vec<String>,
}
fn default_shells() -> Vec<String> {
vec!["bash".into()]
}
impl Default for CompletionsConfig {
fn default() -> Self {
Self { shells: vec!["bash".into()] }
}
}
fn default_analyzers() -> Vec<String> {
vec!["cpp".into(), "python".into()]
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
pub(crate) struct AnalyzerConfig {
#[serde(default = "default_true")]
pub auto_detect: bool,
#[serde(default = "default_analyzers")]
pub enabled: Vec<String>,
#[serde(default)]
pub cpp: CppAnalyzerConfig,
#[serde(default)]
pub python: PythonAnalyzerConfig,
}
impl Default for AnalyzerConfig {
fn default() -> Self {
Self {
auto_detect: true,
enabled: default_analyzers(),
cpp: CppAnalyzerConfig::default(),
python: PythonAnalyzerConfig::default(),
}
}
}
impl AnalyzerConfig {
pub(crate) fn is_enabled(&self, name: &str) -> bool {
self.enabled.iter().any(|a| a == name)
}
}
#[derive(Debug, Deserialize, Serialize, Clone, Default)]
#[serde(deny_unknown_fields)]
pub(crate) struct GraphConfig {
#[serde(default)]
pub viewer: Option<String>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum FieldType {
String,
Bool,
Integer,
StringArray,
TableArray,
}
impl FieldType {
fn label(self) -> &'static str {
match self {
FieldType::String => "a string",
FieldType::Bool => "a boolean",
FieldType::Integer => "an integer",
FieldType::StringArray => "an array of strings",
FieldType::TableArray => "an array of tables",
}
}
fn matches(self, value: &toml::Value) -> bool {
match self {
FieldType::String => value.is_str(),
FieldType::Bool => value.as_bool().is_some(),
FieldType::Integer => value.is_integer(),
FieldType::StringArray => value.as_array()
.is_some_and(|arr| arr.iter().all(|v| v.is_str())),
FieldType::TableArray => value.as_array()
.is_some_and(|arr| arr.iter().all(|v| v.is_table())),
}
}
fn describe_value(value: &toml::Value) -> &'static str {
match value {
toml::Value::String(_) => "a string",
toml::Value::Integer(_) => "an integer",
toml::Value::Float(_) => "a float",
toml::Value::Boolean(_) => "a boolean",
toml::Value::Datetime(_) => "a datetime",
toml::Value::Array(_) => "an array",
toml::Value::Table(_) => "a table",
}
}
}
fn expected_field_type(processor: &str, field: &str) -> Option<FieldType> {
match field {
"scan_dir" => return Some(FieldType::String),
"extensions" => return Some(FieldType::StringArray),
"exclude_dirs" => return Some(FieldType::StringArray),
"exclude_files" => return Some(FieldType::StringArray),
"exclude_paths" => return Some(FieldType::StringArray),
"enabled" => return Some(FieldType::Bool),
"args" => return Some(FieldType::StringArray),
"extra_inputs" => return Some(FieldType::StringArray),
"auto_inputs" => return Some(FieldType::StringArray),
_ => {}
}
match (processor, field) {
("tera", "strict" | "trim_blocks") => Some(FieldType::Bool),
("ruff", "linter") => Some(FieldType::String),
("cc_single_file", "cc" | "cxx" | "output_suffix") => Some(FieldType::String),
("cc_single_file", "cflags" | "cxxflags" | "ldflags" | "include_paths") => Some(FieldType::StringArray),
("cc_single_file", "include_scanner") => Some(FieldType::String),
("cc_single_file", "compilers") => Some(FieldType::TableArray),
("cc", "cc" | "cxx") => Some(FieldType::String),
("cc", "cflags" | "cxxflags" | "ldflags" | "include_dirs") => Some(FieldType::StringArray),
("cc", "single_invocation" | "cache_output_dir") => Some(FieldType::Bool),
("clang_tidy", "compiler_args") => Some(FieldType::StringArray),
("spellcheck", "language" | "words_file") => Some(FieldType::String),
("spellcheck", "auto_add_words") => Some(FieldType::Bool),
("make", "make" | "target") => Some(FieldType::String),
("cargo", "profiles") => Some(FieldType::StringArray),
("cargo" | "clippy", "cargo" | "command") => Some(FieldType::String),
("mypy" | "pyrefly" | "shellcheck" | "luacheck" | "script_check", "checker") => Some(FieldType::String),
("rumdl" | "yamllint" | "jsonlint" | "taplo", "linter") => Some(FieldType::String),
("jq", "checker") => Some(FieldType::String),
("tags", "output" | "tags_file") => Some(FieldType::String),
("tags", "tags_file_strict") => Some(FieldType::Bool),
("pip", "pip") => Some(FieldType::String),
("sphinx", "sphinx_build" | "output_dir" | "working_dir") => Some(FieldType::String),
("mdbook", "mdbook" | "output_dir") => Some(FieldType::String),
("npm", "npm" | "command") => Some(FieldType::String),
("gem", "bundler" | "command" | "gem_home") => Some(FieldType::String),
("mdl", "gem_home" | "mdl_bin" | "gem_stamp") => Some(FieldType::String),
("markdownlint", "markdownlint_bin" | "npm_stamp") => Some(FieldType::String),
("aspell", "aspell" | "conf_dir" | "conf" | "words_file") => Some(FieldType::String),
("aspell", "auto_add_words") => Some(FieldType::Bool),
("marp", "marp_bin" | "output_dir") => Some(FieldType::String),
("marp", "formats") => Some(FieldType::StringArray),
("pandoc", "pandoc" | "from" | "output_dir") => Some(FieldType::String),
("pandoc", "formats") => Some(FieldType::StringArray),
("markdown", "markdown_bin" | "output_dir") => Some(FieldType::String),
("pdflatex", "pdflatex" | "output_dir") => Some(FieldType::String),
("pdflatex", "runs") => Some(FieldType::Integer),
("pdflatex", "qpdf") => Some(FieldType::Bool),
("a2x", "a2x" | "format" | "output_dir") => Some(FieldType::String),
("mermaid", "mmdc_bin" | "output_dir") => Some(FieldType::String),
("mermaid", "formats") => Some(FieldType::StringArray),
("drawio", "drawio_bin" | "output_dir") => Some(FieldType::String),
("drawio", "formats") => Some(FieldType::StringArray),
("libreoffice", "libreoffice_bin" | "output_dir") => Some(FieldType::String),
("libreoffice", "formats") => Some(FieldType::StringArray),
("pdfunite", "pdfunite_bin" | "source_dir" | "source_ext" | "source_output_dir" | "output_dir") => Some(FieldType::String),
("objdump", "output_dir") => Some(FieldType::String),
("cargo" | "sphinx" | "mdbook" | "npm" | "gem", "cache_output_dir") => Some(FieldType::Bool),
_ => None,
}
}
fn validate_processor_fields(raw: &toml::Value) -> Result<()> {
let processor_table = match raw.get("processor").and_then(|v| v.as_table()) {
Some(t) => t,
None => return Ok(()),
};
let mut errors = Vec::new();
for (name, value) in processor_table {
let table = match value.as_table() {
Some(t) => t,
None => continue, };
let known: &[&str] = match name.as_str() {
processor_names::TERA => TeraConfig::known_fields(),
processor_names::RUFF => RuffConfig::known_fields(),
processor_names::PYLINT => PylintConfig::known_fields(),
processor_names::CC_SINGLE_FILE => CcSingleFileConfig::known_fields(),
processor_names::CC => CcConfig::known_fields(),
processor_names::CPPCHECK => CppcheckConfig::known_fields(),
processor_names::CLANG_TIDY => ClangTidyConfig::known_fields(),
processor_names::SHELLCHECK => ShellcheckConfig::known_fields(),
processor_names::LUACHECK => LuacheckConfig::known_fields(),
processor_names::SPELLCHECK => SpellcheckConfig::known_fields(),
processor_names::SLEEP => SleepConfig::known_fields(),
processor_names::MAKE => MakeConfig::known_fields(),
processor_names::CARGO => CargoConfig::known_fields(),
processor_names::CLIPPY => ClippyConfig::known_fields(),
processor_names::RUMDL => RumdlConfig::known_fields(),
processor_names::MYPY => MypyConfig::known_fields(),
processor_names::PYREFLY => PyreflyConfig::known_fields(),
processor_names::YAMLLINT => YamllintConfig::known_fields(),
processor_names::JQ => JqConfig::known_fields(),
processor_names::JSONLINT => JsonlintConfig::known_fields(),
processor_names::TAPLO => TaploConfig::known_fields(),
processor_names::JSON_SCHEMA => JsonSchemaConfig::known_fields(),
processor_names::TAGS => TagsConfig::known_fields(),
processor_names::PIP => PipConfig::known_fields(),
processor_names::SPHINX => SphinxConfig::known_fields(),
processor_names::MDBOOK => MdbookConfig::known_fields(),
processor_names::NPM => NpmConfig::known_fields(),
processor_names::GEM => GemConfig::known_fields(),
processor_names::MDL => MdlConfig::known_fields(),
processor_names::MARKDOWNLINT => MarkdownlintConfig::known_fields(),
processor_names::ASPELL => AspellConfig::known_fields(),
processor_names::MARP => MarpConfig::known_fields(),
processor_names::PANDOC => PandocConfig::known_fields(),
processor_names::MARKDOWN => MarkdownConfig::known_fields(),
processor_names::PDFLATEX => PdflatexConfig::known_fields(),
processor_names::A2X => A2xConfig::known_fields(),
processor_names::ASCII_CHECK => AsciiCheckConfig::known_fields(),
processor_names::MERMAID => MermaidConfig::known_fields(),
processor_names::DRAWIO => DrawioConfig::known_fields(),
processor_names::MAKO => MakoConfig::known_fields(),
processor_names::LIBREOFFICE => LibreofficeConfig::known_fields(),
processor_names::PDFUNITE => PdfuniteConfig::known_fields(),
processor_names::SCRIPT_CHECK => ScriptCheckConfig::known_fields(),
processor_names::LINUX_MODULE => LinuxModuleConfig::known_fields(),
processor_names::CPPLINT => CpplintConfig::known_fields(),
processor_names::CHECKPATCH => CheckpatchConfig::known_fields(),
processor_names::OBJDUMP => ObjdumpConfig::known_fields(),
_ => continue, };
for (key, field_value) in table {
if !known.contains(&key.as_str()) {
errors.push(format!(
"[processor.{}]: unknown field '{}' (valid fields: {})",
name, key, known.join(", ")
));
continue;
}
if let Some(expected) = expected_field_type(name, key)
&& !expected.matches(field_value)
{
errors.push(format!(
"[processor.{}]: field '{}' must be {}, got {} ({})",
name, key, expected.label(),
FieldType::describe_value(field_value),
field_value,
));
}
}
}
if errors.is_empty() {
Ok(())
} else {
anyhow::bail!("Invalid config:\n{}", errors.join("\n"))
}
}
impl Config {
pub(crate) fn require_config() -> Result<()> {
let config_path = Path::new(CONFIG_FILE);
if !config_path.exists() {
return Err(crate::exit_code::RsconstructError::new(
crate::exit_code::RsconstructExitCode::ConfigError,
"No rsconstruct.toml found. Run 'rsconstruct init' to create one.",
).into());
}
Ok(())
}
pub(crate) fn load() -> Result<Self> {
let config_path = Path::new(CONFIG_FILE);
let mut config = if config_path.exists() {
let content = fs::read_to_string(config_path)
.with_context(|| format!("Failed to read config file: {}", config_path.display()))?;
let substituted = substitute_variables(&content)
.with_context(|| format!("Failed to substitute variables in: {}", config_path.display()))?;
let raw: toml::Value = toml::from_str(&substituted)
.with_context(|| format!("Failed to parse config file: {}", config_path.display()))?;
validate_processor_fields(&raw)?;
toml::from_str(&substituted)
.with_context(|| format!("Failed to parse config file: {}", config_path.display()))?
} else {
Config::default()
};
config.processor.resolve_scan_defaults();
Ok(config)
}
}
pub(crate) fn scan_config_from_toml(
value: &toml::Value,
default_scan_dir: &str,
default_extensions: &[&str],
default_exclude_dirs: &[&str],
) -> ScanConfig {
let table = value.as_table();
let scan_dir = table
.and_then(|t| t.get("scan_dir"))
.and_then(|v| v.as_str())
.map(|s| s.to_string());
let extensions = table
.and_then(|t| t.get("extensions"))
.and_then(|v| v.as_array())
.map(|arr| arr.iter().filter_map(|v| v.as_str().map(String::from)).collect());
let exclude_dirs = table
.and_then(|t| t.get("exclude_dirs"))
.and_then(|v| v.as_array())
.map(|arr| arr.iter().filter_map(|v| v.as_str().map(String::from)).collect());
let exclude_files = table
.and_then(|t| t.get("exclude_files"))
.and_then(|v| v.as_array())
.map(|arr| arr.iter().filter_map(|v| v.as_str().map(String::from)).collect());
let exclude_paths = table
.and_then(|t| t.get("exclude_paths"))
.and_then(|v| v.as_array())
.map(|arr| arr.iter().filter_map(|v| v.as_str().map(String::from)).collect());
let mut scan = ScanConfig {
scan_dir,
extensions,
exclude_dirs,
exclude_files,
exclude_paths,
};
scan.resolve(default_scan_dir, default_extensions, default_exclude_dirs);
scan
}