Support Git dependencies

Cargo.toml

@@ -90,6 +90,7 @@ test-log = "0.2"
 fs4 = { version = "0.8.3", features = ["sync"] }
 ariadne = { version = "0.4.1", features = ["auto-color"] }
 clap_complete = { version = "4.5.4" }
+twox-hash = { version = "1.6.3" }
 
 [profile.release]
 debug = false

crates/mooncake/Cargo.toml

@@ -46,7 +46,11 @@ indexmap.workspace = true
 petgraph.workspace = true
 thiserror.workspace = true
 dunce.workspace = true
+git2 = "0.19.0"
+url = "2.5.2"
 
 [dev-dependencies]
 expect-test.workspace = true
 test-log.workspace = true
+tempfile.workspace = true
+copy_dir = "0.1.3"

crates/mooncake/src/dep_dir.rs

@@ -265,9 +265,7 @@ fn map_source_to_dir(dep_dir: &DepDir, module: &ModuleSource) -> PathBuf {
  pkg_to_dir(dep_dir, &module.name.username, &module.name.pkgname)
  }
  ModuleSourceKind::Local(path) => path.clone(),
- ModuleSourceKind::Git(url) => {
- todo!("Git dependency is not yet supported. Got git url: {}", url)
- }
+ ModuleSourceKind::Git(url) => crate::resolver::git::resolve(url).unwrap(),
  }
 }
 

crates/mooncake/src/resolver.rs

@@ -26,6 +26,7 @@ use thiserror::Error;
 use crate::registry::RegistryList;
 
 pub mod env;
+pub mod git;
 pub mod mvs;
 
 pub use mvs::MvsSolver;

crates/mooncake/src/resolver/env.rs

@@ -22,21 +22,23 @@ use std::{
  rc::Rc,
 };
 
+use anyhow::Context;
 use moonutil::{
  common::read_module_desc_file_in_dir,
  module::MoonMod,
- mooncakes::{ModuleName, ModuleSource, ModuleSourceKind},
+ mooncakes::{GitSource, ModuleName, ModuleSource, ModuleSourceKind},
 };
 use semver::Version;
 
 use crate::registry::RegistryList;
 
-use super::ResolverError;
+use super::{git::recursively_scan_for_moon_mods, ResolverError};
 
 pub struct ResolverEnv<'a> {
  registries: &'a RegistryList,
  errors: Vec<super::ResolverError>,
  local_module_cache: HashMap<PathBuf, Rc<MoonMod>>,
+ git_module_cache: HashMap<GitSource, HashMap<ModuleName, (PathBuf, Rc<MoonMod>)>>,
 }
 
 impl<'a> ResolverEnv<'a> {
@@ -45,6 +47,7 @@ impl<'a> ResolverEnv<'a> {
  registries,
  errors: Vec::new(),
  local_module_cache: HashMap::new(),
+ git_module_cache: HashMap::new(),
  }
  }
 
@@ -104,4 +107,44 @@ impl<'a> ResolverEnv<'a> {
  .insert(path.to_owned(), Rc::clone(&rc_module));
  Ok(rc_module)
  }
+
+ pub fn resolve_git_module(
+ &mut self,
+ git_info: &GitSource,
+ expected_name: &ModuleName,
+ ) -> Result<Rc<MoonMod>, ResolverError> {
+ // Check cache
+ if let Some(mods) = self.git_module_cache.get(git_info) {
+ if let Some((_, module)) = mods.get(expected_name) {
+ return Ok(module.clone());
+ }
+ }
+
+ let checkout = super::git::resolve(git_info)
+ .with_context(|| format!("Failed to resolve git source {}", git_info))
+ .map_err(ResolverError::Other)?;
+ let mods = recursively_scan_for_moon_mods(&checkout)
+ .with_context(|| format!("Failed to scan for moon mods in {}", checkout.display()))
+ .map_err(ResolverError::Other)?;
+
+ // populate cache
+ let mut mods_map = HashMap::new();
+ for (path, module) in mods {
+ mods_map.insert(
+ module.name.parse().map_err(|e| {
+ ResolverError::Other(anyhow::anyhow!("Failed to parse module name: {}", e))
+ })?,
+ (path, module.clone()),
+ );
+ }
+ let entry = self
+ .git_module_cache
+ .entry(git_info.clone())
+ .or_insert(mods_map);
+
+ entry
+ .get(expected_name)
+ .map(|(_, module)| module.clone())
+ .ok_or_else(|| ResolverError::ModuleMissing(expected_name.clone()))
+ }
 }