crust_core 1.0.3

Core library to download, install and launch Minecraft (versions, assets, libraries, Java runtime, mod loaders)
Documentation
use std::fmt;
use std::str::FromStr;

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct MavenCoordinate {
    pub group: String,
    pub artifact: String,
    pub version: String,
    pub classifier: Option<String>,
    pub extension: String,
}

#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
#[error("invalid maven coordinate: {0}")]
pub struct ParseError(pub String);

impl FromStr for MavenCoordinate {
    type Err = ParseError;

    fn from_str(input: &str) -> Result<Self, Self::Err> {
        let (body, extension) = match input.rsplit_once('@') {
            Some((body, ext)) if !ext.is_empty() => (body, ext.to_owned()),
            _ => (input, "jar".to_owned()),
        };
        let mut parts = body.split(':');
        let (Some(group), Some(artifact), Some(version)) =
            (parts.next(), parts.next(), parts.next())
        else {
            return Err(ParseError(input.to_owned()));
        };
        if group.is_empty() || artifact.is_empty() || version.is_empty() {
            return Err(ParseError(input.to_owned()));
        }
        let classifier = parts.next().filter(|c| !c.is_empty()).map(str::to_owned);
        if parts.next().is_some() {
            return Err(ParseError(input.to_owned()));
        }
        Ok(Self {
            group: group.to_owned(),
            artifact: artifact.to_owned(),
            version: version.to_owned(),
            classifier,
            extension,
        })
    }
}

impl MavenCoordinate {
    pub fn file_name(&self) -> String {
        match &self.classifier {
            Some(classifier) => format!(
                "{}-{}-{}.{}",
                self.artifact, self.version, classifier, self.extension
            ),
            None => format!("{}-{}.{}", self.artifact, self.version, self.extension),
        }
    }

    pub fn directory(&self) -> String {
        format!(
            "{}/{}/{}",
            self.group.replace('.', "/"),
            self.artifact,
            self.version
        )
    }

    pub fn path(&self) -> String {
        format!("{}/{}", self.directory(), self.file_name())
    }

    pub fn key(&self) -> String {
        match &self.classifier {
            Some(classifier) => format!("{}:{}:{}", self.group, self.artifact, classifier),
            None => format!("{}:{}", self.group, self.artifact),
        }
    }
}

impl fmt::Display for MavenCoordinate {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}:{}:{}", self.group, self.artifact, self.version)?;
        if let Some(classifier) = &self.classifier {
            write!(f, ":{classifier}")?;
        }
        if self.extension != "jar" {
            write!(f, "@{}", self.extension)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct LibraryPath {
    pub path: String,
    pub name: String,
    pub version: String,
}

pub fn library_path(
    main: &str,
    native_suffix: Option<&str>,
    force_ext: Option<&str>,
) -> LibraryPath {
    let parts: Vec<&str> = main.split(':').collect();
    let group = parts.first().copied().unwrap_or_default();
    let artifact = parts.get(1).copied().unwrap_or_default();
    let version = parts.get(2).copied().unwrap_or_default();
    let file_name = match parts.get(3) {
        Some(classifier) => format!("{version}-{classifier}"),
        None => version.to_owned(),
    };
    let final_file_name = if file_name.contains('@') {
        file_name.replacen('@', ".", 1)
    } else {
        format!(
            "{file_name}{}{}",
            native_suffix.unwrap_or_default(),
            force_ext.unwrap_or(".jar")
        )
    };
    let version_dir = version.split('@').next().unwrap_or_default();
    LibraryPath {
        path: format!("{}/{artifact}/{version_dir}", group.replace('.', "/")),
        name: format!("{artifact}-{final_file_name}"),
        version: version.to_owned(),
    }
}

impl LibraryPath {
    pub fn full(&self) -> String {
        format!("{}/{}", self.path, self.name)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn library_path_matches_node_get_path_libraries() {
        let forge = library_path("net.minecraftforge:forge:1.19-41.0.63", None, None);
        assert_eq!(forge.path, "net/minecraftforge/forge/1.19-41.0.63");
        assert_eq!(forge.name, "forge-1.19-41.0.63.jar");
        assert_eq!(forge.version, "1.19-41.0.63");

        let mapping = library_path(
            "de.oceanlabs.mcp:mcp_config:1.20.1-20230612.114412:mappings@txt",
            None,
            None,
        );
        assert_eq!(
            mapping.path,
            "de/oceanlabs/mcp/mcp_config/1.20.1-20230612.114412"
        );
        assert_eq!(
            mapping.name,
            "mcp_config-1.20.1-20230612.114412-mappings.txt"
        );

        let zip = library_path(
            "de.oceanlabs.mcp:mcp_config:1.12.2-20200226.224830@zip",
            None,
            None,
        );
        assert_eq!(
            zip.path,
            "de/oceanlabs/mcp/mcp_config/1.12.2-20200226.224830"
        );
        assert_eq!(zip.name, "mcp_config-1.12.2-20200226.224830.zip");
        assert_eq!(zip.version, "1.12.2-20200226.224830@zip");

        let at_jar = library_path("org.ow2.asm:asm-analysis:9.7@jar", None, None);
        assert_eq!(at_jar.name, "asm-analysis-9.7.jar");
        assert_eq!(at_jar.path, "org/ow2/asm/asm-analysis/9.7");

        let native = library_path(
            "org.lwjgl.lwjgl:lwjgl-platform:2.9.4-nightly-20150209",
            Some("-natives-osx"),
            None,
        );
        assert_eq!(
            native.name,
            "lwjgl-platform-2.9.4-nightly-20150209-natives-osx.jar"
        );

        let client_data = library_path(
            "net.minecraftforge:forge:1.20.1-47.2.0:universal",
            Some("-clientdata"),
            Some(".lzma"),
        );
        assert_eq!(
            client_data.name,
            "forge-1.20.1-47.2.0-universal-clientdata.lzma"
        );
        assert_eq!(
            client_data.full(),
            "net/minecraftforge/forge/1.20.1-47.2.0/forge-1.20.1-47.2.0-universal-clientdata.lzma"
        );
    }

    #[test]
    fn parses_simple_coordinate() {
        let c: MavenCoordinate = "com.mojang:brigadier:1.0.18".parse().unwrap();
        assert_eq!(c.path(), "com/mojang/brigadier/1.0.18/brigadier-1.0.18.jar");
        assert_eq!(c.key(), "com.mojang:brigadier");
    }

    #[test]
    fn parses_classifier_and_extension() {
        let c: MavenCoordinate = "org.lwjgl:lwjgl:3.3.1:natives-macos-arm64".parse().unwrap();
        assert_eq!(
            c.path(),
            "org/lwjgl/lwjgl/3.3.1/lwjgl-3.3.1-natives-macos-arm64.jar"
        );
        let c: MavenCoordinate = "net.minecraftforge:forge:1.20.1-47.2.0:universal@zip"
            .parse()
            .unwrap();
        assert_eq!(c.file_name(), "forge-1.20.1-47.2.0-universal.zip");
        assert_eq!(
            c.to_string(),
            "net.minecraftforge:forge:1.20.1-47.2.0:universal@zip"
        );
    }

    #[test]
    fn rejects_invalid() {
        assert!("only:two".parse::<MavenCoordinate>().is_err());
        assert!("a:b:c:d:e".parse::<MavenCoordinate>().is_err());
    }
}