mod analyzer_configs;
mod processor_configs;
mod provenance;
mod variables;
#[cfg(test)]
mod tests;
pub use analyzer_configs::*;
pub use processor_configs::*;
pub use provenance::{FieldProvenance, ProvenanceMap, Section, SpanMap};
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 variables::substitute_variables;
const CONFIG_FILE: &str = "rsconstruct.toml";
pub const SCAN_CONFIG_FIELDS: &[&str] = &[
"src_dirs", "src_extensions", "src_exclude_dirs", "src_exclude_files", "src_exclude_paths", "src_files",
];
pub const STANDARD_EXTRA_FIELDS: &[&str] = &["enabled", "cache"];
pub trait KnownFields {
fn known_fields() -> &'static [&'static str];
fn checksum_fields() -> &'static [&'static str];
fn must_fields() -> &'static [&'static str] {
&[]
}
fn field_descriptions() -> &'static [(&'static str, &'static str)] {
&[]
}
}
pub struct ScanDefaultsData {
pub src_dirs: &'static [&'static str],
pub src_extensions: &'static [&'static str],
pub src_exclude_dirs: &'static [&'static str],
}
#[derive(Default)]
pub struct ProcessorDefaults {
pub command: &'static str,
pub dep_auto: &'static [&'static str],
pub output_dir: &'static str,
pub formats: &'static [&'static str],
pub args: &'static [&'static str],
pub batch: Option<bool>,
}
#[derive(Copy, Clone)]
pub struct SimpleCheckerParams {
pub description: &'static str,
pub subcommand: Option<&'static str>,
pub prepend_args: &'static [&'static str],
pub extra_tools: &'static [&'static str],
pub fix_subcommand: Option<&'static str>,
pub fix_prepend_args: &'static [&'static str],
pub fix_batch: Option<bool>,
}
pub fn resolve_extra_inputs(dep_inputs: &[String]) -> Result<Vec<PathBuf>> {
let mut resolved = Vec::new();
for p in dep_inputs {
if p.contains('*') || p.contains('?') || p.contains('[') {
for entry in glob::glob(p)
.with_context(|| format!("Invalid glob pattern in dep_inputs: {p}"))?
{
let path = crate::errors::ctx(entry, &format!("Failed to read glob entry for: {p}"))?;
if path.is_file() {
resolved.push(path);
}
}
} else {
let path = PathBuf::from(p);
if !path.exists() {
anyhow::bail!("dep_inputs file not found: {p}");
}
resolved.push(path);
}
}
Ok(resolved)
}
pub const SCAN_FIELD_DESCRIPTIONS: &[(&str, &str)] = &[
("src_dirs", "Directories to scan for source files"),
("src_extensions", "File extensions to match during scanning"),
("src_exclude_dirs", "Directory path segments to skip during scanning"),
("src_exclude_files", "File names to exclude from scanning"),
("src_exclude_paths", "Relative paths to exclude from scanning"),
("src_files", "Additional files to include alongside normal scanning"),
];
pub const SHARED_FIELD_DESCRIPTIONS: &[(&str, &str)] = &[
("dep_inputs", "Extra files that trigger a rebuild when their content changes"),
("dep_auto", "Config files silently added as dep_inputs when they exist on disk"),
("batch", "Pass all matched files to the tool in a single invocation"),
("max_jobs", "Maximum parallel jobs for this processor (overrides global --jobs)"),
("enabled", "Set to false to disable this processor without removing the stanza"),
("cache", "Whether to cache this processor's outputs (set false to always rebuild)"),
];
pub fn output_config_hash(value: &impl Serialize, checksum_fields: &[&str]) -> String {
let json_value: serde_json::Value = serde_json::to_value(value).expect(errors::CONFIG_SERIALIZE);
let filtered = if let serde_json::Value::Object(map) = json_value {
let kept: serde_json::Map<String, serde_json::Value> = map.into_iter()
.filter(|(k, _)| checksum_fields.contains(&k.as_str()))
.collect();
serde_json::Value::Object(kept)
} else {
json_value
};
let json = serde_json::to_string(&filtered).expect(errors::CONFIG_SERIALIZE);
let hash = Sha256::digest(json.as_bytes());
hex::encode(hash)
}
const DEFAULT_PLUGINS_DIR: &str = "plugins";
#[derive(Debug, Deserialize, Serialize, Clone)]
#[serde(deny_unknown_fields)]
pub 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, Clone, Default)]
#[serde(deny_unknown_fields)]
pub struct DependenciesConfig {
#[serde(default)]
pub pip: Vec<String>,
#[serde(default)]
pub npm: Vec<String>,
#[serde(default)]
pub gem: Vec<String>,
#[serde(default)]
pub system: Vec<String>,
#[serde(default)]
pub eatmydata: bool,
}
impl DependenciesConfig {
pub const fn is_empty(&self) -> bool {
self.pip.is_empty() && self.npm.is_empty() && self.gem.is_empty() && self.system.is_empty()
}
}
#[derive(Debug, Deserialize, Serialize, Default)]
#[serde(deny_unknown_fields)]
pub 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,
#[serde(default)]
pub dependencies: DependenciesConfig,
#[serde(default)]
pub command: CommandsConfig,
#[serde(skip)]
pub global_provenance: HashMap<String, ProvenanceMap>,
}
#[derive(Debug, Deserialize, Serialize, Clone, Default)]
#[serde(deny_unknown_fields)]
pub struct SymlinkInstallConfig {
#[serde(default)]
pub sources: Vec<String>,
#[serde(default)]
pub targets: Vec<String>,
}
#[derive(Debug, Deserialize, Serialize, Clone, Default)]
#[serde(deny_unknown_fields)]
pub struct CommandsConfig {
#[serde(default)]
pub symlink_install: SymlinkInstallConfig,
}
#[derive(Debug, Deserialize, Serialize, Clone)]
#[serde(deny_unknown_fields)]
pub struct BuildConfig {
#[serde(default = "default_parallel")]
pub parallel: usize,
#[serde(default)]
pub batch_size: Option<usize>,
#[serde(default = "default_output_dir")]
pub output_dir: String,
}
const fn default_parallel() -> usize {
0
}
fn default_output_dir() -> String {
"out".into()
}
impl Default for BuildConfig {
fn default() -> Self {
Self {
parallel: 0,
batch_size: Some(0), output_dir: "out".into(),
}
}
}
#[derive(Debug, Deserialize, Serialize, Clone, Copy, Default, PartialEq, Eq)]
#[serde(rename_all = "lowercase")]
pub enum RestoreMethod {
#[default]
Auto,
Hardlink,
Copy,
}
impl RestoreMethod {
pub fn resolve(self) -> Self {
match self {
RestoreMethod::Auto => {
if std::env::var("CI").is_ok_and(|v| v == "true") {
RestoreMethod::Copy
} else {
RestoreMethod::Hardlink
}
}
other => other,
}
}
}
#[derive(Debug, Deserialize, Serialize, Clone)]
#[serde(deny_unknown_fields)]
pub 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 const fn default_true() -> bool {
true
}
#[derive(Debug, Clone)]
pub struct ProcessorInstance {
pub instance_name: String,
pub type_name: String,
pub config_toml: toml::Value,
pub provenance: ProvenanceMap,
}
use crate::registries::{self as registry, ProcessorPlugin};
pub fn find_registry_entry(type_name: &str) -> Option<&'static ProcessorPlugin> {
registry::all_plugins().find(|e| e.name == type_name)
}
pub fn registry_entries() -> impl Iterator<Item = &'static ProcessorPlugin> {
registry::all_plugins()
}
pub fn all_type_names() -> Vec<&'static str> {
registry::all_plugins().map(|e| e.name).collect()
}
pub fn is_builtin_type(name: &str) -> bool {
find_registry_entry(name).is_some()
}
pub fn seed_user_provenance(value: &toml::Value) -> ProvenanceMap {
let mut map = ProvenanceMap::new();
if let Some(table) = value.as_table() {
for key in table.keys() {
map.insert(key.clone(), FieldProvenance::UserToml { line: 0 });
}
}
map
}
pub fn resolve_instance_defaults(
type_name: &str,
value: &mut toml::Value,
provenance: &mut ProvenanceMap,
) {
if find_registry_entry(type_name).is_some() {
registry::apply_all_defaults(type_name, value, provenance);
}
}
impl ProcessorConfig {
pub(crate) fn src_dirs(&self) -> Vec<String> {
let mut dirs: Vec<String> = self.instances.iter()
.flat_map(|inst| {
inst.config_toml.get("src_dirs")
.and_then(|v| v.as_array())
.into_iter()
.flat_map(|arr| arr.iter().filter_map(|v| v.as_str().map(std::string::ToString::to_string)))
.filter(|d| !d.is_empty())
})
.collect();
dirs.sort();
dirs.dedup();
dirs
}
pub(crate) fn known_fields_for(type_name: &str) -> Option<&'static [&'static str]> {
find_registry_entry(type_name).map(|e| (e.known_fields)())
}
pub(crate) fn checksum_fields_for(type_name: &str) -> Option<&'static [&'static str]> {
find_registry_entry(type_name).map(|e| (e.checksum_fields)())
}
pub(crate) fn must_fields_for(type_name: &str) -> Option<&'static [&'static str]> {
find_registry_entry(type_name).map(|e| (e.must_fields)())
}
pub(crate) fn field_descriptions_for(type_name: &str) -> Option<&'static [(&'static str, &'static str)]> {
find_registry_entry(type_name).map(|e| (e.field_descriptions)())
}
pub(crate) fn default_src_dirs_for(type_name: &str) -> Option<&'static [&'static str]> {
scan_defaults_for(type_name).map(|d| d.src_dirs)
}
pub(crate) fn defconfig_json(type_name: &str) -> Option<String> {
let entry = find_registry_entry(type_name)?;
(entry.defconfig_json)(entry.name)
}
}
pub fn scan_defaults_for(type_name: &str) -> Option<ScanDefaultsData> {
Some(match type_name {
"tera" => ScanDefaultsData { src_dirs: &["tera.templates"], src_extensions: &[".tera"], src_exclude_dirs: &[] },
"ruff" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".py"], src_exclude_dirs: &[] },
"pylint" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".py"], src_exclude_dirs: &[] },
"mypy" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".py"], src_exclude_dirs: &[] },
"pyrefly" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".py"], src_exclude_dirs: &[] },
"black" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".py"], src_exclude_dirs: &[] },
"doctest" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".py"], src_exclude_dirs: &[] },
"pytest" => ScanDefaultsData { src_dirs: &["tests"], src_extensions: &[".py"], src_exclude_dirs: &[] },
"cc_single_file" => ScanDefaultsData { src_dirs: &["src"], src_extensions: &[".c", ".cc"], src_exclude_dirs: &[] },
"cc" => ScanDefaultsData { src_dirs: &[], src_extensions: &["cc.yaml"], src_exclude_dirs: &[] },
"cppcheck" => ScanDefaultsData { src_dirs: &["src"], src_extensions: &[".c", ".cc"], src_exclude_dirs: &[] },
"clang_tidy" => ScanDefaultsData { src_dirs: &["src"], src_extensions: &[".c", ".cc"], src_exclude_dirs: &[] },
"zspell" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".md"], src_exclude_dirs: &[] },
"shellcheck" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".sh", ".bash"], src_exclude_dirs: &[] },
"luacheck" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".lua"], src_exclude_dirs: &[] },
"make" => ScanDefaultsData { src_dirs: &[], src_extensions: &["Makefile"], src_exclude_dirs: &[] },
"cargo" => ScanDefaultsData { src_dirs: &[], src_extensions: &["Cargo.toml"], src_exclude_dirs: &[] },
"clippy" => ScanDefaultsData { src_dirs: &[], src_extensions: &["Cargo.toml"], src_exclude_dirs: &[] },
"rumdl" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".md"], src_exclude_dirs: &[] },
"yamllint" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".yml", ".yaml"], src_exclude_dirs: &[] },
"jq" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".json"], src_exclude_dirs: &[] },
"jsonlint" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".json"], src_exclude_dirs: &[] },
"taplo" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".toml"], src_exclude_dirs: &[] },
"json_schema" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".json"], src_exclude_dirs: &[] },
"tags" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".md"], src_exclude_dirs: &[] },
"pip" => ScanDefaultsData { src_dirs: &[], src_extensions: &["requirements.txt"], src_exclude_dirs: &[] },
"requirements" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".py"], src_exclude_dirs: &[] },
"sphinx" => ScanDefaultsData { src_dirs: &[], src_extensions: &["conf.py"], src_exclude_dirs: &[] },
"mdbook" => ScanDefaultsData { src_dirs: &[], src_extensions: &["book.toml"], src_exclude_dirs: &[] },
"npm" => ScanDefaultsData { src_dirs: &[], src_extensions: &["package.json"], src_exclude_dirs: &[] },
"gem" => ScanDefaultsData { src_dirs: &[], src_extensions: &["Gemfile"], src_exclude_dirs: &[] },
"mdl" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".md"], src_exclude_dirs: &[] },
"markdownlint" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".md"], src_exclude_dirs: &[] },
"aspell" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".md"], src_exclude_dirs: &[] },
"marp" => ScanDefaultsData { src_dirs: &["marp"], src_extensions: &[".md"], src_exclude_dirs: &[] },
"pandoc" => ScanDefaultsData { src_dirs: &["pandoc"], src_extensions: &[".md"], src_exclude_dirs: &[] },
"markdown2html" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".md"], src_exclude_dirs: &[] },
"pdflatex" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".tex"], src_exclude_dirs: &[] },
"a2x" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".txt"], src_exclude_dirs: &[] },
"ascii" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".md"], src_exclude_dirs: &[] },
"terms" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".md"], src_exclude_dirs: &[] },
"chromium" => ScanDefaultsData { src_dirs: &["out/marp"], src_extensions: &[".html"], src_exclude_dirs: &[] },
"mako" => ScanDefaultsData { src_dirs: &["templates.mako"], src_extensions: &[".mako"], src_exclude_dirs: &[] },
"jinja2" => ScanDefaultsData { src_dirs: &["templates.jinja2"], src_extensions: &[".j2"], src_exclude_dirs: &[] },
"mermaid" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".mmd"], src_exclude_dirs: &[] },
"drawio" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".drawio"], src_exclude_dirs: &[] },
"libreoffice" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".odp"], src_exclude_dirs: &[] },
"protobuf" => ScanDefaultsData { src_dirs: &["proto"], src_extensions: &[".proto"], src_exclude_dirs: &[] },
"pdfunite" => ScanDefaultsData { src_dirs: &[], src_extensions: &["course.yaml"], src_exclude_dirs: &[] },
"ipdfunite" => ScanDefaultsData { src_dirs: &[], src_extensions: &["course.yaml"], src_exclude_dirs: &[] },
"script" => ScanDefaultsData { src_dirs: &[], src_extensions: &[], src_exclude_dirs: &[] },
"creator" => ScanDefaultsData { src_dirs: &[], src_extensions: &[], src_exclude_dirs: &[] },
"generator" => ScanDefaultsData { src_dirs: &[], src_extensions: &[], src_exclude_dirs: &[] },
"explicit" => ScanDefaultsData { src_dirs: &[], src_extensions: &[], src_exclude_dirs: &[] },
"linux_module" => ScanDefaultsData { src_dirs: &[], src_extensions: &["linux-module.yaml"], src_exclude_dirs: &[] },
"cpplint" => ScanDefaultsData { src_dirs: &["src"], src_extensions: &[".c", ".cc", ".h", ".hh"], src_exclude_dirs: &[] },
"checkpatch" => ScanDefaultsData { src_dirs: &["src"], src_extensions: &[".c", ".h"], src_exclude_dirs: &[] },
"objdump" => ScanDefaultsData { src_dirs: &["out/cc_single_file"], src_extensions: &[".elf"], src_exclude_dirs: &[] },
"prettier" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs", ".css", ".scss", ".less", ".html", ".json", ".md", ".yaml", ".yml"], src_exclude_dirs: &[] },
"eslint" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"], src_exclude_dirs: &[] },
"jshint" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".js", ".jsx", ".mjs", ".cjs"], src_exclude_dirs: &[] },
"htmlhint" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".html", ".htm"], src_exclude_dirs: &[] },
"tidy" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".html", ".htm"], src_exclude_dirs: &[] },
"stylelint" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".css", ".scss", ".sass", ".less"], src_exclude_dirs: &[] },
"jslint" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".js"], src_exclude_dirs: &[] },
"standard" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".js"], src_exclude_dirs: &[] },
"htmllint" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".html", ".htm"], src_exclude_dirs: &[] },
"php_lint" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".php"], src_exclude_dirs: &[] },
"perlcritic" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".pl", ".pm"], src_exclude_dirs: &[] },
"xmllint" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".xml", ".svg"], src_exclude_dirs: &[] },
"svglint" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".svg"], src_exclude_dirs: &[] },
"svgo" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".svg"], src_exclude_dirs: &[] },
"checkstyle" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".java"], src_exclude_dirs: &[] },
"yq" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".yml", ".yaml"], src_exclude_dirs: &[] },
"cmake" => ScanDefaultsData { src_dirs: &[], src_extensions: &["CMakeLists.txt"], src_exclude_dirs: &[] },
"hadolint" => ScanDefaultsData { src_dirs: &[], src_extensions: &["Dockerfile"], src_exclude_dirs: &[] },
"jekyll" => ScanDefaultsData { src_dirs: &[], src_extensions: &["_config.yml"], src_exclude_dirs: &[] },
"sass" => ScanDefaultsData { src_dirs: &["sass"], src_extensions: &[".scss", ".sass"], src_exclude_dirs: &[] },
"ijq" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".json"], src_exclude_dirs: &[] },
"ijsonlint" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".json"], src_exclude_dirs: &[] },
"iyamllint" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".yml", ".yaml"], src_exclude_dirs: &[] },
"iyamlschema" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".yml", ".yaml"], src_exclude_dirs: &[] },
"itaplo" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".toml"], src_exclude_dirs: &[] },
"imarkdown2html" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".md"], src_exclude_dirs: &[] },
"isass" => ScanDefaultsData { src_dirs: &["sass"], src_extensions: &[".scss", ".sass"], src_exclude_dirs: &[] },
"yaml2json" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".yml", ".yaml"], src_exclude_dirs: &[] },
"rust_single_file" => ScanDefaultsData { src_dirs: &["src"], src_extensions: &[".rs"], src_exclude_dirs: &[] },
"slidev" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".md"], src_exclude_dirs: &[] },
"encoding" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".py", ".rs", ".js", ".ts", ".c", ".cc", ".h", ".hh", ".java", ".rb", ".go", ".sh", ".bash", ".lua", ".pl", ".pm", ".php", ".md", ".yaml", ".yml", ".json", ".toml", ".xml", ".html", ".htm", ".css", ".scss", ".sass", ".tex", ".txt"], src_exclude_dirs: &[] },
"duplicate_files" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".py", ".rs", ".js", ".ts", ".c", ".cc", ".h", ".hh", ".java", ".rb", ".go", ".sh", ".md", ".yaml", ".yml", ".json", ".toml", ".xml", ".html", ".css"], src_exclude_dirs: &[] },
"marp_images" => ScanDefaultsData { src_dirs: &["marp"], src_extensions: &[".md"], src_exclude_dirs: &[] },
"license_header" => ScanDefaultsData { src_dirs: &[], src_extensions: &[".py", ".rs", ".js", ".ts", ".c", ".cc", ".h", ".hh", ".java", ".rb", ".go", ".sh", ".bash"], src_exclude_dirs: &[] },
_ => return None,
})
}
pub fn processor_defaults_for(type_name: &str) -> Option<ProcessorDefaults> {
let d = ProcessorDefaults::default();
Some(match type_name {
"ruff" => ProcessorDefaults { command: "ruff", dep_auto: &["ruff.toml", ".ruff.toml", "pyproject.toml"], ..d },
"pylint" => ProcessorDefaults { command: "pylint", dep_auto: &[".pylintrc"], ..d },
"pytest" => ProcessorDefaults { command: "pytest", dep_auto: &["conftest.py", "pytest.ini", "pyproject.toml"], ..d },
"black" => ProcessorDefaults { command: "black", dep_auto: &["pyproject.toml"], ..d },
"mypy" => ProcessorDefaults { command: "mypy", dep_auto: &["mypy.ini"], ..d },
"pyrefly" => ProcessorDefaults { command: "pyrefly", dep_auto: &["pyproject.toml"], ..d },
"rumdl" => ProcessorDefaults { command: "rumdl", dep_auto: &[".rumdl.toml"], ..d },
"yamllint" => ProcessorDefaults { command: "yamllint", dep_auto: &[".yamllint", ".yamllint.yml", ".yamllint.yaml"], ..d },
"jq" => ProcessorDefaults { command: "jq", ..d },
"jsonlint" => ProcessorDefaults { command: "jsonlint", ..d },
"taplo" => ProcessorDefaults { command: "taplo", dep_auto: &["taplo.toml", ".taplo.toml"], ..d },
"cppcheck" => ProcessorDefaults { command: "cppcheck", args: &["--error-exitcode=1", "--enable=warning,style,performance,portability"], dep_auto: &[".cppcheck"], batch: Some(false), ..d },
"cpplint" => ProcessorDefaults { command: "cpplint", ..d },
"checkpatch" => ProcessorDefaults { command: "checkpatch.pl", ..d },
"shellcheck" => ProcessorDefaults { command: "shellcheck", dep_auto: &[".shellcheckrc"], ..d },
"luacheck" => ProcessorDefaults { command: "luacheck", dep_auto: &[".luacheckrc"], ..d },
"prettier" => ProcessorDefaults { command: "prettier", dep_auto: &[".prettierrc", ".prettierrc.json", ".prettierrc.js", ".prettierrc.yml", ".prettierrc.yaml", ".prettierrc.toml", ".prettierrc.cjs", ".prettierrc.mjs", "prettier.config.js", "prettier.config.cjs", "prettier.config.mjs"], ..d },
"eslint" => ProcessorDefaults { command: "eslint", dep_auto: &[".eslintrc", ".eslintrc.json", ".eslintrc.js", ".eslintrc.yml", ".eslintrc.yaml", ".eslintrc.cjs", "eslint.config.js", "eslint.config.mjs", "eslint.config.cjs"], ..d },
"jshint" => ProcessorDefaults { command: "jshint", dep_auto: &[".jshintrc"], ..d },
"htmlhint" => ProcessorDefaults { command: "htmlhint", dep_auto: &[".htmlhintrc"], ..d },
"stylelint" => ProcessorDefaults { command: "stylelint", dep_auto: &[".stylelintrc", ".stylelintrc.json", ".stylelintrc.yml", ".stylelintrc.yaml", ".stylelintrc.js", ".stylelintrc.cjs", "stylelint.config.js", "stylelint.config.cjs"], ..d },
"perlcritic" => ProcessorDefaults { command: "perlcritic", dep_auto: &[".perlcriticrc"], ..d },
"svglint" => ProcessorDefaults { command: "svglint", dep_auto: &[".svglintrc.js"], ..d },
"svgo" => ProcessorDefaults { command: "svgo", dep_auto: &["svgo.config.js", "svgo.config.mjs", "svgo.config.cjs"], ..d },
"checkstyle" => ProcessorDefaults { command: "checkstyle", dep_auto: &["checkstyle.xml"], ..d },
"cmake" => ProcessorDefaults { command: "cmake", ..d },
"doctest" => ProcessorDefaults { command: "python3", ..d },
"hadolint" => ProcessorDefaults { command: "hadolint", ..d },
"htmllint" => ProcessorDefaults { command: "htmllint", ..d },
"jslint" => ProcessorDefaults { command: "jslint", ..d },
"php_lint" => ProcessorDefaults { command: "php", ..d },
"slidev" => ProcessorDefaults { command: "slidev", ..d },
"standard" => ProcessorDefaults { command: "standard", ..d },
"tidy" => ProcessorDefaults { command: "tidy", ..d },
"xmllint" => ProcessorDefaults { command: "xmllint", ..d },
"yq" => ProcessorDefaults { command: "yq", ..d },
"marp" => ProcessorDefaults { output_dir: "out/marp", formats: &["pdf"], args: &["--html", "--allow-local-files"], command: "marp", ..d },
"markdown2html" => ProcessorDefaults { output_dir: "out/markdown2html", command: "markdown", ..d },
"chromium" => ProcessorDefaults { output_dir: "out/chromium", command: "google-chrome", ..d },
"mermaid" => ProcessorDefaults { output_dir: "out/mermaid", formats: &["png"], command: "mmdc", ..d },
"drawio" => ProcessorDefaults { output_dir: "out/drawio", formats: &["png"], command: "drawio", ..d },
"libreoffice" => ProcessorDefaults { output_dir: "out/libreoffice", formats: &["pdf"], command: "libreoffice", ..d },
"protobuf" => ProcessorDefaults { output_dir: "out/protobuf", command: "protoc", ..d },
"cc_single_file" => ProcessorDefaults { output_dir: "out/cc_single_file", ..d },
"cargo" => ProcessorDefaults { command: "build", ..d },
"clippy" => ProcessorDefaults { command: "clippy", ..d },
"generator" => ProcessorDefaults { output_dir: "out/generator", ..d },
"explicit" => d,
"sphinx" => ProcessorDefaults { command: "sphinx-build", output_dir: "docs", ..d },
"mdbook" => ProcessorDefaults { command: "mdbook", output_dir: "book", ..d },
"npm" => ProcessorDefaults { command: "npm", ..d },
"sass" => ProcessorDefaults { output_dir: "out/sass", command: "sass", ..d },
"pandoc" => ProcessorDefaults { output_dir: "out/pandoc", formats: &["pdf", "html", "docx"], command: "pandoc", ..d },
"a2x" => ProcessorDefaults { output_dir: "out/a2x", command: "a2x", ..d },
"objdump" => ProcessorDefaults { output_dir: "out/objdump", command: "objdump", ..d },
"imarkdown2html" => ProcessorDefaults { output_dir: "out/imarkdown2html", ..d },
"isass" => ProcessorDefaults { output_dir: "out/isass", ..d },
"yaml2json" => ProcessorDefaults { output_dir: "out/yaml2json", ..d },
"mdl" => ProcessorDefaults { command: "mdl", dep_auto: &[".mdlrc"], ..d },
"markdownlint" => ProcessorDefaults { command: "markdownlint", dep_auto: &[".markdownlint.json", ".markdownlint.jsonc", ".markdownlint.yaml"], ..d },
"aspell" => ProcessorDefaults { command: "aspell", dep_auto: &[".aspell.conf", ".aspell.en.pws", ".aspell.en.prepl"], ..d },
"pdflatex" => ProcessorDefaults { command: "pdflatex", output_dir: "out/pdflatex", ..d },
"rust_single_file" => ProcessorDefaults { command: "rustc", output_dir: "out/rust_single_file", ..d },
"pdfunite" => ProcessorDefaults { command: "pdfunite", output_dir: "out/pdfunite", ..d },
"ipdfunite" => ProcessorDefaults { output_dir: "out/ipdfunite", ..d },
"gem" => ProcessorDefaults { command: "bundle", ..d },
"pip" => ProcessorDefaults { command: "pip", ..d },
"make" => ProcessorDefaults { command: "make", ..d },
_ => return None,
})
}
pub fn apply_processor_defaults(
type_name: &str,
value: &mut toml::Value,
provenance: &mut ProvenanceMap,
) {
let Some(defaults) = processor_defaults_for(type_name) else { return };
let Some(table) = value.as_table_mut() else { return };
set_string_default(table, "command", defaults.command, provenance, FieldProvenance::ProcessorDefault);
set_string_default(table, "output_dir", defaults.output_dir, provenance, FieldProvenance::ProcessorDefault);
set_string_array_default(table, "dep_auto", defaults.dep_auto, provenance, FieldProvenance::ProcessorDefault);
set_string_array_default(table, "formats", defaults.formats, provenance, FieldProvenance::ProcessorDefault);
set_string_array_default(table, "args", defaults.args, provenance, FieldProvenance::ProcessorDefault);
if let Some(batch) = defaults.batch
&& !table.contains_key("batch")
{
table.insert("batch".into(), toml::Value::Boolean(batch));
provenance::record_if_absent(provenance, "batch", FieldProvenance::ProcessorDefault);
}
}
fn set_string_default(
table: &mut toml::map::Map<String, toml::Value>,
key: &str,
val: &str,
provenance: &mut ProvenanceMap,
source: FieldProvenance,
) {
if !val.is_empty() && !table.contains_key(key) {
table.insert(key.into(), toml::Value::String(val.into()));
provenance::record_if_absent(provenance, key, source);
}
}
fn set_string_array_default(
table: &mut toml::map::Map<String, toml::Value>,
key: &str,
vals: &[&str],
provenance: &mut ProvenanceMap,
source: FieldProvenance,
) {
if !vals.is_empty() && !table.contains_key(key) {
let arr: Vec<toml::Value> = vals.iter().map(|s| toml::Value::String(s.to_string())).collect();
table.insert(key.into(), toml::Value::Array(arr));
provenance::record_if_absent(provenance, key, source);
}
}
fn set_empty_array_default(
table: &mut toml::map::Map<String, toml::Value>,
key: &str,
provenance: &mut ProvenanceMap,
source: FieldProvenance,
) {
if !table.contains_key(key) {
table.insert(key.into(), toml::Value::Array(Vec::new()));
provenance::record_if_absent(provenance, key, source);
}
}
fn set_maybe_empty_array_default(
table: &mut toml::map::Map<String, toml::Value>,
key: &str,
vals: &[&str],
provenance: &mut ProvenanceMap,
source: FieldProvenance,
) {
if !table.contains_key(key) {
let arr: Vec<toml::Value> = vals.iter().map(|s| toml::Value::String(s.to_string())).collect();
table.insert(key.into(), toml::Value::Array(arr));
provenance::record_if_absent(provenance, key, source);
}
}
pub fn apply_scan_defaults(
type_name: &str,
value: &mut toml::Value,
provenance: &mut ProvenanceMap,
) {
let Some(defaults) = scan_defaults_for(type_name) else { return };
let Some(table) = value.as_table_mut() else { return };
set_maybe_empty_array_default(table, "src_dirs", defaults.src_dirs, provenance, FieldProvenance::ScanDefault);
set_maybe_empty_array_default(table, "src_extensions", defaults.src_extensions, provenance, FieldProvenance::ScanDefault);
set_maybe_empty_array_default(table, "src_exclude_dirs", defaults.src_exclude_dirs, provenance, FieldProvenance::ScanDefault);
set_empty_array_default(table, "src_exclude_files", provenance, FieldProvenance::ScanDefault);
set_empty_array_default(table, "src_exclude_paths", provenance, FieldProvenance::ScanDefault);
set_empty_array_default(table, "src_files", provenance, FieldProvenance::ScanDefault);
}
#[derive(Debug, Default)]
pub struct ProcessorConfig {
pub instances: Vec<ProcessorInstance>,
pub extra: HashMap<String, toml::Value>,
}
impl Serialize for ProcessorConfig {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error> {
use serde::ser::SerializeMap;
let mut map = serializer.serialize_map(None)?;
for inst in &self.instances {
if inst.instance_name.contains('.') {
} else {
map.serialize_entry(&inst.instance_name, &inst.config_toml)?;
}
}
let mut types: HashMap<&str, Vec<&ProcessorInstance>> = HashMap::new();
for inst in &self.instances {
if let Some(dot) = inst.instance_name.find('.') {
let type_name = &inst.instance_name[..dot];
types.entry(type_name).or_default().push(inst);
}
}
for (type_name, insts) in &types {
let mut table = toml::map::Map::new();
for inst in insts {
let name = &inst.instance_name[type_name.len() + 1..];
table.insert(name.to_string(), inst.config_toml.clone());
}
map.serialize_entry(type_name, &toml::Value::Table(table))?;
}
for (name, value) in &self.extra {
map.serialize_entry(name, value)?;
}
map.end()
}
}
impl<'de> Deserialize<'de> for ProcessorConfig {
fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> std::result::Result<Self, D::Error> {
let table = toml::Value::deserialize(deserializer)?;
Ok(ProcessorConfig::from_toml(&table))
}
}
impl ProcessorConfig {
pub(crate) fn from_toml(value: &toml::Value) -> Self {
let Some(table) = value.as_table() else {
return Self::default();
};
let mut instances = Vec::new();
let mut extra = HashMap::new();
for (key, val) in table {
let Some(sub_table) = val.as_table() else { continue };
if is_builtin_type(key) {
if Self::is_multi_instance(key, sub_table) {
for (name, inst_val) in sub_table {
let instance_name = format!("{key}.{name}");
let mut config = inst_val.clone();
let mut provenance = seed_user_provenance(&config);
resolve_instance_defaults(key, &mut config, &mut provenance);
instances.push(ProcessorInstance {
instance_name,
type_name: key.clone(),
config_toml: config,
provenance,
});
}
} else {
let mut config = val.clone();
let mut provenance = seed_user_provenance(&config);
resolve_instance_defaults(key, &mut config, &mut provenance);
instances.push(ProcessorInstance {
instance_name: key.clone(),
type_name: key.clone(),
config_toml: config,
provenance,
});
}
} else {
extra.insert(key.clone(), val.clone());
}
}
Self { instances, extra }
}
fn is_multi_instance(type_name: &str, table: &toml::map::Map<String, toml::Value>) -> bool {
if table.is_empty() {
return false;
}
let known = Self::known_fields_for(type_name);
let known_fields: Vec<&str> = match known {
Some(fields) => fields.iter()
.chain(SCAN_CONFIG_FIELDS.iter())
.chain(STANDARD_EXTRA_FIELDS.iter())
.copied()
.collect(),
None => return false,
};
for key in table.keys() {
if known_fields.contains(&key.as_str()) {
return false;
}
}
table.values().all(toml::Value::is_table)
}
pub(crate) fn resolve_scan_defaults(&mut self) {
for inst in &mut self.instances {
resolve_instance_defaults(&inst.type_name, &mut inst.config_toml, &mut inst.provenance);
}
}
pub(crate) fn apply_output_dir_defaults(&mut self, global_output_dir: &str) {
for inst in &mut self.instances {
let type_default_prefix = format!("out/{}", inst.type_name);
let instance_prefix = format!("{}/{}", global_output_dir, inst.instance_name);
for field in &["output_dir", "output"] {
let Some(val) = inst.config_toml.get(field).and_then(|v| v.as_str()).map(std::string::ToString::to_string) else { continue };
let new_val = if inst.instance_name != inst.type_name && val.starts_with(&type_default_prefix) {
format!("{}{}", instance_prefix, &val[type_default_prefix.len()..])
} else if global_output_dir != "out" && val.starts_with("out/") {
format!("{}/{}", global_output_dir, &val[4..])
} else {
continue;
};
if let Some(table) = inst.config_toml.as_table_mut() {
table.insert(field.to_string(), toml::Value::String(new_val));
}
if matches!(
inst.provenance.get(*field),
Some(FieldProvenance::ProcessorDefault) | None,
) {
inst.provenance.insert((*field).to_string(), FieldProvenance::OutputDirDefault);
}
}
}
}
pub(crate) fn first_instance_of_type(&self, type_name: &str) -> Option<&ProcessorInstance> {
self.instances.iter().find(|i| i.type_name == type_name)
}
pub(crate) fn instance_field_str(&self, type_name: &str, field: &str) -> Option<String> {
self.first_instance_of_type(type_name)
.and_then(|inst| inst.config_toml.get(field))
.and_then(|v| v.as_str())
.map(std::string::ToString::to_string)
}
}
pub fn default_cc_compiler() -> String {
"gcc".into()
}
pub fn default_cxx_compiler() -> String {
"g++".into()
}
pub fn default_output_suffix() -> String {
".elf".into()
}
#[derive(Debug, Deserialize, Serialize, Clone)]
#[serde(deny_unknown_fields)]
pub 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()] }
}
}
#[derive(Debug, Clone)]
pub struct AnalyzerInstance {
pub instance_name: String,
pub type_name: String,
pub config_toml: toml::Value,
pub provenance: ProvenanceMap,
}
#[derive(Debug, Default)]
pub struct AnalyzerConfig {
pub instances: Vec<AnalyzerInstance>,
}
impl Serialize for AnalyzerConfig {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error> {
use serde::ser::SerializeMap;
let mut map = serializer.serialize_map(None)?;
for inst in &self.instances {
if inst.instance_name == inst.type_name {
map.serialize_entry(&inst.instance_name, &inst.config_toml)?;
}
}
let mut types: HashMap<&str, Vec<&AnalyzerInstance>> = HashMap::new();
for inst in &self.instances {
if inst.instance_name != inst.type_name {
types.entry(inst.type_name.as_str()).or_default().push(inst);
}
}
for (type_name, insts) in &types {
let mut table = toml::map::Map::new();
for inst in insts {
let name = &inst.instance_name[type_name.len() + 1..];
table.insert(name.to_string(), inst.config_toml.clone());
}
map.serialize_entry(type_name, &toml::Value::Table(table))?;
}
map.end()
}
}
impl<'de> Deserialize<'de> for AnalyzerConfig {
fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> std::result::Result<Self, D::Error> {
let table = toml::Value::deserialize(deserializer)?;
AnalyzerConfig::from_toml(&table).map_err(serde::de::Error::custom)
}
}
impl AnalyzerConfig {
pub(crate) fn from_toml(value: &toml::Value) -> Result<Self> {
let Some(table) = value.as_table() else {
return Ok(Self::default());
};
let mut instances = Vec::new();
for (type_name, val) in table {
if registry::find_analyzer_plugin(type_name).is_none() {
anyhow::bail!("Unknown analyzer '{type_name}'. Run 'rsconstruct analyzers list' to see available analyzers.");
}
let Some(sub_table) = val.as_table() else {
anyhow::bail!("Expected [analyzer.{type_name}] to be a table");
};
if Self::is_multi_instance(sub_table) {
for (name, inst_val) in sub_table {
let provenance = seed_user_provenance(inst_val);
instances.push(AnalyzerInstance {
instance_name: format!("{type_name}.{name}"),
type_name: type_name.clone(),
config_toml: inst_val.clone(),
provenance,
});
}
} else {
let provenance = seed_user_provenance(val);
instances.push(AnalyzerInstance {
instance_name: type_name.clone(),
type_name: type_name.clone(),
config_toml: val.clone(),
provenance,
});
}
}
Ok(Self { instances })
}
fn is_multi_instance(table: &toml::map::Map<String, toml::Value>) -> bool {
!table.is_empty() && table.values().all(toml::Value::is_table)
}
}
#[derive(Debug, Deserialize, Serialize, Clone, Default)]
#[serde(deny_unknown_fields)]
pub struct GraphConfig {
#[serde(default)]
pub viewer: Option<String>,
#[serde(default = "default_true")]
pub validate_empty_inputs: bool,
#[serde(default = "default_true")]
pub validate_dep_references: bool,
#[serde(default)]
pub validate_duplicate_inputs: bool,
#[serde(default)]
pub validate_early_cycles: bool,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum FieldType {
String,
Bool,
Integer,
StringArray,
TableArray,
}
impl FieldType {
const 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(toml::Value::is_str)),
FieldType::TableArray => value.as_array()
.is_some_and(|arr| arr.iter().all(toml::Value::is_table)),
}
}
const 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 {
"src_dirs" => return Some(FieldType::StringArray),
"src_extensions" => return Some(FieldType::StringArray),
"src_exclude_dirs" => return Some(FieldType::StringArray),
"src_exclude_files" => return Some(FieldType::StringArray),
"src_exclude_paths" => return Some(FieldType::StringArray),
"src_files" => return Some(FieldType::StringArray),
"args" => return Some(FieldType::StringArray),
"dep_inputs" => return Some(FieldType::StringArray),
"dep_auto" => return Some(FieldType::StringArray),
"max_jobs" => return Some(FieldType::Integer),
"enabled" => return Some(FieldType::Bool),
"cache" => return Some(FieldType::Bool),
"batch" => return Some(FieldType::Bool),
_ => {}
}
match (processor, field) {
("ruff", "command") => 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),
("zspell", "language" | "words_file") => Some(FieldType::String),
("zspell", "auto_add_words") => Some(FieldType::Bool),
("make", "command" | "target") => Some(FieldType::String),
("cargo", "profiles") => Some(FieldType::StringArray),
("cargo" | "clippy", "cargo" | "command") => Some(FieldType::String),
("mypy" | "pyrefly" | "shellcheck" | "luacheck" | "script", "checker") => Some(FieldType::String),
("rumdl" | "yamllint" | "jsonlint" | "taplo", "linter") => Some(FieldType::String),
("jq", "checker") => Some(FieldType::String),
("tags", "output" | "tags_dir") => Some(FieldType::String),
("pip", "command") => Some(FieldType::String),
("sphinx", "command" | "output_dir" | "working_dir") => Some(FieldType::String),
("mdbook", "command" | "output_dir") => Some(FieldType::String),
("npm", "command") => Some(FieldType::String),
("gem", "command" | "gem_home") => Some(FieldType::String),
("mdl", "gem_home" | "command" | "gem_stamp") => Some(FieldType::String),
("mdl", "local_repo") => Some(FieldType::Bool),
("markdownlint", "command" | "npm_stamp") => Some(FieldType::String),
("markdownlint", "local_repo") => Some(FieldType::Bool),
("aspell", "command" | "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", "command" | "output_dir" | "pdf_engine") => Some(FieldType::String),
("pandoc", "formats") => Some(FieldType::StringArray),
("markdown2html", "markdown_bin" | "output_dir") => Some(FieldType::String),
("pdflatex", "command" | "output_dir") => Some(FieldType::String),
("pdflatex", "runs") => Some(FieldType::Integer),
("pdflatex", "qpdf") => Some(FieldType::Bool),
("a2x", "a2x" | "output_dir") => Some(FieldType::String),
("chromium", "chromium_bin" | "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", "command" | "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_single_processor(
type_name: &str,
section_label: &str,
table: &toml::map::Map<String, toml::Value>,
errors: &mut Vec<String>,
) {
let own_fields: &[&str] = match ProcessorConfig::known_fields_for(type_name) {
Some(fields) => fields,
None => return, };
for (key, field_value) in table {
if !own_fields.contains(&key.as_str())
&& !SCAN_CONFIG_FIELDS.contains(&key.as_str())
&& !STANDARD_EXTRA_FIELDS.contains(&key.as_str())
{
let all_fields: Vec<&str> = own_fields.iter()
.chain(SCAN_CONFIG_FIELDS.iter())
.chain(STANDARD_EXTRA_FIELDS.iter())
.copied()
.collect();
errors.push(format!(
"[{}]: unknown field '{}' (valid fields: {})",
section_label, key, all_fields.join(", ")
));
continue;
}
if let Some(expected) = expected_field_type(type_name, key)
&& !expected.matches(field_value)
{
errors.push(format!(
"[{}]: field '{}' must be {}, got {} ({})",
section_label, key, expected.label(),
FieldType::describe_value(field_value),
field_value,
));
}
}
if let Some(must) = ProcessorConfig::must_fields_for(type_name) {
for field in must {
match table.get(*field) {
None => {
errors.push(format!(
"[{section_label}]: required field '{field}' must be specified",
));
}
Some(toml::Value::Array(arr)) if arr.is_empty() => {
errors.push(format!(
"[{section_label}]: required field '{field}' must not be empty",
));
}
Some(toml::Value::String(s)) if s.is_empty() => {
errors.push(format!(
"[{section_label}]: required field '{field}' must not be empty",
));
}
_ => {} }
}
}
const SCAN_DIRS_EXEMPT: &[&str] = &["explicit", "pdfunite", "ipdfunite"];
let has_match_paths = table.get("src_files")
.and_then(|v| v.as_array())
.is_some_and(|arr| !arr.is_empty());
if ProcessorConfig::default_src_dirs_for(type_name).is_some_and(<[&str]>::is_empty)
&& !SCAN_DIRS_EXEMPT.contains(&type_name)
&& !has_match_paths {
match table.get("src_dirs") {
None => {
errors.push(format!(
"[{section_label}]: 'src_dirs' must be specified (this processor defaults to scanning the project root)",
));
}
Some(toml::Value::Array(arr))
if arr.len() == 1
&& arr[0].as_str().is_some_and(str::is_empty) =>
{
errors.push(format!(
"[{section_label}]: 'src_dirs' must not contain empty strings; specify actual directories to scan",
));
}
_ => {} }
}
}
fn validate_processor_fields_raw(raw: &toml::Value) -> Vec<String> {
let Some(processor_table) = raw.get("processor").and_then(|v| v.as_table()) else {
return Vec::new();
};
let mut errors = Vec::new();
for (name, value) in processor_table {
let Some(table) = value.as_table() else { continue };
if !is_builtin_type(name) {
let plugins_dir = raw.get("plugins")
.and_then(|p| p.get("dir"))
.and_then(|d| d.as_str())
.unwrap_or(DEFAULT_PLUGINS_DIR);
let plugin_path = std::path::Path::new(plugins_dir)
.join(format!("{name}.lua"));
if !plugin_path.exists() {
errors.push(format!(
"[processor.{}]: unknown processor type '{}' (not a builtin processor or Lua plugin at {})",
name, name, plugin_path.display(),
));
}
continue;
}
if ProcessorConfig::is_multi_instance(name, table) {
for (inst_name, inst_value) in table {
if let Some(inst_table) = inst_value.as_table() {
let section = format!("processor.{name}.{inst_name}");
validate_single_processor(name, §ion, inst_table, &mut errors);
}
}
} else {
let section = format!("processor.{name}");
validate_single_processor(name, §ion, table, &mut errors);
}
}
errors
}
fn validate_analyzer_fields_raw(raw: &toml::Value) -> Vec<String> {
let Some(analyzer_table) = raw.get("analyzer").and_then(|v| v.as_table()) else {
return Vec::new();
};
let mut errors = Vec::new();
for (type_name, value) in analyzer_table {
let Some(table) = value.as_table() else {
errors.push(format!("[analyzer.{type_name}]: expected a table"));
continue;
};
let Some(plugin) = registry::find_analyzer_plugin(type_name) else {
errors.push(format!(
"[analyzer.{type_name}]: unknown analyzer type '{type_name}' (run 'rsconstruct analyzers list' to see available)",
));
continue;
};
let is_multi_instance = !table.is_empty() && table.values().all(toml::Value::is_table);
if is_multi_instance {
for (inst_name, inst_value) in table {
if let Some(inst_table) = inst_value.as_table() {
let section = format!("analyzer.{type_name}.{inst_name}");
validate_analyzer_section(plugin, §ion, inst_table, &mut errors);
}
}
} else {
let section = format!("analyzer.{type_name}");
validate_analyzer_section(plugin, §ion, table, &mut errors);
}
}
errors
}
fn validate_analyzer_section(
plugin: ®istry::AnalyzerPlugin,
section_label: &str,
table: &toml::map::Map<String, toml::Value>,
errors: &mut Vec<String>,
) {
let known = (plugin.known_fields)();
for key in table.keys() {
if !known.contains(&key.as_str()) {
errors.push(format!(
"[{}]: unknown field '{}' (valid fields: {})",
section_label, key, known.join(", ")
));
}
}
}
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, span_map, global_span_map) = 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()))?;
let mut all_errors = validate_processor_fields_raw(&raw);
all_errors.extend(validate_analyzer_fields_raw(&raw));
if !all_errors.is_empty() {
anyhow::bail!("Invalid config:\n{}", all_errors.join("\n"));
}
let config: Config = toml::from_str(&substituted)
.with_context(|| format!("Failed to parse config file: {}", config_path.display()))?;
let spans = provenance::build_span_map(&substituted);
let global_spans = provenance::build_global_span_map(&substituted);
(config, spans, global_spans)
} else {
(Config::default(), SpanMap::new(), provenance::GlobalSpanMap::new())
};
config.processor.resolve_scan_defaults();
config.processor.apply_output_dir_defaults(&config.build.output_dir);
config.apply_span_map(&span_map);
config.populate_global_provenance(&global_span_map)?;
crate::phases::run_phase(crate::phases::Phase::PostConfig, &mut config)?;
Ok(config)
}
pub(crate) fn apply_overrides(&mut self, iset: &[String], pset: &[String]) -> Result<()> {
for raw in iset {
let (iname, field, value) = parse_override_entry(raw, "--iset")?;
apply_override_to_instances(&mut self.processor.instances, field, &value, |inst| {
inst.instance_name == iname
}, "iname", iname)?;
}
for raw in pset {
let (pname, field, value) = parse_override_entry(raw, "--pset")?;
apply_override_to_instances(&mut self.processor.instances, field, &value, |inst| {
inst.type_name == pname
}, "pname", pname)?;
}
Ok(())
}
fn populate_global_provenance(
&mut self,
global_spans: &provenance::GlobalSpanMap,
) -> Result<()> {
let serialized = toml::Value::try_from(&*self)
.context("Failed to serialize config for global provenance walk")?;
let Some(root) = serialized.as_table() else { return Ok(()) };
for (section_name, section_value) in root {
if section_name == "processor" || section_name == "analyzer" {
continue;
}
let Some(section_table) = section_value.as_table() else { continue };
let user_fields = global_spans.get(section_name);
let mut map = ProvenanceMap::new();
for field in section_table.keys() {
let source = match user_fields.and_then(|f| f.get(field)) {
Some(&line) => FieldProvenance::UserToml { line },
None => FieldProvenance::SerdeDefault,
};
map.insert(field.clone(), source);
}
self.global_provenance.insert(section_name.clone(), map);
}
Ok(())
}
fn apply_span_map(&mut self, spans: &SpanMap) {
for inst in &mut self.processor.instances {
apply_spans_to_instance(&mut inst.provenance, spans, Section::Processor, &inst.instance_name);
}
for inst in &mut self.analyzer.instances {
apply_spans_to_instance(&mut inst.provenance, spans, Section::Analyzer, &inst.instance_name);
}
}
}
fn apply_spans_to_instance(
provenance: &mut ProvenanceMap,
spans: &SpanMap,
section: Section,
instance_name: &str,
) {
let keys: Vec<String> = provenance.keys().cloned().collect();
for key in keys {
if let Some(FieldProvenance::UserToml { line }) = provenance.get(&key) {
if *line != 0 {
continue; }
if let Some(&real_line) = spans.get(&(section, instance_name.to_string(), key.clone())) {
provenance.insert(key, FieldProvenance::UserToml { line: real_line });
}
}
}
}
fn parse_override_entry<'a>(raw: &'a str, flag: &str) -> Result<(&'a str, &'a str, toml::Value)> {
let (lhs, value_str) = raw.split_once('=').ok_or_else(|| anyhow::anyhow!(
"{flag} '{raw}': missing '=' (expected <name>.<field>=<value>)"
))?;
let (name, field) = lhs.split_once('.').ok_or_else(|| anyhow::anyhow!(
"{flag} '{raw}': missing '.' between name and field (expected <name>.<field>=<value>)"
))?;
if name.is_empty() {
anyhow::bail!("{flag} '{raw}': empty name before '.'");
}
if field.is_empty() {
anyhow::bail!("{flag} '{raw}': empty field between '.' and '='");
}
let parsed: toml::Value = match toml::from_str::<toml::Value>(&format!("v = {value_str}")) {
Ok(toml::Value::Table(mut t)) => t.remove("v").unwrap_or_else(|| toml::Value::String(value_str.to_string())),
_ => toml::Value::String(value_str.to_string()),
};
Ok((name, field, parsed))
}
fn apply_override_to_instances(
instances: &mut [ProcessorInstance],
field: &str,
value: &toml::Value,
predicate: impl Fn(&ProcessorInstance) -> bool,
name_kind: &str,
name: &str,
) -> Result<()> {
let matching_indices: Vec<usize> = instances.iter().enumerate()
.filter(|(_, inst)| predicate(inst))
.map(|(i, _)| i)
.collect();
if matching_indices.is_empty() {
anyhow::bail!("no processor instance with {name_kind} '{name}'");
}
for i in matching_indices {
let inst = &mut instances[i];
let type_name = inst.type_name.clone();
validate_override_field(&type_name, field, value, &inst.instance_name)?;
if let Some(table) = inst.config_toml.as_table_mut() {
table.insert(field.to_string(), value.clone());
inst.provenance.insert(field.to_string(), FieldProvenance::CliOverride);
} else {
anyhow::bail!(
"instance '{}' config is not a table (cannot apply override)",
inst.instance_name
);
}
}
Ok(())
}
fn validate_override_field(
type_name: &str,
field: &str,
value: &toml::Value,
instance_label: &str,
) -> Result<()> {
let own_fields = ProcessorConfig::known_fields_for(type_name).unwrap_or(&[]);
let is_known = own_fields.contains(&field)
|| SCAN_CONFIG_FIELDS.contains(&field)
|| STANDARD_EXTRA_FIELDS.contains(&field);
if !is_known {
let mut all_fields: Vec<&str> = own_fields.iter()
.chain(SCAN_CONFIG_FIELDS.iter())
.chain(STANDARD_EXTRA_FIELDS.iter())
.copied()
.collect();
all_fields.sort_unstable();
all_fields.dedup();
anyhow::bail!(
"instance '{instance_label}' (type {type_name}): unknown field '{field}' (valid fields: {})",
all_fields.join(", ")
);
}
if let Some(expected) = expected_field_type(type_name, field)
&& !expected.matches(value)
{
anyhow::bail!(
"instance '{instance_label}' (type {type_name}): field '{field}' must be {}, got {} ({value})",
expected.label(),
FieldType::describe_value(value),
);
}
Ok(())
}
pub fn standard_config_from_toml(
value: &toml::Value,
default_src_dirs: &[&str],
default_src_extensions: &[&str],
default_exclude_dirs: &[&str],
) -> StandardConfig {
let table = value.as_table();
let toml_array = |key: &str| -> Option<Vec<String>> {
table
.and_then(|t| t.get(key))
.and_then(|v| v.as_array())
.map(|arr| arr.iter().filter_map(|v| v.as_str().map(String::from)).collect())
};
let mut cfg = StandardConfig {
src_dirs: toml_array("src_dirs"),
src_extensions: toml_array("src_extensions"),
src_exclude_dirs: toml_array("src_exclude_dirs"),
src_exclude_files: toml_array("src_exclude_files"),
src_exclude_paths: toml_array("src_exclude_paths"),
src_files: toml_array("src_files"),
..StandardConfig::default()
};
if cfg.src_dirs.is_none() {
cfg.src_dirs = Some(default_src_dirs.iter().map(std::string::ToString::to_string).collect());
}
if cfg.src_extensions.is_none() {
cfg.src_extensions = Some(default_src_extensions.iter().map(std::string::ToString::to_string).collect());
}
if cfg.src_exclude_dirs.is_none() {
cfg.src_exclude_dirs = Some(default_exclude_dirs.iter().map(std::string::ToString::to_string).collect());
}
if cfg.src_exclude_files.is_none() {
cfg.src_exclude_files = Some(Vec::new());
}
if cfg.src_exclude_paths.is_none() {
cfg.src_exclude_paths = Some(Vec::new());
}
if cfg.src_files.is_none() {
cfg.src_files = Some(Vec::new());
}
cfg
}
#[allow(clippy::unnecessary_wraps)] fn eatmydata_ci_default(config: &mut Config) -> anyhow::Result<()> {
if std::env::var("CI").is_ok_and(|v| v == "true") {
config.dependencies.eatmydata = true;
}
Ok(())
}
inventory::submit! { crate::phases::PhaseHook {
name: "eatmydata_ci_default",
phase: crate::phases::Phase::PostConfig,
description: "When CI=true, enable eatmydata wrapping for apt/dnf/pacman installs",
function: concat!(module_path!(), "::eatmydata_ci_default"),
location: concat!(file!(), ":", line!()),
run: eatmydata_ci_default,
} }