Fabric support

daedalus/src/fabric.rs

@@ -0,0 +1,132 @@
+use crate::minecraft::{Argument, ArgumentType, Library, VersionInfo, VersionType};
+use crate::{download_file, Error};
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+/// The latest version of the format the model structs deserialize to
+pub const CURRENT_FORMAT_VERSION: usize = 0;
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+/// A partial version returned by fabric meta
+pub struct PartialVersionInfo {
+    /// The version ID of the version
+    pub id: String,
+    /// The version ID this partial version inherits from
+    pub inherits_from: String,
+    /// The time that the version was released
+    pub release_time: DateTime<Utc>,
+    /// The latest time a file in this version was updated
+    pub time: DateTime<Utc>,
+    /// The classpath to the main class to launch the game
+    pub main_class: String,
+    /// Arguments passed to the game or JVM
+    pub arguments: Option<HashMap<ArgumentType, Vec<Argument>>>,
+    /// Libraries that the version depends on
+    pub libraries: Vec<Library>,
+    #[serde(rename = "type")]
+    /// The type of version
+    pub type_: VersionType,
+}
+
+/// Merges a partial version into a complete one
+pub fn merge_partial_version(partial: PartialVersionInfo, merge: VersionInfo) -> VersionInfo {
+    VersionInfo {
+        arguments: if let Some(partial_args) = partial.arguments {
+            if let Some(merge_args) = merge.arguments {
+                Some(partial_args.into_iter().chain(merge_args).collect())
+            } else {
+                Some(partial_args)
+            }
+        } else {
+            merge.arguments
+        },
+        asset_index: merge.asset_index,
+        assets: merge.assets,
+        downloads: merge.downloads,
+        id: merge.id,
+        libraries: partial
+            .libraries
+            .into_iter()
+            .chain(merge.libraries)
+            .collect::<Vec<_>>(),
+        main_class: partial.main_class,
+        minecraft_arguments: merge.minecraft_arguments,
+        minimum_launcher_version: merge.minimum_launcher_version,
+        release_time: partial.release_time,
+        time: partial.time,
+        type_: partial.type_,
+    }
+}
+
+/// The default servers for fabric meta
+pub const FABRIC_META_URL: &str = "https://meta.fabricmc.net/v2";
+
+/// Fetches the manifest of a fabric loader version and game version
+pub async fn fetch_fabric_version(
+    version_number: &str,
+    loader_version: &str,
+) -> Result<PartialVersionInfo, Error> {
+    Ok(serde_json::from_slice(
+        &download_file(
+            &*format!(
+                "{}/versions/loader/{}/{}/profile/json",
+                FABRIC_META_URL, version_number, loader_version
+            ),
+            None,
+        )
+        .await?,
+    )?)
+}
+
+/// Fetches the manifest of a game version's URL
+pub async fn fetch_fabric_game_version(url: &str) -> Result<PartialVersionInfo, Error> {
+    Ok(serde_json::from_slice(&download_file(url, None).await?)?)
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+/// Versions of fabric components
+pub struct FabricVersions {
+    /// Versions of Minecraft that fabric supports
+    pub game: Vec<FabricGameVersion>,
+    /// Available versions of the fabric loader
+    pub loader: Vec<FabricLoaderVersion>,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+/// A version of Minecraft that fabric supports
+pub struct FabricGameVersion {
+    /// The version number of the game
+    pub version: String,
+    /// Whether the Minecraft version is stable or not
+    pub stable: bool,
+    /// (Modrinth Provided) The URLs to download this version's profile with a loader
+    ///  The key of the map is the loader version, and the value is the URL
+    pub urls: Option<HashMap<String, String>>,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+/// A version of the fabric loader
+pub struct FabricLoaderVersion {
+    /// The separator to get the build number
+    pub separator: String,
+    /// The build number
+    pub build: u32,
+    /// The maven artifact
+    pub maven: String,
+    /// The version number of the fabric loader
+    pub version: String,
+    /// Whether the loader is stable or not
+    pub stable: bool,
+}
+/// Fetches the list of fabric versions
+pub async fn fetch_fabric_versions(url: Option<&str>) -> Result<FabricVersions, Error> {
+    Ok(serde_json::from_slice(
+        &download_file(
+            url.unwrap_or(&*format!("{}/versions", FABRIC_META_URL)),
+            None,
+        )
+        .await?,
+    )?)
+}

daedalus/src/lib.rs

@@ -4,6 +4,8 @@
 
 #![warn(missing_docs, unused_import_braces, missing_debug_implementations)]
 
+/// Models and methods for fetching metadata for the Fabric mod loader
+pub mod fabric;
 /// Models and methods for fetching metadata for Minecraft
 pub mod minecraft;
 
@@ -34,6 +36,32 @@ pub enum Error {
     /// There was an error when managing async tasks
     #[error("Error while managing asynchronous tasks")]
     TaskError(#[from] tokio::task::JoinError),
+    /// Error while parsing input
+    #[error("{0}")]
+    ParseError(String),
+}
+
+/// Converts a maven artifact to a path
+pub fn get_path_from_artifact(artifact: &str) -> Result<String, Error> {
+    let name_items = artifact.split(':').collect::<Vec<&str>>();
+
+    let package = name_items.get(0).ok_or_else(|| {
+        Error::ParseError(format!("Unable to find package for library {}", &artifact))
+    })?;
+    let name = name_items.get(1).ok_or_else(|| {
+        Error::ParseError(format!("Unable to find name for library {}", &artifact))
+    })?;
+    let version = name_items.get(2).ok_or_else(|| {
+        Error::ParseError(format!("Unable to find version for library {}", &artifact))
+    })?;
+
+    Ok(format!(
+        "{}/{}/{}-{}.jar",
+        package.replace(".", "/"),
+        version,
+        name,
+        version
+    ))
 }
 
 /// Downloads a file with retry and checksum functionality

daedalus/src/minecraft.rs

@@ -69,7 +69,7 @@ pub struct LatestVersion {
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
-/// Data of all game versions of Minecraft
+/// Data of all game versions of Minecrafat
 pub struct VersionManifest {
     /// A struct containing the latest snapshot and release of the game
     pub latest: LatestVersion,
@@ -181,10 +181,13 @@ pub enum Os {
 #[derive(Serialize, Deserialize, Debug)]
 /// A rule which depends on what OS the user is on
 pub struct OsRule {
+    #[serde(skip_serializing_if = "Option::is_none")]
     /// The name of the OS
     pub name: Option<Os>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     /// The version of the OS. This is normally a RegEx
     pub version: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     /// The architecture of the OS
     pub arch: Option<String>,
 }
@@ -192,8 +195,10 @@ pub struct OsRule {
 #[derive(Serialize, Deserialize, Debug)]
 /// A rule which depends on the toggled features of the launcher
 pub struct FeatureRule {
+    #[serde(skip_serializing_if = "Option::is_none")]
     /// Whether the user is in demo mode
     pub is_demo_user: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     /// Whether the user is using the demo resolution
     pub has_demo_resolution: Option<bool>,
 }
@@ -203,8 +208,10 @@ pub struct FeatureRule {
 pub struct Rule {
     /// The action the rule takes
     pub action: RuleAction,
+    #[serde(skip_serializing_if = "Option::is_none")]
     /// The OS rule
     pub os: Option<OsRule>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     /// The feature rule
     pub features: Option<FeatureRule>,
 }
@@ -212,6 +219,7 @@ pub struct Rule {
 #[derive(Serialize, Deserialize, Debug)]
 /// Information delegating the extraction of the library
 pub struct LibraryExtract {
+    #[serde(skip_serializing_if = "Option::is_none")]
     /// Files/Folders to be excluded from the extraction of the library
     pub exclude: Option<Vec<String>>,
 }
@@ -219,14 +227,21 @@ pub struct LibraryExtract {
 #[derive(Serialize, Deserialize, Debug)]
 /// A library which the game relies on to run
 pub struct Library {
+    #[serde(skip_serializing_if = "Option::is_none")]
     /// The files the library has
-    pub downloads: LibraryDownloads,
+    pub downloads: Option<LibraryDownloads>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     /// Rules of the extraction of the file
     pub extract: Option<LibraryExtract>,
     /// The maven name of the library. The format is `groupId:artifactId:version`
     pub name: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    /// The URL to the repository where the library can be downloaded
+    pub url: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     /// Native files that the library relies on
     pub natives: Option<HashMap<Os, String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     /// Rules deciding whether the library should be downloaded or not
     pub rules: Option<Vec<Rule>>,
 }
@@ -270,6 +285,7 @@ pub enum ArgumentType {
 #[serde(rename_all = "camelCase")]
 /// Information about a version
 pub struct VersionInfo {
+    #[serde(skip_serializing_if = "Option::is_none")]
     /// Arguments passed to the game or JVM
     pub arguments: Option<HashMap<ArgumentType, Vec<Argument>>>,
     /// Assets for the game
@@ -284,6 +300,7 @@ pub struct VersionInfo {
     pub libraries: Vec<Library>,
     /// The classpath to the main class to launch the game
     pub main_class: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
     /// (Legacy) Arguments passed to the game
     pub minecraft_arguments: Option<String>,
     /// The minimum version of the Minecraft Launcher that can run this version of the game