mod checkers;
mod generators;
mod mass_generators;
pub mod lua_processor;
use anyhow::{Context, Result};
#[cfg(debug_assertions)]
use std::cell::RefCell;
use std::collections::{HashMap, HashSet};
use std::fs;
use std::io::Write;
use std::path::{Path, PathBuf};
use std::process::{Command, Output};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::OnceLock;
use std::time::Duration;
use tokio::runtime::Runtime;
use tokio::sync::watch;
use crate::color;
use crate::errors;
use crate::config::{config_hash, resolve_extra_inputs};
use crate::file_index::FileIndex;
use crate::graph::{BuildGraph, Product};
macro_rules! gen_processor_names {
( $( $const_name:ident, $field:ident, $config_type:ty, $proc_type:ty,
($($scan_args:tt)*); )* ) => {
pub mod names {
$( pub const $const_name: &str = stringify!($field); )*
}
};
}
for_each_processor!(gen_processor_names);
static INTERRUPTED: AtomicBool = AtomicBool::new(false);
static RUNTIME: OnceLock<Runtime> = OnceLock::new();
static INTERRUPT_SENDER: OnceLock<watch::Sender<bool>> = OnceLock::new();
fn get_runtime() -> &'static Runtime {
RUNTIME.get_or_init(|| {
Runtime::new().expect(errors::TOKIO_RUNTIME)
})
}
fn get_interrupt_sender() -> &'static watch::Sender<bool> {
INTERRUPT_SENDER.get_or_init(|| {
let (tx, _rx) = watch::channel(false);
tx
})
}
fn get_interrupt_receiver() -> watch::Receiver<bool> {
get_interrupt_sender().subscribe()
}
pub(crate) fn resolve_anchor_path(anchor_dir: &Path, rel: &str) -> PathBuf {
if anchor_dir.as_os_str().is_empty() {
PathBuf::from(rel)
} else {
anchor_dir.join(rel)
}
}
pub(crate) fn set_interrupted() {
INTERRUPTED.store(true, Ordering::SeqCst);
let _ = get_interrupt_sender().send(true);
}
#[cfg(debug_assertions)]
thread_local! {
static DECLARED_TOOLS: RefCell<Option<Vec<String>>> = const { RefCell::new(None) };
}
#[cfg(debug_assertions)]
pub(crate) fn set_declared_tools(tools: Option<Vec<String>>) {
DECLARED_TOOLS.with(|dt| {
*dt.borrow_mut() = tools;
});
}
#[cfg(not(debug_assertions))]
pub(crate) fn set_declared_tools(_tools: Option<Vec<String>>) {}
#[cfg(debug_assertions)]
pub(crate) fn suspend_tool_check() -> ToolCheckGuard {
let prev = DECLARED_TOOLS.with(|dt| dt.borrow_mut().take());
ToolCheckGuard { prev }
}
#[cfg(not(debug_assertions))]
pub(crate) fn suspend_tool_check() -> ToolCheckGuard {
ToolCheckGuard { _private: () }
}
#[cfg(debug_assertions)]
pub(crate) struct ToolCheckGuard {
prev: Option<Vec<String>>,
}
#[cfg(debug_assertions)]
impl Drop for ToolCheckGuard {
fn drop(&mut self) {
DECLARED_TOOLS.with(|dt| {
*dt.borrow_mut() = self.prev.take();
});
}
}
#[cfg(not(debug_assertions))]
pub(crate) struct ToolCheckGuard {
_private: (),
}
pub(crate) fn format_command(cmd: &Command) -> String {
let program = cmd.get_program().to_string_lossy();
let args: Vec<_> = cmd.get_args()
.map(|a| a.to_string_lossy())
.collect();
if args.is_empty() {
program.into_owned()
} else {
format!("{} {}", program, args.join(" "))
}
}
pub(crate) fn log_command(cmd: &Command) {
if crate::runtime_flags::show_child_processes() {
let cwd = cmd.get_current_dir()
.map(|p| p.display().to_string())
.unwrap_or_default();
if cwd.is_empty() {
eprintln!("{} {}", color::dim("[exec]"), format_command(cmd));
} else {
let cwd_info = format!("(in {})", cwd);
eprintln!("{} {} {}", color::dim("[exec]"), format_command(cmd), color::dim(&cwd_info));
}
}
}
fn run_command_inner(cmd: &mut Command, inherit_stdio: bool) -> Result<Output> {
log_command(cmd);
#[cfg(debug_assertions)]
DECLARED_TOOLS.with(|dt| {
if let Some(ref tools) = *dt.borrow() {
let program = cmd.get_program().to_string_lossy();
let basename = program.rsplit('/').next().unwrap_or(&program);
assert!(
tools.iter().any(|t| {
let t_basename = t.rsplit('/').next().unwrap_or(t);
t_basename == basename
}),
"Processor executed undeclared tool '{basename}'. Declared: {tools:?}",
);
}
});
if INTERRUPTED.load(Ordering::SeqCst) {
anyhow::bail!("Interrupted");
}
let program = cmd.get_program().to_os_string();
let args: Vec<_> = cmd.get_args().map(|a| a.to_os_string()).collect();
let current_dir = cmd.get_current_dir().map(|p| p.to_path_buf());
let envs: Vec<_> = cmd.get_envs()
.filter_map(|(k, v)| v.map(|val| (k.to_os_string(), val.to_os_string())))
.collect();
let rt = get_runtime();
rt.block_on(async {
let mut tokio_cmd = tokio::process::Command::new(&program);
tokio_cmd.args(&args);
if let Some(dir) = ¤t_dir {
tokio_cmd.current_dir(dir);
}
for (key, val) in &envs {
tokio_cmd.env(key, val);
}
if inherit_stdio {
tokio_cmd.stdout(std::process::Stdio::inherit());
tokio_cmd.stderr(std::process::Stdio::inherit());
} else {
tokio_cmd.stdout(std::process::Stdio::piped());
tokio_cmd.stderr(std::process::Stdio::piped());
}
tokio_cmd.kill_on_drop(true);
let child = tokio_cmd.spawn()
.with_context(|| {
let prog = program.to_string_lossy();
let total_len: usize = prog.len() + args.iter().map(|a| a.len() + 1).sum::<usize>();
let arg_count = args.len();
if total_len > 100_000 {
format!(
"Failed to spawn '{}' with {} arguments (total command length ~{} bytes). \
This usually means the argument list is too long for the OS (E2BIG). \
Consider reducing the number of files or excluding directories.",
prog, arg_count, total_len
)
} else {
format!("Failed to spawn: {} {}", prog,
args.iter().map(|a| a.to_string_lossy()).collect::<Vec<_>>().join(" "))
}
})?;
let mut interrupt_rx = get_interrupt_receiver();
if INTERRUPTED.load(Ordering::SeqCst) {
anyhow::bail!("Interrupted");
}
tokio::select! {
biased;
_ = interrupt_rx.changed() => {
anyhow::bail!("Interrupted")
}
result = child.wait_with_output() => {
let output = result.context("Failed to wait for child process")?;
Ok(output)
}
}
})
}
pub(crate) fn run_command(cmd: &mut Command) -> Result<Output> {
let show = crate::runtime_flags::show_output();
run_command_inner(cmd, show)
}
pub(crate) fn run_command_capture(cmd: &mut Command) -> Result<Output> {
run_command_inner(cmd, false)
}
pub(crate) fn check_command_output(output: &Output, context: impl std::fmt::Display) -> Result<()> {
if !output.status.success() {
use std::fmt::Write;
let mut msg = format!("{context} failed");
let stderr = String::from_utf8_lossy(&output.stderr);
let stdout = String::from_utf8_lossy(&output.stdout);
if !stderr.is_empty() {
let _ = write!(msg, "\nstderr:\n{}", stderr.trim_end());
}
if !stdout.is_empty() {
let _ = write!(msg, "\nstdout:\n{}", stdout.trim_end());
}
anyhow::bail!("{msg}");
}
Ok(())
}
pub(crate) fn scan_root(scan: &crate::config::ScanConfig) -> PathBuf {
PathBuf::from(scan.scan_dir())
}
pub(crate) fn scan_root_valid(scan: &crate::config::ScanConfig) -> bool {
let root = scan_root(scan);
root.as_os_str().is_empty() || root.exists()
}
pub(crate) fn stub_path(stub_dir: &Path, source: &Path, suffix: &str) -> PathBuf {
let stub_name = format!(
"{}.{}",
source.display().to_string().replace(['/', '\\'], "_"),
suffix,
);
stub_dir.join(stub_name)
}
pub(crate) fn dot_to_svg(dot_content: &str) -> Result<String> {
use std::process::{Command, Stdio};
let mut cmd = Command::new("dot");
cmd.arg("-Tsvg")
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::piped());
log_command(&cmd);
let mut child = cmd
.spawn()
.map_err(|_| anyhow::anyhow!("Graphviz 'dot' command not found. Install Graphviz to use SVG format"))?;
child.stdin.take().expect(crate::errors::STDIN_PIPED).write_all(dot_content.as_bytes())?;
let output = child.wait_with_output()?;
check_command_output(&output, "dot")?;
Ok(String::from_utf8(output.stdout)?)
}
pub(crate) fn flush_words(
existing: &HashSet<String>,
new_words: &HashSet<String>,
words_path: &Path,
header_line: Option<&str>,
) -> Result<()> {
let to_add: Vec<_> = new_words.iter()
.filter(|w| !existing.contains(*w))
.collect();
if to_add.is_empty() {
return Ok(());
}
let mut sorted: Vec<_> = to_add;
sorted.sort();
let file_exists = words_path.exists();
let mut file = std::fs::OpenOptions::new()
.create(true)
.append(true)
.open(words_path)
.with_context(|| format!("Failed to open words file: {}", words_path.display()))?;
if !file_exists
&& let Some(header) = header_line {
writeln!(file, "{}", header)?;
}
for word in &sorted {
writeln!(file, "{}", word)?;
}
println!("Added {} word(s) to {}", sorted.len(), words_path.display());
Ok(())
}
pub(crate) fn config_file_inputs(path: &str) -> Vec<String> {
if Path::new(path).exists() {
vec![path.to_string()]
} else {
Vec::new()
}
}
pub(crate) fn ensure_output_dir(output: &Path) -> Result<()> {
if let Some(parent) = output.parent() {
fs::create_dir_all(parent)
.with_context(|| format!("Failed to create output directory: {}", parent.display()))?;
}
Ok(())
}
pub(crate) fn clean_output_dir(product: &Product, processor_name: &str, verbose: bool) -> Result<usize> {
if let Some(ref output_dir) = product.output_dir
&& output_dir.exists()
{
if verbose {
println!("Removing {} output directory: {}", processor_name, output_dir.display());
}
fs::remove_dir_all(output_dir.as_ref())?;
return Ok(1);
}
Ok(0)
}
pub(crate) fn build_anchor_inputs(anchor: &Path, sibling_files: &[PathBuf], extra: &[PathBuf]) -> Vec<PathBuf> {
let mut inputs: Vec<PathBuf> = Vec::with_capacity(1 + sibling_files.len() + extra.len());
inputs.push(anchor.to_path_buf());
for file in sibling_files {
if *file != anchor {
inputs.push(file.clone());
}
}
inputs.extend_from_slice(extra);
inputs
}
pub(crate) fn scan_or_skip(scan: &crate::config::ScanConfig, file_index: &FileIndex) -> Option<Vec<PathBuf>> {
if !scan_root_valid(scan) {
return None;
}
let files = file_index.scan(scan, true);
if files.is_empty() {
return None;
}
Some(files)
}
pub(crate) fn clean_outputs(product: &Product, label: &str, verbose: bool) -> Result<usize> {
let mut count = 0;
for output in &product.outputs {
match fs::remove_file(output) {
Ok(()) => {
count += 1;
if verbose {
println!("Removed {} output: {}", label, output.display());
}
}
Err(e) if e.kind() == std::io::ErrorKind::NotFound => {}
Err(e) => return Err(e.into()),
}
}
Ok(count)
}
#[derive(Debug)]
pub(crate) struct SiblingFilter<'a> {
pub extensions: &'a [&'a str],
pub excludes: &'a [&'a str],
}
pub(crate) struct DirectoryProductOpts<'a, H: serde::Serialize> {
pub scan: &'a crate::config::ScanConfig,
pub file_index: &'a FileIndex,
pub extra_inputs: &'a [String],
pub cfg_hash: &'a H,
pub siblings: &'a SiblingFilter<'a>,
pub processor_name: &'a str,
pub output_dir_name: Option<&'a str>,
}
pub(crate) fn discover_directory_products(
graph: &mut BuildGraph,
opts: DirectoryProductOpts<'_, impl serde::Serialize>,
) -> Result<()> {
let DirectoryProductOpts { scan, file_index, extra_inputs, cfg_hash, siblings, processor_name, output_dir_name } = opts;
let files = file_index.scan(scan, true);
if files.is_empty() {
return Ok(());
}
let hash = Some(config_hash(cfg_hash));
let extra = resolve_extra_inputs(extra_inputs)?;
for anchor in files {
let anchor_dir = anchor.parent().map(|p| p.to_path_buf()).unwrap_or_default();
let sibling_files = file_index.query(
&anchor_dir,
siblings.extensions,
siblings.excludes,
&[],
&[],
);
let inputs = build_anchor_inputs(&anchor, &sibling_files, &extra);
if let Some(dir_name) = output_dir_name {
let output_dir = if anchor_dir.as_os_str().is_empty() {
PathBuf::from(dir_name)
} else {
anchor_dir.join(dir_name)
};
graph.add_product_with_output_dir(inputs, vec![], processor_name, hash.clone(), output_dir)?;
} else {
graph.add_product(inputs, vec![], processor_name, hash.clone())?;
}
}
Ok(())
}
pub(crate) fn discover_checker_products(
graph: &mut BuildGraph,
scan: &crate::config::ScanConfig,
file_index: &FileIndex,
extra_inputs: &[String],
cfg_hash: &impl serde::Serialize,
processor_name: &str,
) -> Result<()> {
let files = file_index.scan(scan, true);
if files.is_empty() {
return Ok(());
}
let hash = Some(config_hash(cfg_hash));
let extra = resolve_extra_inputs(extra_inputs)?;
for file in files {
let mut inputs = Vec::with_capacity(1 + extra.len());
inputs.push(file);
inputs.extend_from_slice(&extra);
graph.add_product(inputs, vec![], processor_name, hash.clone())?;
}
Ok(())
}
pub(crate) fn run_in_anchor_dir(cmd: &mut Command, anchor: &Path) -> Result<Output> {
let anchor_dir = anchor.parent()
.context("Anchor file has no parent directory")?;
if !anchor_dir.as_os_str().is_empty() {
cmd.current_dir(anchor_dir);
}
run_command(cmd)
}
pub(crate) fn anchor_display_dir(anchor: &Path) -> &str {
anchor.parent()
.and_then(|p| if p.as_os_str().is_empty() { None } else { p.to_str() })
.unwrap_or(".")
}
pub(crate) fn ensure_stub_dir(stub_dir: &Path, processor_name: &str) -> Result<()> {
if !stub_dir.exists() {
fs::create_dir_all(stub_dir)
.with_context(|| format!("Failed to create {} stub directory", processor_name))?;
}
Ok(())
}
const MAX_ARG_LEN: usize = 1_000_000;
pub(crate) fn run_checker(
tool: &str,
subcommand: Option<&str>,
args: &[String],
files: &[&Path],
) -> Result<()> {
let base_len: usize = tool.len()
+ subcommand.map_or(0, |s| s.len() + 1)
+ args.iter().map(|a| a.len() + 1).sum::<usize>();
let files_len: usize = files.iter().map(|f| f.as_os_str().len() + 1).sum();
if base_len + files_len <= MAX_ARG_LEN {
return run_checker_once(tool, subcommand, args, files);
}
let mut chunk_start = 0;
while chunk_start < files.len() {
let mut chunk_len = base_len;
let mut chunk_end = chunk_start;
while chunk_end < files.len() {
let file_len = files[chunk_end].as_os_str().len() + 1;
if chunk_len + file_len > MAX_ARG_LEN && chunk_end > chunk_start {
break;
}
chunk_len += file_len;
chunk_end += 1;
}
run_checker_once(tool, subcommand, args, &files[chunk_start..chunk_end])?;
chunk_start = chunk_end;
}
Ok(())
}
fn run_checker_once(
tool: &str,
subcommand: Option<&str>,
args: &[String],
files: &[&Path],
) -> Result<()> {
let mut cmd = Command::new(tool);
if let Some(sub) = subcommand {
cmd.arg(sub);
}
for arg in args {
cmd.arg(arg);
}
for file in files {
cmd.arg(file);
}
let output = run_command(&mut cmd)?;
check_command_output(&output, tool)
}
pub(crate) fn execute_checker_batch<F>(
products: &[&Product],
batch_fn: F,
) -> Vec<Result<()>>
where
F: Fn(&[&Path]) -> Result<()>,
{
let input_paths: Vec<&Path> = products.iter()
.map(|p| p.primary_input())
.collect();
match batch_fn(&input_paths) {
Ok(()) => products.iter().map(|_| Ok(())).collect(),
Err(e) => {
let err_msg = e.to_string();
products.iter().map(|_| Err(anyhow::anyhow!("{}", err_msg))).collect()
}
}
}
pub use checkers::{
AsciiCheckProcessor, AspellProcessor,
CheckpatchProcessor, ClippyProcessor, ClangTidyProcessor, CppcheckProcessor, CpplintProcessor,
CheckstyleProcessor, CmakeProcessor,
HadolintProcessor, EslintProcessor, HtmlhintProcessor, HtmllintProcessor,
JekyllProcessor, JshintProcessor, JslintProcessor, JqProcessor, JsonlintProcessor, JsonSchemaProcessor,
LuacheckProcessor, MakeProcessor, MarkdownlintProcessor, MdlProcessor, MypyProcessor,
PerlcriticProcessor, PhpLintProcessor, PylintProcessor, PyreflyProcessor, RuffProcessor, RumdlProcessor,
ScriptCheckProcessor, ShellcheckProcessor, SlidevProcessor, SpellcheckProcessor,
StandardProcessor, StylelintProcessor,
TaploProcessor, TidyProcessor, XmllintProcessor, YamllintProcessor, YqProcessor,
};
pub use generators::{A2xProcessor, CcSingleFileProcessor, ChromiumProcessor, DrawioProcessor, LibreofficeProcessor, LinuxModuleProcessor, MakoProcessor, MarpProcessor, MarkdownProcessor, MermaidProcessor, ObjdumpProcessor, PandocProcessor, PdflatexProcessor, PdfuniteProcessor, TagsProcessor, TeraProcessor};
pub use mass_generators::{CargoProcessor, CcProcessor, GemProcessor, MdbookProcessor, NpmProcessor, PipProcessor, SphinxProcessor};
pub(crate) use generators::tags as tags_cmd;
pub use lua_processor::LuaProcessor;
pub type ProcessorMap = HashMap<String, Box<dyn ProductDiscovery>>;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ProcessorType {
Generator,
Checker,
MassGenerator,
}
impl ProcessorType {
pub fn as_str(&self) -> &'static str {
match self {
ProcessorType::Generator => "generator",
ProcessorType::Checker => "checker",
ProcessorType::MassGenerator => "mass_generator",
}
}
}
pub trait ProductDiscovery: Sync + Send {
fn description(&self) -> &str;
fn processor_type(&self) -> ProcessorType {
ProcessorType::Checker
}
fn hidden(&self) -> bool {
false
}
fn discover(&self, graph: &mut BuildGraph, file_index: &FileIndex) -> Result<()>;
fn discover_for_clean(&self, graph: &mut BuildGraph, file_index: &FileIndex) -> Result<()> {
self.discover(graph, file_index)
}
fn execute(&self, product: &Product) -> Result<()>;
fn clean(&self, _product: &Product, _verbose: bool) -> Result<usize> {
Ok(0)
}
fn auto_detect(&self, file_index: &FileIndex) -> bool;
fn required_tools(&self) -> Vec<String> {
Vec::new()
}
fn tool_version_commands(&self) -> Vec<(String, Vec<String>)> {
self.required_tools()
.into_iter()
.map(|tool| (tool, vec!["--version".to_string()]))
.collect()
}
fn supports_batch(&self) -> bool {
false
}
fn execute_batch(&self, products: &[&Product]) -> Vec<Result<()>> {
products.iter().map(|p| self.execute(p)).collect()
}
fn config_json(&self) -> Option<String> {
None
}
}
#[allow(dead_code)]
pub struct InstallMethod {
pub method: &'static str,
pub command: &'static str,
}
pub struct ToolInfo {
pub name: &'static str,
pub runtime: &'static str,
pub install_methods: &'static [InstallMethod],
}
macro_rules! tool {
($name:expr, $runtime:expr, $method:expr, $cmd:expr) => {
ToolInfo {
name: $name,
runtime: $runtime,
install_methods: &[InstallMethod { method: $method, command: $cmd }],
}
};
}
macro_rules! tool_multi {
($name:expr, $runtime:expr, $( ($method:expr, $cmd:expr) ),+ $(,)?) => {
ToolInfo {
name: $name,
runtime: $runtime,
install_methods: &[ $( InstallMethod { method: $method, command: $cmd } ),+ ],
}
};
}
pub static TOOLS: &[ToolInfo] = &[
tool!("ruff", "python", "pip", "pip install ruff"),
tool!("pylint", "python", "pip", "pip install pylint"),
tool!("mypy", "python", "pip", "pip install mypy"),
tool!("pyrefly", "python", "pip", "pip install pyrefly"),
tool!("yamllint", "python", "pip", "pip install yamllint"),
tool!("sphinx-build", "python", "pip", "pip install sphinx"),
tool!("pip", "python", "system", "python3 -m ensurepip"),
tool!("jsonlint", "python", "pip", "pip install jsonlint"),
tool!("cpplint", "python", "pip", "pip install cpplint"),
tool!("a2x", "python", "apt", "apt install asciidoc"),
tool!("python3", "python", "apt", "apt install python3"),
tool!("marp", "node", "npm", "npm install -g @marp-team/marp-cli"),
tool!("mmdc", "node", "npm", "npm install -g @mermaid-js/mermaid-cli"),
tool!("node_modules/.bin/markdownlint", "node", "npm", "npm install markdownlint-cli"),
tool!("markdownlint", "node", "npm", "npm install -g markdownlint-cli"),
tool!("eslint", "node", "npm", "npm install -g eslint"),
tool!("htmlhint", "node", "npm", "npm install -g htmlhint"),
tool!("jshint", "node", "npm", "npm install -g jshint"),
tool!("npm", "node", "apt", "apt install npm"),
tool!("node", "node", "apt", "apt install nodejs"),
tool!("gems/bin/mdl", "ruby", "gem", "gem install mdl"),
tool!("mdl", "ruby", "gem", "gem install mdl"),
tool!("bundle", "ruby", "gem", "gem install bundler"),
tool!("ruby", "ruby", "apt", "apt install ruby"),
tool!("mdbook", "rust", "cargo", "cargo install mdbook"),
tool!("rumdl", "rust", "cargo", "cargo install rumdl"),
tool!("taplo", "rust", "cargo", "cargo install taplo-cli"),
tool!("cargo", "rust", "binary", "curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh"),
tool!("rustc", "rust", "binary", "curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh"),
tool!("perl", "perl", "apt", "apt install perl"),
tool!("markdown", "perl", "apt", "apt install markdown"),
tool!("checkpatch.pl", "perl", "manual", "install from Linux kernel source: scripts/checkpatch.pl"),
tool!("shellcheck", "system", "apt", "apt install shellcheck"),
tool!("luacheck", "system", "apt", "apt install lua-check"),
tool!("cppcheck", "system", "apt", "apt install cppcheck"),
tool!("clang-tidy", "system", "apt", "apt install clang-tidy"),
tool!("gcc", "system", "apt", "apt install gcc"),
tool!("g++", "system", "apt", "apt install g++"),
tool!("clang", "system", "apt", "apt install clang"),
tool!("clang++", "system", "apt", "apt install clang"),
tool!("ar", "system", "apt", "apt install binutils"),
tool!("make", "system", "apt", "apt install make"),
tool!("jq", "system", "apt", "apt install jq"),
tool!("aspell", "system", "apt", "apt install aspell"),
tool!("pandoc", "system", "apt", "apt install pandoc"),
tool!("pdflatex", "system", "apt", "apt install texlive-latex-base"),
tool!("qpdf", "system", "apt", "apt install qpdf"),
tool!("dot", "system", "apt", "apt install graphviz"),
tool!("drawio", "system", "snap", "snap install drawio"),
tool!("libreoffice", "system", "apt", "apt install libreoffice"),
tool!("flock", "system", "apt", "apt install util-linux"),
tool!("pdfunite", "system", "apt", "apt install poppler-utils"),
tool!("google-chrome", "system", "apt", "apt install google-chrome-stable"),
tool!("objdump", "system", "apt", "apt install binutils"),
tool!("tidy", "system", "apt", "apt install tidy"),
tool!("xmllint", "system", "apt", "apt install libxml2-utils"),
tool!("cmake", "system", "apt", "apt install cmake"),
tool!("hadolint", "system", "apt", "apt install hadolint"),
tool!("php", "system", "apt", "apt install php-cli"),
tool!("checkstyle", "system", "apt", "apt install checkstyle"),
tool_multi!("yq", "system",
("pip", "pip install yq"),
("snap", "snap install yq"),
("apt", "apt install yq"),
),
tool!("stylelint", "node", "npm", "npm install -g stylelint"),
tool!("jslint", "node", "npm", "npm install -g jslint"),
tool!("standard", "node", "npm", "npm install -g standard"),
tool!("htmllint", "node", "npm", "npm install -g htmllint-cli"),
tool!("slidev", "node", "npm", "npm install -g @slidev/cli"),
tool!("perlcritic", "perl", "apt", "apt install libperl-critic-perl"),
tool!("jekyll", "ruby", "gem", "gem install jekyll"),
tool!("true", "system", "system", "coreutils"),
];
pub fn tool_info(tool: &str) -> Option<&'static ToolInfo> {
TOOLS.iter().find(|t| t.name == tool)
}
pub fn tool_install_command(tool: &str) -> Option<&'static str> {
tool_info(tool).and_then(|t| t.install_methods.first().map(|m| m.command))
}
pub fn tool_runtime(tool: &str) -> Option<&'static str> {
tool_info(tool).map(|t| t.runtime)
}
#[allow(dead_code)]
pub fn tool_install_methods(tool: &str) -> Option<&'static [InstallMethod]> {
tool_info(tool).map(|t| t.install_methods)
}
#[derive(Debug, Clone, PartialEq)]
pub struct ProductTiming {
pub display: String,
pub processor: String,
pub duration: Duration,
pub start_offset: Option<Duration>,
}
#[derive(Debug, Default, PartialEq)]
pub struct ProcessStats {
pub processed: usize,
pub failed: usize,
pub flaky: usize,
pub skipped: usize,
pub restored: usize,
pub files_created: usize,
pub files_restored: usize,
pub duration: Duration,
pub product_timings: Vec<ProductTiming>,
}
impl ProcessStats {
pub fn total(&self) -> usize {
self.processed + self.failed + self.skipped + self.restored
}
}
#[derive(Default)]
pub struct BuildStats {
pub categories: Vec<ProcessStats>,
pub total_duration: Duration,
pub failed_count: usize,
pub failed_messages: Vec<String>,
pub phase_timings: Vec<(String, Duration)>,
}
impl BuildStats {
pub fn add(&mut self, stats: ProcessStats) {
if stats.total() > 0 {
self.categories.push(stats);
}
}
pub fn total_processed(&self) -> usize {
self.categories.iter().map(|s| s.processed).sum()
}
pub fn total_skipped(&self) -> usize {
self.categories.iter().map(|s| s.skipped).sum()
}
pub fn total_restored(&self) -> usize {
self.categories.iter().map(|s| s.restored).sum()
}
pub fn total_files_created(&self) -> usize {
self.categories.iter().map(|s| s.files_created).sum()
}
pub fn total_files_restored(&self) -> usize {
self.categories.iter().map(|s| s.files_restored).sum()
}
pub fn total_flaky(&self) -> usize {
self.categories.iter().map(|s| s.flaky).sum()
}
pub fn print_summary(&self, summary: bool, timings: bool) {
if crate::json_output::is_json_mode() || crate::runtime_flags::quiet() {
return;
}
if !summary && !timings {
return;
}
if self.categories.is_empty() && self.failed_count == 0 {
if summary {
println!("{}", color::dim("Nothing to build."));
}
return;
}
if summary {
let total_processed = self.total_processed();
let total_restored = self.total_restored();
let total_failed = self.failed_count;
let total_skipped = self.total_skipped();
let total_files_created = self.total_files_created();
let total_files_restored = self.total_files_restored();
let mut parts = Vec::new();
if total_processed > 0 {
if total_files_created > 0 {
parts.push(format!("{} processed ({} files created)", total_processed, total_files_created));
} else {
parts.push(format!("{} processed", total_processed));
}
}
if total_restored > 0 {
if total_files_restored > 0 {
parts.push(format!("{} restored ({} files)", total_restored, total_files_restored));
} else {
parts.push(format!("{} restored", total_restored));
}
}
let total_flaky = self.total_flaky();
if total_flaky > 0 {
parts.push(format!("{} flaky", total_flaky));
}
if total_failed > 0 {
parts.push(format!("{} failed", total_failed));
}
if total_skipped > 0 {
parts.push(format!("{} unchanged", total_skipped));
}
if parts.is_empty() {
println!("{}", color::dim("Nothing to build."));
} else {
let line = format!("Build summary: {}", parts.join(", "));
if total_failed > 0 {
println!("{}", color::red(&line));
} else {
println!("{}", color::green(&line));
}
}
}
if self.failed_count > 0 {
println!("{}", color::red(&format!("Build finished with {} error(s):", self.failed_count)));
for msg in &self.failed_messages {
println!("{} {}", color::red("*"), msg);
}
}
if timings {
println!();
println!("{}", color::bold("Timing:"));
if !self.phase_timings.is_empty() {
let max_name_len = self.phase_timings.iter().map(|(n, _)| n.len()).max().unwrap_or(0);
for (name, dur) in &self.phase_timings {
println!(" {:width$} {:.3}s", name, dur.as_secs_f64(), width = max_name_len);
}
}
for cat in &self.categories {
for pt in &cat.product_timings {
println!("[{}] {} {}", pt.processor, pt.display,
color::dim(&format!("({:.3}s)", pt.duration.as_secs_f64())));
}
}
let total: f64 = self.phase_timings.iter().map(|(_, d)| d.as_secs_f64()).sum();
println!("{}", color::bold(&format!("Total: {:.3}s", total)));
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::config::ProcessorConfig;
use crate::builder::create_builtin_processors;
#[test]
fn all_required_tools_have_registry_entries() {
let mut cfg = ProcessorConfig::default();
cfg.resolve_scan_defaults();
let processors = create_builtin_processors(&cfg);
for (proc_name, proc) in &processors {
for tool in proc.required_tools() {
if tool.is_empty() {
continue;
}
assert!(
tool_install_command(&tool).is_some(),
"Processor '{}' requires tool '{}' which has no install command in TOOLS",
proc_name, tool
);
assert!(
tool_runtime(&tool).is_some(),
"Processor '{}' requires tool '{}' which has no runtime category in TOOLS",
proc_name, tool
);
}
}
}
}