elemental-driver 0.1.0

Driver library for Elemental, providing implementations for interacting with different modloaders and game versions.
Documentation
use std::collections::{HashMap, HashSet};

use anyhow::{Context, Result};
use serde::Deserialize;

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct LiteLoaderRelease {
    pub game_version: String,
    pub loader_version: String,
    pub stream: String,
}

#[derive(Debug, Clone)]
pub(super) struct LiteLoaderSelectedBuild {
    pub(super) game_version: String,
    pub(super) repository: LiteLoaderManifestRepository,
    pub(super) common_libraries: Vec<LiteLoaderManifestLibrary>,
    pub(super) build: LiteLoaderManifestBuild,
}

#[derive(Debug, Clone, Deserialize)]
pub(super) struct LiteLoaderManifest {
    pub(super) versions: HashMap<String, LiteLoaderManifestGameVersion>,
}

#[derive(Debug, Clone, Deserialize)]
pub(super) struct LiteLoaderManifestGameVersion {
    pub(super) repo: LiteLoaderManifestRepository,
    #[serde(default)]
    pub(super) artefacts: HashMap<String, HashMap<String, LiteLoaderManifestBuild>>,
    pub(super) snapshots: Option<LiteLoaderManifestSnapshots>,
}

#[derive(Debug, Clone, Deserialize)]
pub(super) struct LiteLoaderManifestRepository {
    #[serde(rename = "stream")]
    _stream: String,
    #[serde(rename = "type")]
    _repository_type: String,
    pub(super) url: String,
    #[serde(rename = "classifier")]
    _classifier: String,
}

#[derive(Debug, Clone, Deserialize)]
pub(super) struct LiteLoaderManifestSnapshots {
    #[serde(default)]
    pub(super) libraries: Vec<LiteLoaderManifestLibrary>,
    #[serde(flatten)]
    pub(super) packages: HashMap<String, HashMap<String, LiteLoaderManifestBuild>>,
}

#[derive(Debug, Clone, Deserialize)]
pub(super) struct LiteLoaderManifestBuild {
    #[serde(rename = "tweakClass")]
    pub(super) tweak_class: String,
    #[serde(default)]
    pub(super) libraries: Vec<LiteLoaderManifestLibrary>,
    pub(super) stream: String,
    pub(super) file: String,
    pub(super) version: String,
    #[serde(rename = "build")]
    _build: Option<String>,
    #[serde(rename = "md5")]
    _md5: Option<String>,
    pub(super) timestamp: Option<String>,
    #[serde(rename = "lastSuccessfulBuild")]
    _last_successful_build: Option<usize>,
}

#[derive(Debug, Clone, Deserialize)]
pub(super) struct LiteLoaderManifestLibrary {
    pub(super) name: String,
    #[serde(default)]
    pub(super) url: String,
}

pub(super) fn collect_releases(manifest: LiteLoaderManifest) -> Vec<LiteLoaderRelease> {
    let mut releases = Vec::new();

    for (game_version, game_entry) in manifest.versions {
        for selected in collect_builds_for_game(game_version.as_str(), &game_entry) {
            releases.push(LiteLoaderRelease {
                game_version: selected.game_version,
                loader_version: selected.build.version,
                stream: selected.build.stream,
            });
        }
    }

    releases.sort_by(|left, right| {
        left.game_version
            .cmp(&right.game_version)
            .then(left.loader_version.cmp(&right.loader_version))
    });

    releases
}

pub(super) fn select_build(
    manifest: &LiteLoaderManifest,
    game_version: &str,
    loader_version: &str,
) -> Result<LiteLoaderSelectedBuild> {
    let game_entry = manifest
        .versions
        .get(game_version)
        .with_context(|| format!("can't find LiteLoader Minecraft version '{game_version}'"))?;

    collect_builds_for_game(game_version, game_entry)
        .into_iter()
        .find(|build| build.build.version == loader_version)
        .with_context(|| {
            format!(
                "can't find LiteLoader loader version '{loader_version}' for Minecraft '{game_version}'"
            )
        })
}

fn collect_builds_for_game(
    game_version: &str,
    game_entry: &LiteLoaderManifestGameVersion,
) -> Vec<LiteLoaderSelectedBuild> {
    let mut builds = Vec::new();
    let mut seen_versions = HashSet::new();

    collect_package_builds(
        &mut builds,
        &mut seen_versions,
        game_version,
        &game_entry.repo,
        Vec::new(),
        &game_entry.artefacts,
    );

    if let Some(snapshots) = &game_entry.snapshots {
        collect_package_builds(
            &mut builds,
            &mut seen_versions,
            game_version,
            &game_entry.repo,
            snapshots.libraries.clone(),
            &snapshots.packages,
        );
    }

    builds.sort_by(|left, right| left.build.version.cmp(&right.build.version));

    builds
}

fn collect_package_builds(
    builds: &mut Vec<LiteLoaderSelectedBuild>,
    seen_versions: &mut HashSet<String>,
    game_version: &str,
    repository: &LiteLoaderManifestRepository,
    common_libraries: Vec<LiteLoaderManifestLibrary>,
    packages: &HashMap<String, HashMap<String, LiteLoaderManifestBuild>>,
) {
    for (coordinates, entries) in packages {
        if coordinates != "com.mumfrey:liteloader" {
            continue;
        }

        for build in materialize_build_entries(entries) {
            if !build.version.is_empty() && seen_versions.insert(build.version.clone()) {
                builds.push(LiteLoaderSelectedBuild {
                    game_version: game_version.to_owned(),
                    repository: repository.clone(),
                    common_libraries: common_libraries.clone(),
                    build,
                });
            }
        }
    }
}

fn materialize_build_entries(
    entries: &HashMap<String, LiteLoaderManifestBuild>,
) -> Vec<LiteLoaderManifestBuild> {
    let mut builds = entries
        .iter()
        .filter(|(key, _)| key.as_str() != "latest")
        .map(|(_, build)| build.clone())
        .collect::<Vec<LiteLoaderManifestBuild>>();

    if builds.is_empty()
        && let Some(latest) = entries.get("latest")
    {
        builds.push(latest.clone());
    }

    builds
}