use std::{
path::{Path, PathBuf},
process::ExitCode,
};
use clap::{Parser, Subcommand};
use rayon::prelude::*;
use crate::{
RenderCtx, WorkspaceIndex, domain,
fs::artifact::{GeneratedTextFile, Status},
output,
render::template,
};
#[derive(Debug, Parser)]
#[command(
name = "markupwright",
version,
about = "Generate Markdown docs from configured templates"
)]
struct Args {
#[arg(long, value_name = "PATH", global = true)]
root: Option<PathBuf>,
#[command(subcommand)]
command: Option<Command>,
#[arg(long, short = 'F')]
filter: Vec<Box<str>>,
#[arg(long)]
dry_run: bool,
#[arg(long)]
check: bool,
#[arg(long, short, global = true)]
quiet: bool,
}
#[derive(Debug, Subcommand)]
enum Command {
Init,
}
#[derive(Debug, thiserror::Error)]
enum ProcessError {
#[error("{}: template path has no parent", path.display())]
MissingParent { path: PathBuf },
#[error("{}: {source}", path.display())]
Template {
path: PathBuf,
#[source]
source: template::TemplateError,
},
#[error(transparent)]
Artifact(#[from] crate::fs::artifact::Error),
}
#[derive(Debug)]
struct ProcessedTemplate<'a> {
path: &'a Path,
result: Result<ProcessedOutput, ProcessError>,
}
#[derive(Debug)]
struct ProcessedOutput {
path: PathBuf,
checksum: crate::fs::checksum::FileChecksum,
changed: bool,
}
#[must_use]
pub fn run() -> ExitCode {
let mut args = Args::parse();
if args.check {
args.dry_run = true;
args.quiet = true;
}
let root = match resolve_root(args.root.take()) {
Ok(root) => root,
Err(error) => {
output::error(&error.to_string());
return ExitCode::FAILURE;
}
};
if let Err(error) = crate::fs::tool_layout::ensure_safe(&root) {
output::error(&error.to_string());
return ExitCode::FAILURE;
}
if matches!(args.command, Some(Command::Init)) {
if args.dry_run || args.check || !args.filter.is_empty() {
output::error("init cannot be combined with generation options");
return ExitCode::FAILURE;
}
return initialize(&root, args.quiet);
}
let paths = match crate::workspace::load::discover(&root) {
Ok(paths) => paths,
Err(error) => {
output::error(&error.to_string());
return ExitCode::FAILURE;
}
};
let files = match crate::workspace::load::read_paths(&root, &paths) {
Ok(files) => files,
Err(error) => {
output::error(&error.to_string());
return ExitCode::FAILURE;
}
};
let mut cache = crate::cache::Cache::load(&root);
if cache.is_current(Some(files.checksum()), &args.filter) {
return ExitCode::SUCCESS;
}
let loaded = match files.into_workspace() {
Ok(loaded) => loaded,
Err(error) => {
output::error(&error.to_string());
return ExitCode::FAILURE;
}
};
let workspace = &loaded.workspace;
let templates = template_paths(workspace, &paths, &args.filter);
if templates.is_empty() {
if !args.quiet {
output::warning("no configured document inputs found");
}
return ExitCode::SUCCESS;
}
if let Err(error) = template::validate_outputs(workspace, &templates) {
output::error(&error.to_string());
return ExitCode::FAILURE;
}
if !args.quiet {
output::detail(&format!("found {} template(s)", templates.len()));
output::blank();
}
let formatter = crate::markdown::Formatter::new();
let results = templates
.par_iter()
.map(|template_path| {
let result = process_one(template_path, workspace, &formatter, &args);
ProcessedTemplate {
path: template_path,
result,
}
})
.collect();
finish_run(&loaded, &args, &mut cache, &templates, results)
}
fn initialize(root: &Path, quiet: bool) -> ExitCode {
match crate::init::initialize(root) {
Ok(()) => {
if !quiet {
output::success("created .markupwright/config.toml");
output::success("created .markupwright/templates/");
output::success("created .markupwright/.gitignore");
}
ExitCode::SUCCESS
}
Err(error) => {
output::error(&error.to_string());
ExitCode::FAILURE
}
}
}
fn finish_run(
loaded: &crate::workspace::load::Loaded,
args: &Args,
cache: &mut crate::cache::Cache,
templates: &[PathBuf],
results: Vec<ProcessedTemplate<'_>>,
) -> ExitCode {
let workspace = &loaded.workspace;
let root = workspace.root();
let mut changed = 0;
let mut errors = 0;
let mut changed_files = Vec::new();
let mut outputs = Vec::new();
for processed in results {
match processed.result {
Ok(output) => {
changed += usize::from(output.changed);
if output.changed && args.check {
changed_files.push(relative_path(&output.path, root));
}
report_processed(processed.path, workspace, args, output.changed);
outputs.push((output.path, output.checksum));
}
Err(error) => {
errors += 1;
output::error(&error.to_string());
}
}
}
if !args.quiet {
output::blank();
let verb = if args.dry_run {
"would update"
} else {
"updated"
};
let unchanged = templates.len() - changed - errors;
output::detail(&format!(
"{changed} {verb}, {unchanged} unchanged, {errors} error(s)"
));
}
let status = run_status(args, errors, &mut changed_files);
if status == ExitCode::SUCCESS
&& (!args.dry_run || changed == 0)
&& let Ok(workspace_checksum) = loaded.checksum_with(&outputs)
{
cache.record(workspace_checksum, &args.filter, &outputs);
}
if !args.dry_run {
cache.persist();
}
status
}
fn run_status(args: &Args, errors: usize, changed_files: &mut [String]) -> ExitCode {
if errors > 0 {
return ExitCode::FAILURE;
}
if args.check && !changed_files.is_empty() {
changed_files.sort();
for file in changed_files.iter() {
output::warning(&format!("out of date: {file}"));
}
output::error(&format!(
"{} file(s) out of date - run `markupwright` to fix",
changed_files.len()
));
return ExitCode::FAILURE;
}
ExitCode::SUCCESS
}
fn process_one(
template_path: &Path,
workspace: &WorkspaceIndex,
formatter: &crate::markdown::Formatter,
args: &Args,
) -> Result<ProcessedOutput, ProcessError> {
let root = workspace.root();
let Some(directory) = template_path.parent() else {
return Err(ProcessError::MissingParent {
path: template_path.to_path_buf(),
});
};
let relative = directory
.strip_prefix(root)
.map(|path| path.to_string_lossy().replace('\\', "/"))
.unwrap_or_default();
let context = RenderCtx {
workspace: workspace.clone(),
root,
dir: directory,
rel_dir: &relative,
metadata: domain::load(workspace, directory),
};
let document = template::prepare(template_path, &context, formatter).map_err(|source| {
ProcessError::Template {
path: PathBuf::from(relative_path(template_path, root)),
source,
}
})?;
let artifact = GeneratedTextFile::new(&document.output_path, &document.contents);
let changed = artifact.status()? != Status::Current;
let checksum = crate::fs::checksum::contents(&document.contents);
if changed && !args.dry_run {
artifact.persist()?;
}
Ok(ProcessedOutput {
path: document.output_path,
checksum,
changed,
})
}
fn report_processed(template_path: &Path, workspace: &WorkspaceIndex, args: &Args, updated: bool) {
if args.quiet {
return;
}
let output = relative_path(
&workspace.config().output_path(template_path),
workspace.root(),
);
if updated && args.dry_run {
output::warning(&format!("would update {output}"));
} else if updated {
output::success(&format!("updated {output}"));
} else {
output::detail(&format!("unchanged {output}"));
}
}
fn template_paths(
workspace: &WorkspaceIndex,
paths: &[PathBuf],
filters: &[Box<str>],
) -> Vec<PathBuf> {
let root = workspace.root();
paths
.iter()
.filter(|path| {
let Some(directory) = path.parent() else {
return false;
};
let Some(metadata) = workspace.metadata(directory) else {
return false;
};
path.strip_prefix(root).is_ok_and(|relative| {
workspace
.config()
.document_template(relative, metadata.domain)
.is_some()
})
})
.filter(|path| {
filters.is_empty()
|| path.strip_prefix(root).is_ok_and(|relative| {
let relative = relative.to_string_lossy().replace('\\', "/");
filters
.iter()
.any(|filter| relative.contains(filter.as_ref()))
})
})
.cloned()
.collect()
}
fn relative_path(path: &Path, root: &Path) -> String {
path.strip_prefix(root)
.unwrap_or(path)
.to_string_lossy()
.replace('\\', "/")
}
#[derive(Debug, thiserror::Error)]
#[error("failed to resolve repository root {}: {source}", path.display())]
struct RootError {
path: PathBuf,
#[source]
source: std::io::Error,
}
fn resolve_root(argument: Option<PathBuf>) -> Result<PathBuf, RootError> {
let requested = argument
.or_else(|| std::env::var_os("MARKUPWRIGHT_ROOT").map(PathBuf::from))
.unwrap_or_else(|| PathBuf::from("."));
std::fs::canonicalize(&requested).map_err(|source| RootError {
path: requested,
source,
})
}