elemental-driver 0.1.0

Driver library for Elemental, providing implementations for interacting with different modloaders and game versions.
Documentation
use std::path::PathBuf;

use anyhow::{Context, Result};
use elemental_core::minecraft::MinecraftVersionId;

use crate::{
    families::installer::{
        InstallerArtifactEndpoints, InstallerMavenArtifactSpec, InstallerMavenEndpoints,
        InstallerMavenSource,
    },
    loader_version::LoaderVersionId,
    url::{Origin, OriginPolicy},
};

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum ForgeOrigin {
    Maven,
}

#[derive(Debug, Clone)]
pub struct ForgeEndpoints {
    origin_policy: OriginPolicy<ForgeOrigin>,
}

pub type ForgeSource = InstallerMavenSource<ForgeEndpoints>;

impl Origin for ForgeOrigin {
    fn canonical(self) -> &'static str {
        match self {
            Self::Maven => "https://maven.minecraftforge.net",
        }
    }

    fn all() -> &'static [Self] {
        const ALL: &[ForgeOrigin] = &[ForgeOrigin::Maven];
        ALL
    }
}

impl Default for ForgeEndpoints {
    fn default() -> Self {
        Self::official()
    }
}

impl ForgeEndpoints {
    pub fn new(origin_policy: OriginPolicy<ForgeOrigin>) -> Self {
        Self { origin_policy }
    }

    pub fn official() -> Self {
        Self::new(OriginPolicy::default())
    }

    pub fn origin_policy(&self) -> &OriginPolicy<ForgeOrigin> {
        &self.origin_policy
    }

    pub fn maven_metadata_url(&self) -> Result<String> {
        self.origin_policy.resolve(
            ForgeOrigin::Maven,
            "/net/minecraftforge/forge/maven-metadata.xml",
        )
    }

    pub fn installer_url(&self, game_version: &str, loader_version: &str) -> Result<String> {
        let version = release_version(game_version, loader_version);
        self.origin_policy.resolve(
            ForgeOrigin::Maven,
            &format!("/net/minecraftforge/forge/{version}/forge-{version}-installer.jar"),
        )
    }

    pub fn maven_artifact_url(&self, artifact_path: &str) -> Result<String> {
        self.origin_policy
            .resolve(ForgeOrigin::Maven, artifact_path)
    }

    pub fn rewrite_upstream(&self, raw_url: &str) -> Result<String> {
        self.origin_policy.rewrite_origin_url(raw_url)
    }
}

impl InstallerArtifactEndpoints for ForgeEndpoints {
    fn artifact_url(&self, artifact_path: &str) -> Result<String> {
        ForgeEndpoints::maven_artifact_url(self, artifact_path)
    }

    fn rewrite_upstream(&self, raw_url: &str) -> Result<String> {
        ForgeEndpoints::rewrite_upstream(self, raw_url)
    }
}

impl InstallerMavenEndpoints for ForgeEndpoints {
    const SOURCE_NAME: &'static str = "forge source";

    fn maven_metadata_url(&self) -> Result<String> {
        ForgeEndpoints::maven_metadata_url(self)
    }

    fn installer_artifact_spec(
        &self,
        game_version: &MinecraftVersionId,
        loader_version: &LoaderVersionId,
    ) -> Result<InstallerMavenArtifactSpec> {
        let version = release_version(game_version.as_str(), loader_version.as_str());

        Ok(InstallerMavenArtifactSpec {
            coordinate: format!("net.minecraftforge:forge:{version}:installer"),
            download_url: self.installer_url(game_version.as_str(), loader_version.as_str())?,
            relative_path: forge_installer_relative_path(&version),
        })
    }
}

pub fn release_version(game_version: &str, loader_version: &str) -> String {
    format!("{game_version}-{loader_version}")
}

pub fn forge_installer_relative_path(version: &str) -> PathBuf {
    PathBuf::from("net")
        .join("minecraftforge")
        .join("forge")
        .join(version)
        .join(format!("forge-{version}-installer.jar"))
}

pub fn parse_installer_version(version: &str) -> Result<(String, String)> {
    version
        .split_once('-')
        .map(|(game_version, loader_version)| (game_version.to_owned(), loader_version.to_owned()))
        .context(format!("forge installer version is invalid: {version}"))
}