mod checkers;
mod generators;
mod mass_generators;
pub mod lua_processor;
pub(crate) mod word_manager;
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::{output_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(output_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(output_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, ZspellProcessor,
StandardProcessor, StylelintProcessor,
TaploProcessor, TermsProcessor, 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(crate) use checkers::terms;
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 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
}
}
pub struct InstallMethod {
pub method: &'static str,
pub package: &'static str,
}
impl InstallMethod {
pub fn command(&self) -> String {
match self.method {
"apt" => format!("sudo apt install -y {}", self.package),
"snap" => format!("sudo snap install {}", self.package),
"pip" => format!("pip install {}", self.package),
"npm" => format!("npm install -g {}", self.package),
"cargo" => format!("cargo install {}", self.package),
"gem" => format!("gem install {}", self.package),
_ => self.package.to_string(),
}
}
pub fn batch_command(method: &str, packages: &[&str]) -> String {
match method {
"apt" => format!("sudo apt install -y {}", packages.join(" ")),
"snap" => format!("sudo snap install {}", packages.join(" ")),
"pip" => format!("pip install {}", packages.join(" ")),
"npm" => format!("npm install -g {}", packages.join(" ")),
"cargo" => format!("cargo install {}", packages.join(" ")),
"gem" => format!("gem install {}", packages.join(" ")),
_ => packages.iter().map(|p| p.to_string()).collect::<Vec<_>>().join("; "),
}
}
}
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, $package:expr) => {
ToolInfo {
name: $name,
runtime: $runtime,
install_methods: &[InstallMethod { method: $method, package: $package }],
}
};
($name:expr, $runtime:expr, $method:expr) => {
ToolInfo {
name: $name,
runtime: $runtime,
install_methods: &[InstallMethod { method: $method, package: $name }],
}
};
}
macro_rules! tool_multi {
($name:expr, $runtime:expr, $( ($method:expr, $package:expr) ),+ $(,)?) => {
ToolInfo {
name: $name,
runtime: $runtime,
install_methods: &[ $( InstallMethod { method: $method, package: $package } ),+ ],
}
};
}
pub static TOOLS: &[ToolInfo] = &[
tool!("ruff", "python", "pip"),
tool!("pylint", "python", "pip"),
tool!("mypy", "python", "pip"),
tool!("pyrefly", "python", "pip"),
tool!("yamllint", "python", "pip"),
tool!("sphinx-build", "python", "pip", "sphinx"),
tool!("pip", "python", "system", "python3 -m ensurepip"),
tool!("jsonlint", "python", "pip"),
tool!("cpplint", "python", "pip"),
tool!("a2x", "python", "apt", "asciidoc"),
tool!("python3", "python", "apt"),
tool!("marp", "node", "npm", "@marp-team/marp-cli"),
tool!("mmdc", "node", "npm", "@mermaid-js/mermaid-cli"),
tool!("node_modules/.bin/markdownlint", "node", "npm", "markdownlint-cli"),
tool!("markdownlint", "node", "npm", "markdownlint-cli"),
tool!("eslint", "node", "npm"),
tool!("htmlhint", "node", "npm"),
tool!("jshint", "node", "npm"),
tool!("npm", "node", "apt"),
tool!("node", "node", "apt", "nodejs"),
tool!("gems/bin/mdl", "ruby", "gem", "mdl"),
tool!("mdl", "ruby", "gem"),
tool!("bundle", "ruby", "gem", "bundler"),
tool!("ruby", "ruby", "apt"),
tool!("mdbook", "rust", "cargo"),
tool!("rumdl", "rust", "cargo"),
tool!("taplo", "rust", "cargo", "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"),
tool!("markdown", "perl", "apt"),
tool!("checkpatch.pl", "perl", "manual", "install from Linux kernel source: scripts/checkpatch.pl"),
tool!("shellcheck", "system", "apt"),
tool!("luacheck", "system", "apt", "lua-check"),
tool!("cppcheck", "system", "apt"),
tool!("clang-tidy", "system", "apt"),
tool!("gcc", "system", "apt"),
tool!("g++", "system", "apt"),
tool!("clang", "system", "apt"),
tool!("clang++", "system", "apt", "clang"),
tool!("ar", "system", "apt", "binutils"),
tool!("make", "system", "apt"),
tool!("jq", "system", "apt"),
tool!("aspell", "system", "apt"),
tool!("pandoc", "system", "apt"),
tool!("pdflatex", "system", "apt", "texlive-latex-base"),
tool!("qpdf", "system", "apt"),
tool!("dot", "system", "apt", "graphviz"),
tool!("drawio", "system", "snap"),
tool!("libreoffice", "system", "apt"),
tool!("flock", "system", "apt", "util-linux"),
tool!("pdfunite", "system", "apt", "poppler-utils"),
tool!("google-chrome", "system", "apt", "google-chrome-stable"),
tool!("objdump", "system", "apt", "binutils"),
tool!("tidy", "system", "apt"),
tool!("xmllint", "system", "apt", "libxml2-utils"),
tool!("cmake", "system", "apt"),
tool_multi!("hadolint", "system",
("binary", "wget -O ~/.local/bin/hadolint https://github.com/hadolint/hadolint/releases/latest/download/hadolint-Linux-x86_64 && chmod +x ~/.local/bin/hadolint"),
("brew", "hadolint"),
("nix", "hadolint"),
("apt", "hadolint"),
),
tool!("php", "system", "apt", "php-cli"),
tool!("checkstyle", "system", "apt"),
tool_multi!("yq", "system",
("pip", "yq"),
("snap", "yq"),
("apt", "yq"),
),
tool!("stylelint", "node", "npm"),
tool!("jslint", "node", "npm"),
tool!("standard", "node", "npm"),
tool!("htmllint", "node", "npm", "htmllint-cli"),
tool!("slidev", "node", "npm", "@slidev/cli"),
tool!("perlcritic", "perl", "apt", "libperl-critic-perl"),
tool!("jekyll", "ruby", "gem"),
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<String> {
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)
}
#[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(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct FailedProduct {
pub file: String,
pub processor: String,
pub error: String,
}
#[derive(Default)]
pub struct BuildStats {
pub categories: Vec<ProcessStats>,
pub total_duration: Duration,
pub failed_count: usize,
pub failed_messages: Vec<String>,
pub failed_details: Vec<FailedProduct>,
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::builder::create_all_default_processors;
#[test]
fn all_required_tools_have_registry_entries() {
let processors = create_all_default_processors();
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
);
}
}
}
}