wowlab_manifest_schema/

repository_composition.rs

// #t(file: rust_clone_in_loop) Composition owns bounded keys and values for diagnostics and patches.

//! TOML component parsing, ordered composition, and shared-section patching.

use indexmap::IndexSet;
use serde::Deserialize;
use wowlab_fs::{
    containment, file,
    path::{Component, Path, PathBuf},
    walk,
};

use crate::{CURRENT_SCHEMA_VERSION, ManifestLoadError};

const SHARED_DIR: &str = "shared";
const TABLE_SECTIONS: &[&str] = &[
    "auras",
    "spells",
    "auto_attacks",
    "talents",
    "set_bonuses",
    "talent_companion_auras",
    "hero_talents",
    "effects",
    "content_effects",
    "reported_spells",
];
const ARRAY_SECTIONS: &[&str] = &[
    "spell_groups",
    "impact_procs",
    "talent_gated_aura_effects",
    "masked_passive_effects",
    "passive_effect_overrides",
];

pub(super) fn compose_spec_document(path: &Path) -> Result<toml::Table, ManifestLoadError> {
    let mut document = read_table(path)?;

    validate_schema_version(&document, path)?;
    let parts = parse_paths(&mut document, "parts", path)?;
    let shared = parse_shared(&mut document, path)?;
    let mut included = IndexSet::with_capacity(parts.len() + shared.len());

    load_private_parts(&mut document, path, parts, &mut included)?;
    load_shared_components(&mut document, path, shared, &mut included)?;

    Ok(document)
}

pub(super) fn validate_schema_version(
    document: &toml::Table,
    path: &Path,
) -> Result<(), ManifestLoadError> {
    let Some(version) = document.get("schema_version") else {
        return Err(ManifestLoadError::MissingSchemaVersion {
            path: path.to_path_buf(),
        });
    };
    let Some(found) = version.as_integer() else {
        return Ok(());
    };

    if found != i64::from(CURRENT_SCHEMA_VERSION) {
        return Err(ManifestLoadError::UnsupportedSchemaVersion {
            path: path.to_path_buf(),
            found,
            expected: CURRENT_SCHEMA_VERSION,
        });
    }

    Ok(())
}

fn load_private_parts(
    document: &mut toml::Table,
    manifest_path: &Path,
    parts: Vec<PathBuf>,
    included: &mut IndexSet<PathBuf>,
) -> Result<(), ManifestLoadError> {
    let spec_dir = manifest_path
        .parent()
        .ok_or_else(|| ManifestLoadError::InvalidSpecPath {
            path: manifest_path.to_path_buf(),
        })?;

    for part in parts {
        validate_component_path(&part)?;
        reject_duplicate_component(included, manifest_path, &part)?;
        let part_path = canonical_component_path(spec_dir, &part)?;
        let component = read_component(&part_path)?;

        merge_component(document, component, &part_path)?;
    }

    Ok(())
}

fn load_shared_components(
    document: &mut toml::Table,
    manifest_path: &Path,
    shared: Vec<SharedInclude>,
    included: &mut IndexSet<PathBuf>,
) -> Result<(), ManifestLoadError> {
    let class_dir = manifest_path
        .parent()
        .and_then(Path::parent)
        .ok_or_else(|| ManifestLoadError::InvalidSpecPath {
            path: manifest_path.to_path_buf(),
        })?;

    for include in shared {
        validate_component_path(&include.path)?;
        let identity = PathBuf::from(SHARED_DIR).join(&include.path);

        reject_duplicate_component(included, manifest_path, &identity)?;
        let shared_dir = class_dir.join(SHARED_DIR);
        let shared_path = canonical_component_path(&shared_dir, &include.path)?;
        let component = read_component(&shared_path)?;

        apply_shared_component(document, component, include, &shared_path)?;
    }

    Ok(())
}

#[derive(Debug, Deserialize)]
#[serde(deny_unknown_fields)]
struct SharedInclude {
    path: PathBuf,
    #[serde(default)]
    before: OrderedSections,
    #[serde(default)]
    append: AppendSections,
    #[serde(default)]
    patch: PatchSections,
}

#[derive(Debug, Default, Deserialize)]
#[serde(deny_unknown_fields)]
#[expect(
    clippy::struct_excessive_bools,
    reason = "fields mirror independent append switches in the flat TOML include schema"
)]
struct AppendSections {
    #[serde(default)]
    auras: bool,
    #[serde(default)]
    spells: bool,
    #[serde(default)]
    auto_attacks: bool,
    #[serde(default)]
    hero_talents: bool,
    #[serde(default)]
    effects: bool,
}

impl AppendSections {
    fn configured_sections(&self) -> impl Iterator<Item = &'static str> {
        [
            ("auras", self.auras),
            ("spells", self.spells),
            ("auto_attacks", self.auto_attacks),
            ("hero_talents", self.hero_talents),
            ("effects", self.effects),
        ]
        .into_iter()
        .filter_map(|(section, configured)| configured.then_some(section))
    }

    fn contains(&self, section: &str) -> bool {
        match section {
            "auras" => self.auras,
            "spells" => self.spells,
            "auto_attacks" => self.auto_attacks,
            "hero_talents" => self.hero_talents,
            "effects" => self.effects,
            _ => false,
        }
    }
}

#[derive(Debug, Default, Deserialize)]
#[serde(deny_unknown_fields)]
struct OrderedSections {
    auras: Option<String>,
    spells: Option<String>,
    auto_attacks: Option<String>,
    hero_talents: Option<String>,
    effects: Option<String>,
}

impl OrderedSections {
    fn take(&mut self, section: &str) -> Option<String> {
        match section {
            "auras" => self.auras.take(),
            "spells" => self.spells.take(),
            "auto_attacks" => self.auto_attacks.take(),
            "hero_talents" => self.hero_talents.take(),
            "effects" => self.effects.take(),
            _ => None,
        }
    }

    fn configured_sections(&self) -> impl Iterator<Item = &'static str> {
        [
            ("auras", self.auras.is_some()),
            ("spells", self.spells.is_some()),
            ("auto_attacks", self.auto_attacks.is_some()),
            ("hero_talents", self.hero_talents.is_some()),
            ("effects", self.effects.is_some()),
        ]
        .into_iter()
        .filter_map(|(section, configured)| configured.then_some(section))
    }
}

#[derive(Debug, Default, Deserialize)]
#[serde(deny_unknown_fields)]
struct PatchSections {
    #[serde(default)]
    auras: toml::Table,
    #[serde(default)]
    spells: toml::Table,
}

impl PatchSections {
    fn take(&mut self, section: &str) -> toml::Table {
        match section {
            "auras" => std::mem::take(&mut self.auras),
            "spells" => std::mem::take(&mut self.spells),
            _ => toml::Table::new(),
        }
    }

    fn configured_sections(&self) -> impl Iterator<Item = &'static str> {
        [
            ("auras", !self.auras.is_empty()),
            ("spells", !self.spells.is_empty()),
        ]
        .into_iter()
        .filter_map(|(section, configured)| configured.then_some(section))
    }
}

pub(super) fn toml_paths_below(root: &Path) -> Result<Vec<PathBuf>, ManifestLoadError> {
    let mut paths =
        walk::repository_files(root).map_err(|source| ManifestLoadError::WalkDirectory {
            path: root.to_path_buf(),
            source,
        })?;

    paths.retain(|path| {
        path.extension()
            .is_some_and(|extension| extension == "toml")
    });

    Ok(paths)
}

pub(super) fn is_shared_path(path: &Path, specs_root: &Path) -> bool {
    containment::relative_to(specs_root, path).is_ok_and(|relative| {
        relative
            .components()
            .any(|component| component.as_os_str() == SHARED_DIR)
    })
}

fn read_source(path: &Path) -> Result<String, ManifestLoadError> {
    file::read_text(path).map_err(|source| ManifestLoadError::ReadFile {
        path: path.to_path_buf(),
        source,
    })
}

pub(super) fn read_table(path: &Path) -> Result<toml::Table, ManifestLoadError> {
    let source = read_source(path)?;

    toml::from_str(&source).map_err(|source| ManifestLoadError::Parse {
        path: path.to_path_buf(),
        source,
    })
}

fn parse_paths(
    document: &mut toml::Table,
    field: &str,
    path: &Path,
) -> Result<Vec<PathBuf>, ManifestLoadError> {
    let Some(value) = document.remove(field) else {
        return Ok(Vec::new());
    };

    value.try_into().map_err(|source| ManifestLoadError::Parse {
        path: path.to_path_buf(),
        source,
    })
}

fn parse_shared(
    document: &mut toml::Table,
    path: &Path,
) -> Result<Vec<SharedInclude>, ManifestLoadError> {
    let Some(value) = document.remove("shared") else {
        return Ok(Vec::new());
    };

    value.try_into().map_err(|source| ManifestLoadError::Parse {
        path: path.to_path_buf(),
        source,
    })
}

fn validate_component_path(path: &Path) -> Result<(), ManifestLoadError> {
    let valid_extension = path
        .extension()
        .is_some_and(|extension| extension == "toml");
    let valid_components = path
        .components()
        .all(|component| matches!(component, Component::Normal(_) | Component::Current));

    if path.as_os_str().is_empty() || !valid_extension || !valid_components {
        return Err(ManifestLoadError::InvalidComponentPath {
            path: path.to_path_buf(),
        });
    }

    Ok(())
}

fn canonical_component_path(base: &Path, relative: &Path) -> Result<PathBuf, ManifestLoadError> {
    let target = base.join(relative);

    containment::resolve_existing(base, relative).map_err(|source| {
        if let Some(outside) = source.outside_root().cloned() {
            ManifestLoadError::PathOutsideRepository {
                path: outside.path().to_path_buf(),
                root: outside.root().to_path_buf(),
                source: outside,
            }
        } else {
            ManifestLoadError::ResolveComponent {
                path: target,
                root: base.to_path_buf(),
                source,
            }
        }
    })
}

fn reject_duplicate_component(
    included: &mut IndexSet<PathBuf>,
    manifest: &Path,
    path: &Path,
) -> Result<(), ManifestLoadError> {
    if included.insert(path.to_path_buf()) {
        return Ok(());
    }

    Err(ManifestLoadError::DuplicateComponent {
        manifest: manifest.to_path_buf(),
        path: path.to_path_buf(),
    })
}

pub(super) fn read_component(path: &Path) -> Result<toml::Table, ManifestLoadError> {
    let component = read_table(path)?;

    if component.is_empty() {
        return Err(ManifestLoadError::EmptyComponent {
            path: path.to_path_buf(),
        });
    }

    for section in component.keys() {
        if !TABLE_SECTIONS.contains(&section.as_str())
            && !ARRAY_SECTIONS.contains(&section.as_str())
        {
            return Err(ManifestLoadError::UnsupportedSection {
                source_path: path.to_path_buf(),
                section: section.clone(),
            });
        }
    }

    Ok(component)
}

fn merge_component(
    document: &mut toml::Table,
    component: toml::Table,
    source_path: &Path,
) -> Result<(), ManifestLoadError> {
    for (section, value) in component {
        if TABLE_SECTIONS.contains(&section.as_str()) {
            let source = value.as_table().cloned().ok_or_else(|| {
                ManifestLoadError::InvalidTargetSection {
                    source_path: source_path.to_path_buf(),
                    section: section.clone(),
                }
            })?;

            merge_table_section(document, &section, source, None, source_path)?;
        } else {
            merge_array_section(document, &section, &value, source_path)?;
        }
    }

    Ok(())
}

fn apply_shared_component(
    document: &mut toml::Table,
    component: toml::Table,
    mut include: SharedInclude,
    shared_path: &Path,
) -> Result<(), ManifestLoadError> {
    let present: IndexSet<String> = component.keys().cloned().collect();

    for section in include
        .before
        .configured_sections()
        .chain(include.append.configured_sections())
        .chain(include.patch.configured_sections())
    {
        if !present.contains(section) {
            return Err(ManifestLoadError::ConfigurationWithoutSection {
                shared: shared_path.to_path_buf(),
                section,
            });
        }
    }

    for section in include.before.configured_sections() {
        if include.append.contains(section) {
            return Err(ManifestLoadError::ConflictingSectionOrder {
                shared: shared_path.to_path_buf(),
                section,
            });
        }
    }

    for (section, value) in component {
        if TABLE_SECTIONS.contains(&section.as_str()) {
            let mut source = value.as_table().cloned().ok_or_else(|| {
                ManifestLoadError::InvalidTargetSection {
                    source_path: shared_path.to_path_buf(),
                    section: section.clone(),
                }
            })?;
            let patch = include.patch.take(&section);

            if !patch.is_empty() {
                patch_entries(&mut source, &section, &patch, shared_path)?;
            }

            let before = include.before.take(&section);

            merge_table_section(document, &section, source, before.as_deref(), shared_path)?;
        } else {
            merge_array_section(document, &section, &value, shared_path)?;
        }
    }

    Ok(())
}

fn merge_table_section(
    document: &mut toml::Table,
    section: &str,
    source: toml::Table,
    before: Option<&str>,
    source_path: &Path,
) -> Result<(), ManifestLoadError> {
    let target = document
        .entry(section)
        .or_insert_with(|| toml::Value::Table(toml::Table::new()))
        .as_table_mut()
        .ok_or_else(|| ManifestLoadError::InvalidTargetSection {
            source_path: source_path.to_path_buf(),
            section: section.to_owned(),
        })?;

    if let Some(insertion_point) = before {
        if !target.contains_key(insertion_point) {
            return Err(ManifestLoadError::MissingInsertionPoint {
                shared: source_path.to_path_buf(),
                section: ordered_section_name(section),
                before: insertion_point.to_owned(),
            });
        }
    }

    for key in source.keys() {
        if target.contains_key(key) {
            return Err(ManifestLoadError::DuplicateKey {
                source_path: source_path.to_path_buf(),
                section: section.to_owned(),
                key: key.clone(),
            });
        }
    }

    insert_entries(target, source.into_iter().collect(), before);

    Ok(())
}

fn merge_array_section(
    document: &mut toml::Table,
    section: &str,
    source: &toml::Value,
    source_path: &Path,
) -> Result<(), ManifestLoadError> {
    let source =
        source
            .as_array()
            .cloned()
            .ok_or_else(|| ManifestLoadError::InvalidArraySection {
                source_path: source_path.to_path_buf(),
                section: section.to_owned(),
            })?;
    let target = document
        .entry(section)
        .or_insert_with(|| toml::Value::Array(Vec::new()))
        .as_array_mut()
        .ok_or_else(|| ManifestLoadError::InvalidArraySection {
            source_path: source_path.to_path_buf(),
            section: section.to_owned(),
        })?;

    target.extend(source);

    Ok(())
}

fn patch_entries(
    source: &mut toml::Table,
    section: &str,
    patch: &toml::Table,
    shared_path: &Path,
) -> Result<(), ManifestLoadError> {
    let section = ordered_section_name(section);

    for (key, value) in source {
        let table = value
            .as_table_mut()
            .ok_or_else(|| ManifestLoadError::InvalidPatchTarget {
                shared: shared_path.to_path_buf(),
                section,
                key: key.clone(),
            })?;

        table.extend(
            patch
                .iter()
                .map(|(key, value)| (key.clone(), value.clone())),
        );
    }

    Ok(())
}

// #t(fn: rust_const_fn_candidate) Matching string slices is not const-stable.
fn ordered_section_name(section: &str) -> &'static str {
    match section {
        "auras" => "auras",
        "spells" => "spells",
        "auto_attacks" => "auto_attacks",
        "hero_talents" => "hero_talents",
        "effects" => "effects",
        _ => "unknown",
    }
}

fn insert_entries(
    target: &mut toml::Table,
    entries: Vec<(String, toml::Value)>,
    before: Option<&str>,
) {
    let previous = std::mem::take(target);
    let mut pending = Some(entries);

    for (key, value) in previous {
        if before == Some(key.as_str()) {
            if let Some(entries) = pending.take() {
                target.extend(entries);
            }
        }

        target.insert(key, value);
    }

    if let Some(entries) = pending {
        target.extend(entries);
    }
}

pub(super) fn deserialize_section<T>(
    value: Option<toml::Value>,
    path: &Path,
) -> Result<T, ManifestLoadError>
where
    T: Default + for<'de> Deserialize<'de>,
{
    let Some(value) = value else {
        return Ok(T::default());
    };

    value.try_into().map_err(|source| ManifestLoadError::Parse {
        path: path.to_path_buf(),
        source,
    })
}