Added Downloading different mod loaders from modrinth. Pending curseforge implementation

Author: JayanAXHF

Cargo.lock

@@ -14,10 +14,14 @@ hex = "0.4.3"
 hmac-sha512 = "1.1.7"
 inquire = "0.7.5"
 itertools = "0.14.0"
+percent-encoding = "2.3.1"
+pretty_assertions = { version = "1.4.1" }
 reqwest = "0.12.18"
 serde = { version = "1.0.219", features = ["derive"] }
 serde_json = "1.0.140"
+strum = { version = "0.27.1", features = ["derive"] }
 tabwriter = "1.4.1"
+tempfile = "3.20.0"
 thiserror = "2.0.12"
 tokio = { version = "1.45.1", features = ["full", "rt-multi-thread"] }
 tracing = "0.1.41"

core/Cargo.toml

@@ -1,5 +1,8 @@
 use clap::{Parser, Subcommand};
 use std::{fmt::Display, path::PathBuf};
+use strum::EnumIter;
+
+use crate::ModLoader;
 
 /// Modder is a tool for managing mods for Minecraft.
 /// It can add mods from Modrinth and Github.
@@ -39,6 +42,12 @@ pub enum Commands {
         /// Github token for any mods nested in a github repo.
         #[arg(short, long)]
         token: Option<String>,
+        /// Mod Loader
+        #[arg(short, long, default_value_t= ModLoader::Fabric)]
+        loader: ModLoader,
+        /// The directory to update mods in
+        #[arg( default_value_os_t = PathBuf::from("./"))]
+        dir: PathBuf,
     },
     /// Bulk-update a directory of mods to the specified version
     #[command(arg_required_else_help = true)]
@@ -54,6 +63,14 @@ pub enum Commands {
         /// Github token for any mods nested in a github repo.
         #[arg(short, long)]
         token: Option<String>,
+        /// Where to download the mod from
+        #[arg(short, long)]
+        source: Option<Source>,
+        /// Don't check other sources if the mod is not found on <source>
+        #[arg(long, default_value_t = true)]
+        other_sources: bool,
+        #[arg(short, long)]
+        loader: Option<ModLoader>,
     },
     /// Quickly add mods from a curated list to the supplied directory (defaults to current directory)
     QuickAdd {
@@ -63,15 +80,9 @@ pub enum Commands {
         /// Find top `limit` mods from Modrinth
         #[arg(short, long, default_value_t = 100)]
         limit: u16,
-    },
-    /// All the other options, just run in the minecraft directory
-    InPlace {
-        /// The game version to add this mod for
-        #[arg(short, long)]
-        version: Option<String>,
-        /// Passed down to the quick add command
-        #[arg(short, long, default_value_t = 100)]
-        limit: u16,
+        /// The mod loader to use
+        #[arg(short, long, default_value_t = ModLoader::Fabric)]
+        loader: ModLoader,
     },
     /// Toggle a mod in the supplied directory (defaults to current directory)
     Toggle {
@@ -99,26 +110,27 @@ impl Display for Commands {
             Commands::QuickAdd { .. } => "Quick Add".to_string(),
             Commands::Update { .. } => "Update".to_string(),
             Commands::Add { .. } => "Add".to_string(),
-            Commands::InPlace { .. } => "Edit Minecraft Directory".to_string(),
             Commands::Toggle { .. } => "Toggle".to_string(),
             Commands::List { .. } => "List".to_string(),
         };
         write!(f, "{}", text)
     }
 }
 
-#[derive(Debug, Clone, clap::ValueEnum, PartialEq, Default, Hash, Eq)]
+#[derive(Debug, Clone, clap::ValueEnum, PartialEq, Default, Hash, Eq, EnumIter)]
 pub enum Source {
     #[default]
     Modrinth,
     Github,
+    CurseForge,
 }
 
 impl Display for Source {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let text = match self {
             Source::Modrinth => "modrinth".to_string(),
             Source::Github => "github".to_string(),
+            Source::CurseForge => "curseforge".to_string(),
         };
         write!(f, "{}", text)
     }

core/src/actions.rs

@@ -0,0 +1,47 @@
+use std::fs::File;
+use std::io::{self, Read};
+use std::path::Path;
+
+/// Reads the entire content of a file into a byte vector.
+///
+/// # Arguments
+/// * `jar_file_path` - The path to the file to read.
+///
+/// # Returns
+/// A `Result` which is `Ok(Vec<u8>)` on success, or `Err(std::io::Error)` if an error occurs
+/// during file opening or reading.
+pub fn get_jar_contents(jar_file_path: &Path) -> io::Result<Vec<u8>> {
+    let mut file = File::open(jar_file_path)?;
+    let mut buffer = Vec::new();
+    file.read_to_end(&mut buffer)?;
+    Ok(buffer)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use pretty_assertions::assert_eq;
+    use std::io::Write;
+    use tempfile::NamedTempFile;
+
+    #[test]
+    fn test_get_jar_contents() {
+        let content = b"This is some test content.";
+        let mut temp_file = NamedTempFile::new().expect("Failed to create temp file");
+        temp_file
+            .write_all(content)
+            .expect("Failed to write to temp file");
+        let path = temp_file.path();
+
+        let read_content = get_jar_contents(path).expect("Failed to read jar contents");
+        assert_eq!(read_content, content);
+    }
+
+    #[test]
+    fn test_get_jar_contents_non_existent_file() {
+        let path = Path::new("non_existent_file.jar");
+        let result = get_jar_contents(path);
+        assert!(result.is_err());
+        assert_eq!(result.unwrap_err().kind(), io::ErrorKind::NotFound);
+    }
+}

core/src/cli.rs

@@ -0,0 +1,57 @@
+//! Ported from https://github.com/meza/curseforge-fingerprint/blob/b15012c026c56ca89fad90f8cf9a8e140616e2c0/src/addon/fingerprint.cpp
+#![allow(clippy::let_and_return)]
+pub struct MurmurHash2;
+
+const MULTIPLEX: u32 = 1540483477;
+
+impl MurmurHash2 {
+    pub fn hash(data: &[u8]) -> u32 {
+        let n_length = MurmurHash2::normalise(data);
+        let mut seed = 1_u32 ^ n_length;
+        let mut num_1 = 0;
+        let mut num_2 = 0;
+        for c in data.iter().filter(|&c| !is_whitespace(*c)) {
+            num_1 |= (*c as u32) << num_2;
+            num_2 += 8;
+            if num_2 == 32 {
+                seed = seed.wrapping_mul(MULTIPLEX) ^ MurmurHash2::mix(num_1);
+                num_1 = 0;
+                num_2 = 0;
+            }
+        }
+        if num_2 > 0 {
+            seed = (seed ^ num_1).wrapping_mul(MULTIPLEX);
+        }
+        let hash = (seed ^ (seed >> 13)).wrapping_mul(MULTIPLEX);
+        hash ^ (hash >> 15)
+    }
+    #[inline]
+    const fn mix(num_1: u32) -> u32 {
+        let num_3 = num_1.wrapping_mul(MULTIPLEX);
+        let num_4 = (num_3 ^ (num_3 >> 24)).wrapping_mul(MULTIPLEX);
+        num_4
+    }
+    fn normalise(data: &[u8]) -> u32 {
+        let mut n_len = 0;
+        data.iter()
+            .filter(|&c| !is_whitespace(*c))
+            .for_each(|_| n_len += 1);
+        n_len
+    }
+}
+
+fn is_whitespace(c: u8) -> bool {
+    c == b' ' || c == b'\t' || c == b'\r' || c == b'\n'
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use pretty_assertions::assert_eq;
+    #[test]
+    fn test_murmur_hash() {
+        let file = "Hello world";
+        let hash = MurmurHash2::hash(file.as_bytes());
+        assert_eq!(hash, 1423925525);
+    }
+}