codegen/app/

generation.rs

use std::collections::BTreeMap;

use anyhow::{Context, bail};
use wowlab_fs::{
    checksum::Checksum,
    path::{Component, Path, PathBuf},
};
use wowlab_manifest_schema::{CURRENT_SCHEMA_VERSION, Manifest, ManifestRepository};

use super::{
    cache::{CodegenCache, ManifestInputs, constant_output},
    identifiers::{
        validate_item_identifiers, validate_module_component, validate_named_identifiers,
        validate_rust_identifier, validate_spec_identifiers,
    },
    spec_file::{generate_shared_file, generate_spec_file},
};
use crate::{
    gen_barrel::{
        generate_identity_catalog, generate_shared_mod, generate_specs_mod, generate_top_mod,
    },
    gen_item_registry::generate_items_mod_file,
    gen_items::generate_item_file,
    helpers::{display_name_from_filename, module_name_from_filename, to_snake},
};

pub(super) struct LoadedSpec {
    pub(super) path: PathBuf,
    pub(super) manifest: Manifest,
    pub(super) mod_name: String,
    pub(super) display_name: String,
    pub(super) source_path: String,
}

pub(super) struct GenerationResult {
    pub(super) files: Vec<(String, String)>,
    pub(super) dependencies: BTreeMap<String, Checksum>,
}

struct PreparedSpec {
    mod_name: String,
    output_path: String,
    dependency: Checksum,
    source: PreparedSpecSource,
}

enum PreparedSpecSource {
    Loaded(Box<LoadedSpec>),
    Reused(String),
}

fn prepare_specs_for_generation(
    repository: &ManifestRepository,
    manifests_dir: &Path,
    inputs: &ManifestInputs,
    cache: Option<&CodegenCache>,
) -> anyhow::Result<Vec<PreparedSpec>> {
    let specs_root = manifests_dir.join("specs");
    let mut specs = Vec::new();
    let mut diagnostics = Vec::new();

    for path in repository.spec_paths()? {
        let mod_name = repository.spec_slug(&path)?;
        let display_name = display_name_from_filename(Path::new(&mod_name))?;
        let source_path = path
            .strip_prefix(&specs_root)
            .with_context(|| {
                format!(
                    "spec manifest is outside {}: {}",
                    specs_root.display(),
                    path.display()
                )
            })?
            .to_str()
            .with_context(|| format!("spec manifest path is not UTF-8: {}", path.display()))?
            .to_owned();
        let output_path = format!("specs/{mod_name}.rs");
        let dependency = inputs.spec(&path)?;

        if let Some(contents) = cache
            .map(|cache| cache.reuse(&output_path, dependency))
            .transpose()?
            .flatten()
        {
            specs.push(PreparedSpec {
                mod_name,
                output_path,
                dependency,
                source: PreparedSpecSource::Reused(contents),
            });

            continue;
        }

        let manifest = repository
            .load_spec(&path)
            .with_context(|| format!("failed to load {}", path.display()))?;

        if manifest.schema_version != CURRENT_SCHEMA_VERSION {
            bail!(
                "{}: unknown schema_version {} (expected {})",
                path.display(),
                manifest.schema_version,
                CURRENT_SCHEMA_VERSION
            );
        }

        diagnostics.extend(
            manifest
                .diagnostics()
                .into_iter()
                .map(|diagnostic| format!("{}: {diagnostic}", path.display())),
        );

        specs.push(PreparedSpec {
            mod_name: mod_name.clone(),
            output_path,
            dependency,
            source: PreparedSpecSource::Loaded(Box::new(LoadedSpec {
                path,
                manifest,
                mod_name,
                display_name,
                source_path,
            })),
        });
    }

    if !diagnostics.is_empty() {
        diagnostics.sort_unstable();

        bail!(
            "composed manifest diagnostics failed:\n{}",
            diagnostics.join("\n")
        );
    }

    for spec in &specs {
        if let PreparedSpecSource::Loaded(loaded) = &spec.source {
            validate_spec_identifiers(loaded)?;
        }
    }

    Ok(specs)
}

#[cfg(test)]
pub(super) fn generate_all(manifests_dir: &Path) -> anyhow::Result<Vec<(String, String)>> {
    let repository = ManifestRepository::new(manifests_dir);
    let paths = repository.toml_paths()?;
    let inputs = ManifestInputs::capture(manifests_dir, &paths)?;

    generate_all_incremental(manifests_dir, &inputs, None).map(|generation| generation.files)
}

pub(super) fn generate_all_incremental(
    manifests_dir: &Path,
    inputs: &ManifestInputs,
    cache: Option<&CodegenCache>,
) -> anyhow::Result<GenerationResult> {
    let repository = ManifestRepository::new(manifests_dir);
    // Previously successful, byte-identical specs reuse their verified artifacts. Every cache
    // miss is composed and validated before any new Rust is emitted.
    let specs = prepare_specs_for_generation(&repository, manifests_dir, inputs, cache)?;
    let mut files: Vec<(String, String)> = Vec::new();
    let mut dependencies = BTreeMap::new();
    let mut identity_specs = Vec::new();
    let mut identity_shared = Vec::new();

    for path in repository.spec_paths()? {
        let manifest = repository.load_spec(&path)?;
        let module_name = repository.spec_slug(&path)?;

        identity_specs.push((module_name, manifest));
    }

    let items = repository.load_items()?;

    for shared_path in repository.shared_paths()? {
        let bindings = repository.load_shared_bindings(&shared_path)?;
        let relative = shared_path.relative_path();
        let group = relative
            .components()
            .next()
            .and_then(|component| match component {
                Component::Normal(value) => value.to_str(),
                _ => None,
            })
            .context("shared manifest must have a group")?;
        let name = module_name_from_filename(relative)?;
        let module_name = format!("{group}_{name}");

        identity_shared.push((module_name, bindings));
    }

    push_generated(
        &mut files,
        &mut dependencies,
        cache,
        "identity_values.rs".into(),
        inputs.all_manifests()?,
        || generate_identity_catalog(&identity_specs, &items, &identity_shared),
    )?;

    generate_shared_outputs(&repository, inputs, &mut files, &mut dependencies, cache)?;
    let spec_names = generate_spec_outputs(specs, &mut files, &mut dependencies)?;

    push_generated(
        &mut files,
        &mut dependencies,
        cache,
        "mod.rs".into(),
        constant_output("top-level module barrel"),
        || generate_top_mod().context("generating top-level module barrel"),
    )?;
    push_generated(
        &mut files,
        &mut dependencies,
        cache,
        "specs/mod.rs".into(),
        inputs.all_specs()?,
        || generate_specs_mod(&spec_names).context("generating spec module barrel"),
    )?;

    generate_item_outputs(
        &repository,
        manifests_dir,
        inputs,
        &mut files,
        &mut dependencies,
        cache,
    )?;

    Ok(GenerationResult {
        files,
        dependencies,
    })
}

fn generate_shared_outputs(
    repository: &ManifestRepository,
    inputs: &ManifestInputs,
    files: &mut Vec<(String, String)>,
    dependencies: &mut BTreeMap<String, Checksum>,
    cache: Option<&CodegenCache>,
) -> anyhow::Result<()> {
    let mut shared_modules: BTreeMap<String, Vec<String>> = BTreeMap::new();

    for shared_path in repository.shared_paths()? {
        let bindings = repository.load_shared_bindings(&shared_path)?;

        if bindings.effects.is_empty() && bindings.reported_spells.is_empty() {
            continue;
        }

        let relative = shared_path.relative_path();
        let group = relative
            .components()
            .next()
            .and_then(|component| match component {
                Component::Normal(value) => value.to_str(),
                _ => None,
            })
            .map(str::to_owned)
            .with_context(|| {
                format!(
                    "shared manifest must be nested by group: {}",
                    relative.display()
                )
            })?;
        let name = module_name_from_filename(relative)?;
        let source_path = relative.to_str().with_context(|| {
            format!("shared manifest path is not UTF-8: {}", relative.display())
        })?;

        validate_module_component(
            &group,
            &format!("shared manifest group in {}", relative.display()),
        )?;
        validate_module_component(
            &name,
            &format!("shared manifest module in {}", relative.display()),
        )?;
        validate_named_identifiers(bindings.effects.keys(), "effects", shared_path.path())?;

        for reported in bindings.reported_spells.keys() {
            validate_rust_identifier(
                &reported.to_uppercase(),
                &format!(
                    "{} [reported_spells.{reported}]",
                    shared_path.path().display()
                ),
            )?;
        }

        let output_path = format!("shared/{group}/{name}.rs");
        let identity_module = format!("{group}_{name}");
        let dependency = inputs.shared_file(shared_path.path())?;

        push_generated(files, dependencies, cache, output_path, dependency, || {
            generate_shared_file(&bindings, source_path, &identity_module).with_context(|| {
                format!(
                    "generating shared file from {}",
                    shared_path.path().display()
                )
            })
        })?;
        shared_modules.entry(group).or_default().push(name);
    }

    for (group, modules) in &shared_modules {
        let output_path = format!("shared/{group}/mod.rs");
        let dependency = inputs.shared_group(group)?;

        push_generated(files, dependencies, cache, output_path, dependency, || {
            generate_shared_mod(modules)
                .with_context(|| format!("generating shared module barrel for {group}"))
        })?;
    }

    push_generated(
        files,
        dependencies,
        cache,
        "shared/mod.rs".into(),
        inputs.all_shared()?,
        || {
            generate_shared_mod(&shared_modules.keys().cloned().collect::<Vec<_>>())
                .context("generating top-level shared module barrel")
        },
    )?;

    Ok(())
}

fn generate_spec_outputs(
    specs: Vec<PreparedSpec>,
    files: &mut Vec<(String, String)>,
    dependencies: &mut BTreeMap<String, Checksum>,
) -> anyhow::Result<Vec<String>> {
    let mut spec_names = Vec::with_capacity(specs.len());

    for spec in specs {
        match spec.source {
            PreparedSpecSource::Loaded(loaded) => {
                push_generated(
                    files,
                    dependencies,
                    None,
                    spec.output_path,
                    spec.dependency,
                    || {
                        generate_spec_file(
                            &loaded.manifest,
                            &loaded.source_path,
                            &loaded.mod_name,
                            &loaded.display_name,
                        )
                        .with_context(|| {
                            format!("generating spec file from {}", loaded.path.display())
                        })
                    },
                )?;
            }
            PreparedSpecSource::Reused(contents) => {
                push_output(
                    files,
                    dependencies,
                    spec.output_path,
                    spec.dependency,
                    contents,
                )?;
            }
        }

        spec_names.push(spec.mod_name);
    }

    Ok(spec_names)
}

fn generate_item_outputs(
    repository: &ManifestRepository,
    manifests_dir: &Path,
    inputs: &ManifestInputs,
    files: &mut Vec<(String, String)>,
    dependencies: &mut BTreeMap<String, Checksum>,
    cache: Option<&CodegenCache>,
) -> anyhow::Result<()> {
    let items_manifest = repository.load_items()?;
    let items_path = manifests_dir.join("items.toml");

    if items_manifest.schema_version != CURRENT_SCHEMA_VERSION {
        bail!(
            "{}: unknown schema_version {} (expected {})",
            items_path.display(),
            items_manifest.schema_version,
            CURRENT_SCHEMA_VERSION
        );
    }

    let items_dependency = inputs.items()?;

    for (key, item) in &items_manifest.items {
        validate_item_identifiers(key, item, &items_path)?;

        if crate::gen_items::is_simple_equip_aura(item) {
            continue;
        }

        let snake = to_snake(key);
        let output_path = format!("items/{snake}.rs");

        push_generated(
            files,
            dependencies,
            cache,
            output_path,
            items_dependency,
            || {
                generate_item_file(key, item)
                    .with_context(|| format!("generating item file for {key}"))
            },
        )?;
    }

    push_generated(
        files,
        dependencies,
        cache,
        "items/mod.rs".into(),
        items_dependency,
        || {
            generate_items_mod_file(&items_manifest)
                .with_context(|| format!("generating items module from {}", items_path.display()))
        },
    )
}

fn push_generated(
    files: &mut Vec<(String, String)>,
    dependencies: &mut BTreeMap<String, Checksum>,
    cache: Option<&CodegenCache>,
    output_path: String,
    dependency: Checksum,
    generate: impl FnOnce() -> anyhow::Result<String>,
) -> anyhow::Result<()> {
    let contents = cache
        .map(|cache| cache.reuse(&output_path, dependency))
        .transpose()?
        .flatten()
        .map_or_else(generate, Ok)?;

    push_output(files, dependencies, output_path, dependency, contents)
}

fn push_output(
    files: &mut Vec<(String, String)>,
    dependencies: &mut BTreeMap<String, Checksum>,
    output_path: String,
    dependency: Checksum,
    contents: String,
) -> anyhow::Result<()> {
    if dependencies
        .insert(output_path.clone(), dependency)
        .is_some()
    {
        bail!("generator produced duplicate output path {output_path}");
    }

    files.push((output_path, contents));

    Ok(())
}