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 variables::substitute_variables;
const CONFIG_FILE: &str = "rsconstruct.toml";
pub(crate) const SCAN_CONFIG_FIELDS: &[&str] = &[
"scan_dir", "extensions", "exclude_dirs", "exclude_files", "exclude_paths",
];
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)
}
const NON_OUTPUT_FIELDS: &[&str] = &[
"scan_dir", "extensions", "exclude_dirs", "exclude_files", "exclude_paths",
"extra_inputs", "auto_inputs", "batch",
];
pub(crate) fn output_config_hash(value: &impl Serialize, extra_exclude: &[&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(mut map) = json_value {
for field in NON_OUTPUT_FIELDS {
map.remove(*field);
}
for field in extra_exclude {
map.remove(*field);
}
serde_json::Value::Object(map)
} else {
json_value
};
let json = serde_json::to_string(&filtered).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)
}
}
pub(crate) const COMMON_EXCLUDE_DIRS: &[&str] = &["/.git/", "/out/", "/build/", "/dist/"];
pub(crate) const BUILD_TOOL_EXCLUDES: &[&str] = &[
"/.git/", "/out/", "/build/", "/dist/",
"/.rsconstruct/", "/node_modules/", "/target/", "/gems/",
];
pub(crate) const PYTHON_EXCLUDE_DIRS: &[&str] = &[
"/.git/", "/out/", "/build/", "/dist/",
"/.venv/", "/__pycache__/", "/node_modules/", "/.tox/", "/.eggs/",
];
pub(crate) const CC_EXCLUDE_DIRS: &[&str] = COMMON_EXCLUDE_DIRS;
pub(crate) const ZSPELL_EXCLUDE_DIRS: &[&str] = BUILD_TOOL_EXCLUDES;
pub(crate) const SHELL_EXCLUDE_DIRS: &[&str] = BUILD_TOOL_EXCLUDES;
pub(crate) const MARKDOWN_EXCLUDE_DIRS: &[&str] = BUILD_TOOL_EXCLUDES;
pub(crate) 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
}
#[derive(Debug, Clone)]
pub(crate) struct ProcessorInstance {
pub instance_name: String,
pub type_name: String,
pub config_toml: toml::Value,
}
macro_rules! gen_processor_config {
( $( $const_name:ident, $field:ident, $config_type:ty, $proc_type:ty,
($scan_dir:expr, $exts:expr, $excl:expr); )* ) => {
pub(crate) fn all_type_names() -> Vec<&'static str> {
vec![ $( stringify!($field), )* ]
}
pub(crate) fn is_builtin_type(name: &str) -> bool {
matches!(name, $( stringify!($field) )|*)
}
pub(crate) fn resolve_instance_scan_defaults(type_name: &str, value: &mut toml::Value) -> anyhow::Result<()> {
match type_name {
$(
stringify!($field) => {
let mut cfg: $config_type = toml::from_str(&toml::to_string(value)?)?;
cfg.scan.resolve($scan_dir, $exts, $excl);
*value = toml::Value::try_from(&cfg)?;
Ok(())
}
)*
_ => Ok(()), }
}
impl ProcessorConfig {
pub(crate) fn scan_dirs(&self) -> Vec<String> {
let mut dirs: Vec<String> = self.instances.iter()
.filter_map(|inst| {
inst.config_toml.get("scan_dir")
.and_then(|v| v.as_str())
.filter(|d| !d.is_empty())
.map(|d| d.to_string())
})
.collect();
dirs.sort();
dirs.dedup();
dirs
}
pub(crate) fn known_fields_for(type_name: &str) -> Option<&'static [&'static str]> {
match type_name {
$( stringify!($field) => Some(<$config_type as KnownFields>::known_fields()), )*
_ => None,
}
}
pub(crate) fn defconfig_json(type_name: &str) -> Option<String> {
let json: serde_json::Value = match type_name {
$( stringify!($field) => {
let mut cfg = <$config_type>::default();
cfg.scan.resolve($scan_dir, $exts, $excl);
serde_json::to_value(cfg).ok()?
}, )*
_ => return None,
};
serde_json::to_string_pretty(&json).ok()
}
}
};
}
for_each_processor!(gen_processor_config);
#[derive(Debug, Default)]
pub(crate) 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)?;
ProcessorConfig::from_toml(&table).map_err(serde::de::Error::custom)
}
}
impl ProcessorConfig {
pub(crate) fn from_toml(value: &toml::Value) -> Result<Self> {
let table = match value.as_table() {
Some(t) => t,
None => return Ok(Self::default()),
};
let mut instances = Vec::new();
let mut extra = HashMap::new();
for (key, val) in table {
let sub_table = match val.as_table() {
Some(t) => t,
None => 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();
resolve_instance_scan_defaults(key, &mut config).ok();
instances.push(ProcessorInstance {
instance_name,
type_name: key.clone(),
config_toml: config,
});
}
} else {
let mut config = val.clone();
resolve_instance_scan_defaults(key, &mut config).ok();
instances.push(ProcessorInstance {
instance_name: key.clone(),
type_name: key.clone(),
config_toml: config,
});
}
} else {
extra.insert(key.clone(), val.clone());
}
}
Ok(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())
.copied()
.collect(),
None => return false,
};
for key in table.keys() {
if known_fields.contains(&key.as_str()) {
return false;
}
}
table.values().all(|v| v.is_table())
}
pub(crate) fn resolve_scan_defaults(&mut self) {
for inst in &mut self.instances {
resolve_instance_scan_defaults(&inst.type_name, &mut inst.config_toml).ok();
}
}
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(|s| s.to_string())
}
}
pub(crate) fn default_script_linter() -> String {
"true".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, 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),
"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),
("zspell", "language" | "words_file") => Some(FieldType::String),
("zspell", "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", "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", "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),
("mdl", "local_repo") => Some(FieldType::Bool),
("markdownlint", "markdownlint_bin" | "npm_stamp") => Some(FieldType::String),
("markdownlint", "local_repo") => Some(FieldType::Bool),
("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),
("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", "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_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()) {
let all_fields: Vec<&str> = own_fields.iter()
.chain(SCAN_CONFIG_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,
));
}
}
}
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, };
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!("{}.lua", name));
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);
}
}
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
}