elemental-driver 0.1.0

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

use anyhow::Result;
use elemental_core::{
    minecraft::MinecraftVersionId,
    storage::{
        Storage,
        layout::{Layout, Layoutable},
    },
};
use elemental_schema::mojang::piston::PistonMetaData;

use crate::{
    driver::{Driver, DriverDescriptor, InstalledDriver},
    families::version_json::{
        VersionJsonGameStorageExt, VersionJsonInstanceLayout, VersionJsonInstanceResource,
        VersionJsonRootLayout,
    },
};

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct LibraryPrefixSet {
    prefixes: &'static [&'static str],
}

impl LibraryPrefixSet {
    pub const fn new(prefixes: &'static [&'static str]) -> Self {
        Self { prefixes }
    }

    pub fn matches(self, metadata: &PistonMetaData) -> bool {
        metadata
            .libraries
            .iter()
            .map(|library| library.name.as_str())
            .any(|name| self.matches_name(name))
    }

    pub fn version(self, metadata: &PistonMetaData) -> Option<String> {
        metadata
            .libraries
            .iter()
            .map(|library| library.name.as_str())
            .find(|name| self.matches_name(name))
            .and_then(|name| name.split(':').nth(2).map(ToOwned::to_owned))
    }

    pub fn installed_driver(
        self,
        metadata: &PistonMetaData,
        descriptor: DriverDescriptor,
    ) -> Option<InstalledDriver> {
        self.version(metadata).map(|driver_version| {
            InstalledDriver::version_json(descriptor, metadata, Some(driver_version))
        })
    }

    fn matches_name(self, library_name: &str) -> bool {
        self.prefixes
            .iter()
            .any(|prefix| library_name.starts_with(prefix))
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ProfileIdPattern {
    separator: &'static str,
}

impl ProfileIdPattern {
    pub const fn new(separator: &'static str) -> Self {
        Self { separator }
    }

    pub fn build(self, game_version: &str, loader_version: &str) -> String {
        format!("{game_version}{}{loader_version}", self.separator)
    }

    pub fn loader_version(self, metadata_id: &str) -> Option<String> {
        metadata_id
            .split_once(self.separator)
            .map(|(_, loader_version)| loader_version.to_owned())
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ProfiledDriverIdentity {
    descriptor: DriverDescriptor,
    markers: LibraryPrefixSet,
    version_libraries: LibraryPrefixSet,
    profile_id: ProfileIdPattern,
    stale_markers: Option<LibraryPrefixSet>,
}

impl ProfiledDriverIdentity {
    pub const fn new(
        descriptor: DriverDescriptor,
        markers: LibraryPrefixSet,
        version_libraries: LibraryPrefixSet,
        profile_id: ProfileIdPattern,
    ) -> Self {
        Self {
            descriptor,
            markers,
            version_libraries,
            profile_id,
            stale_markers: None,
        }
    }

    pub const fn with_stale_markers(self, stale_markers: LibraryPrefixSet) -> Self {
        Self {
            stale_markers: Some(stale_markers),
            ..self
        }
    }

    pub fn build_profile_id(self, game_version: &str, loader_version: &str) -> String {
        self.profile_id.build(game_version, loader_version)
    }

    pub fn inspect_driver_version(self, metadata: &PistonMetaData) -> Option<String> {
        self.version_libraries
            .version(metadata)
            .or_else(|| self.profile_id.loader_version(metadata.id.as_str()))
    }

    pub fn matches_metadata(self, metadata: &PistonMetaData) -> bool {
        self.markers.matches(metadata)
            || self
                .profile_id
                .loader_version(metadata.id.as_str())
                .is_some()
    }

    pub fn local_metadata_needs_refresh(
        self,
        metadata: &PistonMetaData,
        game_version: &MinecraftVersionId,
        loader_version: &str,
    ) -> bool {
        metadata.id != self.build_profile_id(game_version.as_str(), loader_version)
            || metadata.inherits_from.as_deref() != Some(game_version.as_str())
            || self
                .stale_markers
                .is_some_and(|stale_markers| stale_markers.matches(metadata))
            || self
                .inspect_driver_version(metadata)
                .is_none_or(|installed| installed != loader_version)
    }

    pub fn inspect_installed(self, metadata: &PistonMetaData) -> Option<InstalledDriver> {
        if !self.matches_metadata(metadata) {
            return None;
        }

        Some(InstalledDriver::version_json(
            self.descriptor,
            metadata,
            self.inspect_driver_version(metadata),
        ))
    }
}

#[derive(Debug, Clone)]
pub struct InstanceProbe<L: Layout, VL: Layout> {
    pub storage: Storage<VL, Storage<L>>,
    pub metadata: Option<PistonMetaData>,
}

#[derive(Debug, Clone)]
pub struct InstalledInstance<L: Layout, VL: Layout> {
    pub storage: Storage<VL, Storage<L>>,
    pub driver: InstalledDriver,
}

impl<L: Layout, VL: VersionJsonInstanceLayout> InstanceProbe<L, VL> {
    pub fn collect(storage: Storage<VL, Storage<L>>) -> Result<Self> {
        let metadata_path = Self::detect_metadata_path(&storage)?;
        let metadata: Option<PistonMetaData> = match metadata_path.as_ref() {
            Some(path) => Some(serde_json::from_reader(File::open(path)?)?),
            None => None,
        };

        Ok(Self { storage, metadata })
    }

    fn detect_metadata_path(storage: &Storage<VL, Storage<L>>) -> Result<Option<PathBuf>> {
        let preferred = storage
            .try_get_resource(VersionJsonInstanceResource::Metadata)
            .ok()
            .filter(|path| path.exists());
        if preferred.is_some() {
            return Ok(preferred);
        }

        let mut json_files = Vec::new();
        if storage.path.exists() {
            for entry in storage.path.read_dir()? {
                let entry = entry?;
                if entry.file_type()?.is_file()
                    && entry
                        .path()
                        .extension()
                        .and_then(|extension| extension.to_str())
                        .is_some_and(|extension| extension.eq_ignore_ascii_case("json"))
                {
                    json_files.push(entry.path());
                }
            }
        }

        Ok(if json_files.len() == 1 {
            json_files.into_iter().next()
        } else {
            None
        })
    }
}

impl<L: Layout + Clone, VL: VersionJsonInstanceLayout + Clone> InstalledInstance<L, VL> {
    pub async fn detect(
        storage: Storage<VL, Storage<L>>,
        drivers: &[&dyn Driver<L, VL>],
    ) -> Result<Option<Self>> {
        let probe = InstanceProbe::collect(storage.clone())?;
        for driver in drivers {
            if let Some(installed) = driver.inspect(&probe).await? {
                return Ok(Some(Self {
                    storage,
                    driver: installed,
                }));
            }
        }

        Ok(None)
    }
}

impl<L, VL> InstalledInstance<L, VL>
where
    L: VersionJsonRootLayout + Clone,
    VL: VersionJsonInstanceLayout + Clone,
{
    pub async fn detect_all(
        storage: &Storage<L>,
        version_layout: VL,
        drivers: &[&dyn Driver<L, VL>],
    ) -> Result<Vec<Self>> {
        let mut instances = Vec::new();

        for instance in storage.instances(version_layout)? {
            if let Some(installed) = Self::detect(instance, drivers).await? {
                instances.push(installed);
            }
        }

        Ok(instances)
    }
}