elemental-driver 0.2.0

Driver library for Elemental, providing implementations for interacting with different modloaders and game versions.
Documentation
use elemental_schema::forge::ForgeInstallerProfile;

use crate::{
    error::{Error, Result},
    loader_version::LoaderVersionId,
    maven::MavenCoordinate,
};

#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct InstallerProfileIdentity {
    game_version: String,
    loader_version: LoaderVersionId,
}

impl InstallerProfileIdentity {
    pub(crate) fn from_profile(
        install_profile: &ForgeInstallerProfile,
        family_name: &str,
        loader_name: &str,
    ) -> Result<Self> {
        let game_version = install_profile
            .minecraft
            .clone()
            .or_else(|| {
                install_profile
                    .install
                    .as_ref()
                    .and_then(|legacy| legacy.minecraft.clone())
            })
            .ok_or_else(|| Error::InstallerProfileMinecraftVersionMissing {
                family_name: family_name.to_owned(),
            })?;

        let raw_loader_version = install_profile
            .path
            .clone()
            .or_else(|| {
                install_profile
                    .install
                    .as_ref()
                    .and_then(|legacy| legacy.path.clone())
            })
            .and_then(|coordinate| {
                MavenCoordinate::parse(coordinate.as_str())
                    .map(|parsed| parsed.version().to_owned())
            })
            .or_else(|| install_profile.version.clone())
            .ok_or_else(|| Error::InstallerProfileLoaderVersionMissing {
                family_name: family_name.to_owned(),
                loader_name: loader_name.to_owned(),
            })?;

        Ok(Self {
            game_version,
            loader_version: LoaderVersionId::from(raw_loader_version),
        })
    }

    fn validate_requested(
        &self,
        expected_game_version: &str,
        expected_loader_version: &LoaderVersionId,
        family_name: &str,
    ) -> Result<()> {
        if self.game_version != expected_game_version {
            return Err(Error::InstallerGameVersionMismatch {
                family_name: family_name.to_owned(),
                actual: self.game_version.clone(),
                expected: expected_game_version.to_owned(),
            });
        }

        if &self.loader_version != expected_loader_version {
            return Err(Error::InstallerLoaderVersionMismatch {
                family_name: family_name.to_owned(),
                actual: self.loader_version.to_string(),
                expected: expected_loader_version.to_string(),
            });
        }

        Ok(())
    }
}

pub fn profile_game_and_raw_loader_version(
    install_profile: &ForgeInstallerProfile,
    family_name: &str,
    loader_name: &str,
) -> Result<(String, LoaderVersionId)> {
    let identity =
        InstallerProfileIdentity::from_profile(install_profile, family_name, loader_name)?;
    Ok((identity.game_version, identity.loader_version))
}

pub fn validate_installer_profile_identity(
    expected_game_version: &str,
    expected_loader_version: &LoaderVersionId,
    actual_game_version: &str,
    actual_loader_version: &LoaderVersionId,
    family_name: &str,
) -> Result<()> {
    InstallerProfileIdentity {
        game_version: actual_game_version.to_owned(),
        loader_version: actual_loader_version.clone(),
    }
    .validate_requested(expected_game_version, expected_loader_version, family_name)
}