codegen/app/

output_tree.rs

use std::{collections::BTreeSet, process::ExitCode};

use anyhow::{Context, bail};
use wowlab_common::output;
use wowlab_fs::{
    artifact::{GeneratedTextFile, Status},
    directory::{self, EntryKind},
    path::{Path, PathBuf},
};

use super::ownership::{
    OWNERSHIP_MANIFEST, adopt_legacy_generated_tree, ownership_manifest_source,
    prune_empty_owned_parents, read_ownership_manifest, reject_unowned_files,
    validate_owned_file_kinds, validate_owned_path, write_ownership_manifest,
};

pub(super) fn write_generated_files(
    files: &[(String, String)],
    output_dir: &Path,
    quiet: bool,
) -> anyhow::Result<()> {
    let expected_paths = expected_path_set(files)?;
    let actual_paths = actual_file_set(output_dir)?;

    let previous_paths = match read_ownership_manifest(output_dir)? {
        Some(paths) => {
            reject_unowned_files(&actual_paths, &paths)?;
            validate_owned_file_kinds(output_dir, &paths)?;

            paths
        }
        None => adopt_legacy_generated_tree(output_dir, &actual_paths)?,
    };

    // Cover both old and new artifacts before any output-tree mutation.
    let transitional_paths = previous_paths
        .union(&expected_paths)
        .cloned()
        .collect::<BTreeSet<_>>();

    write_ownership_manifest(output_dir, &transitional_paths)?;

    for obsolete in previous_paths.difference(&expected_paths) {
        let path = output_dir.join(obsolete);

        if !directory::remove_file_if_exists(&path)
            .with_context(|| format!("failed to remove obsolete output {}", path.display()))?
        {
            continue;
        }

        if !quiet {
            output::detail(&format!("removed obsolete {}", path.display()));
        }

        if let Some(parent) = path.parent() {
            prune_empty_owned_parents(output_dir, parent)?;
        }
    }

    for (filename, code) in files {
        let output_file = output_dir.join(filename);

        GeneratedTextFile::new(&output_file, code).persist()?;

        if !quiet {
            output::detail(&format!("wrote {}", output_file.display()));
        }
    }

    write_ownership_manifest(output_dir, &expected_paths)?;

    Ok(())
}

pub(super) fn check_freshness(
    files: &[(String, String)],
    output_dir: &Path,
) -> anyhow::Result<ExitCode> {
    let expected_paths = expected_path_set(files)?;
    let actual_paths = actual_file_set(output_dir)?;
    let mut stale = BTreeSet::new();
    let ownership = read_ownership_manifest(output_dir)?;

    if let Some(owned_paths) = &ownership {
        reject_unowned_files(&actual_paths, owned_paths)?;
        validate_owned_file_kinds(output_dir, owned_paths)?;
    } else {
        let _legacy_paths = adopt_legacy_generated_tree(output_dir, &actual_paths)?;

        stale.insert(PathBuf::from(OWNERSHIP_MANIFEST));
    }

    for (filename, expected) in files {
        let path = output_dir.join(filename);

        if GeneratedTextFile::new(&path, expected).status()? != Status::Current {
            stale.insert(PathBuf::from(filename.as_str()));
        }
    }

    stale.extend(actual_paths.difference(&expected_paths).cloned());

    let ownership_path = output_dir.join(OWNERSHIP_MANIFEST);

    if ownership.is_some()
        && GeneratedTextFile::new(
            &ownership_path,
            &ownership_manifest_source(&expected_paths)?,
        )
        .status()?
            != Status::Current
    {
        stale.insert(PathBuf::from(OWNERSHIP_MANIFEST));
    }

    if stale.is_empty() {
        output::success("generated code is up-to-date");

        Ok(ExitCode::SUCCESS)
    } else {
        output::error(&format!(
            "{} file(s) are stale, run `cargo codegen` to regenerate:",
            stale.len()
        ));

        for file in &stale {
            output::detail(&format!("  {}", file.display()));
        }

        Ok(ExitCode::FAILURE)
    }
}

pub(super) fn expected_path_set(files: &[(String, String)]) -> anyhow::Result<BTreeSet<PathBuf>> {
    let mut paths = BTreeSet::new();

    for (filename, _) in files {
        let path = PathBuf::from(filename.as_str());

        validate_owned_path(&path)?;

        if !paths.insert(path) {
            bail!("generator produced duplicate output path {filename}");
        }
    }

    Ok(paths)
}

pub(super) fn actual_file_set(output_dir: &Path) -> anyhow::Result<BTreeSet<PathBuf>> {
    let mut paths = BTreeSet::new();

    match directory::inspect_link(output_dir)? {
        Some(entry) if entry.kind() == EntryKind::Symlink => {
            bail!(
                "generated output root must not be a symlink: {}",
                output_dir.display()
            );
        }
        Some(entry) if entry.kind() != EntryKind::Directory => {
            bail!(
                "generated output root is not a directory: {}",
                output_dir.display()
            );
        }
        Some(_) => {}
        None => return Ok(paths),
    }

    collect_actual_files(output_dir, output_dir, &mut paths)?;

    Ok(paths)
}

fn collect_actual_files(
    root: &Path,
    current_directory: &Path,
    paths: &mut BTreeSet<PathBuf>,
) -> anyhow::Result<()> {
    for entry in directory::entries(current_directory).with_context(|| {
        format!(
            "failed to read output directory {}",
            current_directory.display()
        )
    })? {
        if entry.kind() == EntryKind::Symlink {
            bail!(
                "generated output tree contains a symlink: {}",
                entry.path().display()
            );
        } else if entry.kind() == EntryKind::Directory {
            collect_actual_files(root, entry.path(), paths)?;
        } else if entry.kind() == EntryKind::File {
            let relative = entry.path().strip_prefix(root).with_context(|| {
                format!(
                    "generated output {} is outside {}",
                    entry.path().display(),
                    root.display()
                )
            })?;

            if relative != Path::new(OWNERSHIP_MANIFEST) {
                paths.insert(relative.to_path_buf());
            }
        } else {
            bail!(
                "generated output tree contains a non-regular entry: {}",
                entry.path().display()
            );
        }
    }

    Ok(())
}