elemental-driver 0.1.0

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

use anyhow::Result;
use async_trait::async_trait;
use elemental_core::minecraft::MinecraftVersionId;

use crate::catalog::{
    Catalog, Release, ReleaseInfo, collect_single_game_loader_releases, single_game_release_info,
};
use crate::loader_version::LoaderVersionId;

use super::source::{FabricEndpointOverrides, FabricEndpoints, FabricFlavor, FabricSource};

pub struct FabricCatalog {
    source: FabricSource,
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct FabricRelease {
    pub game_version: MinecraftVersionId,
    pub loader_version: LoaderVersionId,
    pub description: Option<String>,
}

#[async_trait]
impl Release for FabricRelease {
    async fn info(&self) -> ReleaseInfo {
        single_game_release_info(
            self.loader_version.to_string(),
            self.game_version.clone(),
            self.description.clone(),
        )
    }
}

impl FabricCatalog {
    pub fn new(source: FabricSource) -> Self {
        Self { source }
    }

    pub fn with_defaults() -> Self {
        Self::new(FabricSource::default())
    }

    pub fn for_flavor(flavor: FabricFlavor) -> Result<Self> {
        Ok(Self::new(FabricSource::new(FabricEndpoints::for_flavor(
            flavor,
        )?)))
    }

    pub fn with_overrides(overrides: FabricEndpointOverrides) -> Result<Self> {
        Ok(Self::new(FabricSource::new(
            FabricEndpoints::with_overrides(overrides)?,
        )))
    }
}

#[async_trait]
impl Catalog for FabricCatalog {
    type Release = FabricRelease;

    async fn releases(&self) -> Result<HashMap<MinecraftVersionId, Vec<Self::Release>>> {
        let game_versions = self
            .source
            .game_versions()
            .await?
            .into_iter()
            .map(|game_version| MinecraftVersionId::from(game_version.version))
            .collect::<Vec<MinecraftVersionId>>();

        collect_single_game_loader_releases(
            game_versions,
            |game_version| async move { self.source.loader_versions(game_version.as_str()).await },
            |game_version, loader| FabricRelease {
                game_version: game_version.clone(),
                loader_version: LoaderVersionId::from(loader.loader.version),
                description: Some(if loader.loader.stable {
                    "Stable".to_owned()
                } else {
                    "Unstable".to_owned()
                }),
            },
        )
        .await
    }
}