hacking

Author: Grant Wuerker

crates/resolver/Cargo.toml

@@ -15,3 +15,4 @@ toml = "0.8.13"
 serde = { version = "1", features = ["derive"] }
 git2 = "0.18.3"
 indexmap = "2.2"
+petgraph = "0.5.1"

crates/resolver/src/files.rs

@@ -1,14 +1,14 @@
 use camino::Utf8PathBuf;
-use git::GitDesc;
-use local::LocalDesc;
+use git::{GitDesc, GitResolutionError};
+use local::{LocalDesc, LocalResolutionError};
 use serde::Deserialize;
 
 use crate::Resolver;
 
 mod git;
 mod local;
 
-#[derive(Deserialize)]
+#[derive(Deserialize, Hash, Debug)]
 #[serde(untagged)]
 pub enum AnyFilesDesc {
     Local(LocalDesc),
@@ -18,8 +18,8 @@ pub enum AnyFilesDesc {
 pub struct AnyFilesResolver;
 
 pub enum AnyFilesResolutionError {
-    Local(local::LocalResolutionError),
-    Git(git::GitResolutionError),
+    Local(LocalResolutionError),
+    Git(GitResolutionError),
 }
 
 impl Resolver for AnyFilesResolver {

crates/resolver/src/files/git.rs

@@ -1,9 +1,11 @@
 use camino::Utf8PathBuf;
+use git2::{Error as Git2Error, FetchOptions, Oid, Repository};
 use serde::Deserialize;
+use std::fs;
 
 use crate::Resolver;
 
-#[derive(Deserialize)]
+#[derive(Deserialize, Hash, Debug, Clone)]
 pub struct GitDesc {
     remote: String,
     refspec: String,
@@ -14,7 +16,34 @@ pub struct GitResolver {
     pub default_clone_path: Utf8PathBuf,
 }
 
-pub struct GitResolutionError;
+#[derive(Debug)]
+pub enum GitResolutionError {
+    GitError(Git2Error),
+    IoError(std::io::Error),
+    InvalidOid,
+}
+
+impl From<Git2Error> for GitResolutionError {
+    fn from(error: Git2Error) -> Self {
+        GitResolutionError::GitError(error)
+    }
+}
+
+impl From<std::io::Error> for GitResolutionError {
+    fn from(error: std::io::Error) -> Self {
+        GitResolutionError::IoError(error)
+    }
+}
+
+impl std::fmt::Display for GitResolutionError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            GitResolutionError::GitError(e) => write!(f, "Git error: {}", e),
+            GitResolutionError::IoError(e) => write!(f, "IO error: {}", e),
+            GitResolutionError::InvalidOid => write!(f, "Invalid OID for refspec"),
+        }
+    }
+}
 
 impl Resolver for GitResolver {
     type Config = ();
@@ -23,72 +52,65 @@ impl Resolver for GitResolver {
     type ResolutionError = GitResolutionError;
 
     fn from_config(_: &Self::Config) -> Self {
-        todo!("")
+        todo!()
     }
 
     fn resolve(&self, desc: &GitDesc) -> Result<Utf8PathBuf, GitResolutionError> {
-        // check to see if the dep is already in the dep directory
-        // check to see if the repo is already cached on the local fs
-        // if it is, then check to see if the repo is valid with respect to the CID or refspec
-        // if the repo is not cached, clone it
-        // copy to dep directory
-        // resolve the repo path
-        todo!("")
+        let clone_path = if let Some(ref local_path) = desc.local_path {
+            Utf8PathBuf::from(local_path)
+        } else {
+            self.default_clone_path
+                .join(format!("{}_{}", &desc.remote, &desc.refspec))
+        };
+
+        if clone_path.exists() {
+            let repo = Repository::open(&clone_path).map_err(GitResolutionError::from)?;
+
+            if !repo.find_reference(&desc.refspec).is_ok() {
+                fs::remove_dir_all(&clone_path)?;
+                self.clone_repo(&desc.remote, &clone_path, &desc.refspec)?;
+            }
+        } else {
+            self.clone_repo(&desc.remote, &clone_path, &desc.refspec)?;
+        }
+
+        Ok(clone_path)
     }
 }
 
-// use git2::{FetchOptions, Oid, Repository};
-// use std::error::Error;
-// use std::path::Path;
-
-// /// Fetch and checkout the specified refspec from the remote repository without
-// /// fetching any additional history.
-// pub fn fetch_and_checkout<P: AsRef<Path>>(
-//     remote: &str,
-//     target_directory: P,
-//     refspec: &str,
-// ) -> Result<(), Box<dyn Error>> {
-//     // We initialize the repo here so that we can be sure that we created a directory that
-//     // needs to be clean up in case of an error. If the init fails, there won't be anything
-//     // to clean up.
-//     let repo = Repository::init(&target_directory)?;
-//     let res = _fetch_and_checkout(remote, repo, refspec);
-//     if res.is_err() {
-//         std::fs::remove_dir_all(target_directory).expect("Failed to clean up directory");
-//     }
-
-//     res
-// }
-
-// fn _fetch_and_checkout(
-//     remote: &str,
-//     repo: Repository,
-//     refspec: &str,
-// ) -> Result<(), Box<dyn Error>> {
-//     let mut remote = repo.remote("origin", remote)?;
-
-//     let mut fetch_options = FetchOptions::new();
-
-//     fetch_options.depth(1);
-
-//     // Fetch the specified SHA1 with depth 1
-//     if let Err(e) = remote.fetch(&[refspec], Some(&mut fetch_options), None) {
-//         if let (git2::ErrorClass::Net, git2::ErrorCode::GenericError) = (e.class(), e.code()) {
-//             // That's a pretty cryptic error for the common case of the refspec not existing.
-//             // We keep the cryptic error (because it might have other causes) but add a hint.
-//             return Err(format!("{}\nMake sure revision {} exists in remote", e, refspec).into());
-//         } else {
-//             return Err(e.into());
-//         }
-//     }
-
-//     // Find the fetched commit by SHA1
-//     let oid = Oid::from_str(refspec)?;
-//     let commit = repo.find_commit(oid)?;
-
-//     // Checkout the commit
-//     repo.checkout_tree(commit.as_object(), None)?;
-//     repo.set_head_detached(oid)?;
-
-//     Ok(())
-// }
+impl GitResolver {
+    fn clone_repo(
+        &self,
+        remote: &str,
+        target_directory: &Utf8PathBuf,
+        refspec: &str,
+    ) -> Result<(), GitResolutionError> {
+        let repo = Repository::init(target_directory)?;
+
+        self.fetch_and_checkout(remote, &repo, refspec)?;
+
+        Ok(())
+    }
+
+    fn fetch_and_checkout(
+        &self,
+        remote: &str,
+        repo: &Repository,
+        refspec: &str,
+    ) -> Result<(), GitResolutionError> {
+        let mut remote = repo.remote("origin", remote)?;
+
+        let mut fetch_options = FetchOptions::new();
+        fetch_options.depth(1);
+
+        remote.fetch(&[refspec], Some(&mut fetch_options), None)?;
+
+        let oid = Oid::from_str(refspec).map_err(|_| GitResolutionError::InvalidOid)?;
+        let commit = repo.find_commit(oid)?;
+
+        repo.checkout_tree(commit.as_object(), None)?;
+        repo.set_head_detached(oid)?;
+
+        Ok(())
+    }
+}

crates/resolver/src/files/local.rs

@@ -3,16 +3,16 @@ use serde::Deserialize;
 
 use super::Resolver;
 
-#[derive(Deserialize)]
+#[derive(Deserialize, Hash, Debug)]
 pub struct LocalDesc {
     pub path: String,
 }
 
 pub struct LocalResolver;
 
 pub enum LocalResolutionError {
-    Invalid,
-    DoesNotExist,
+    InvalidPath,
+    PathDoesNotExist,
 }
 
 impl Resolver for LocalResolver {
@@ -21,19 +21,19 @@ impl Resolver for LocalResolver {
     type Resource = Utf8PathBuf;
     type ResolutionError = LocalResolutionError;
 
-    fn from_config(config: &Self::Config) -> Self {
+    fn from_config(_: &Self::Config) -> Self {
         todo!()
     }
 
     fn resolve(&self, desc: &LocalDesc) -> Result<Utf8PathBuf, LocalResolutionError> {
         if let Ok(path) = Utf8PathBuf::try_from(desc.path.clone()) {
             if !path.exists() {
-                Err(LocalResolutionError::DoesNotExist)
+                Err(LocalResolutionError::PathDoesNotExist)
             } else {
                 Ok(path)
             }
         } else {
-            Err(LocalResolutionError::Invalid)
+            Err(LocalResolutionError::InvalidPath)
         }
     }
 }

crates/resolver/src/ingot.rs

@@ -1,17 +1,21 @@
 use serde::Deserialize;
 use smol_str::SmolStr;
+use std::hash::Hash;
 
 use crate::files::AnyFilesDesc;
 
 mod config;
+mod dep_graph;
 mod src_files;
 
-#[derive(Deserialize)]
-pub struct IngotDesc<FD> {
-    name: SmolStr,
-    version: Option<String>,
+#[derive(Deserialize, Hash, Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub struct IngotDesc<FD>
+where
+    FD: Hash,
+{
+    pub version: Option<SmolStr>,
     #[serde(flatten)]
-    files_desc: FD,
+    pub files_desc: FD,
 }
 
 pub type AnyIngotDesc = IngotDesc<AnyFilesDesc>;

crates/resolver/src/ingot/config.rs

@@ -1,16 +1,32 @@
+use camino::Utf8PathBuf;
+use serde::de::DeserializeOwned;
+use serde::Deserialize;
 use smol_str::SmolStr;
+use std::hash::Hash;
+use std::{collections::HashMap, fs};
+use toml;
 
 use crate::Resolver;
 
 use super::IngotDesc;
 
-pub struct Config<FD> {
+#[derive(Deserialize)]
+pub struct Config<FD>
+where
+    FD: Hash,
+{
     pub name: SmolStr,
     pub version: SmolStr,
-    dependencies: Vec<IngotDesc<FD>>,
+    pub dependencies: HashMap<SmolStr, IngotDesc<FD>>,
 }
 
-pub struct ConfigResolutionError;
+#[derive(Debug)]
+pub enum ConfigResolutionError {
+    FileNotFound,
+    FileReadError(std::io::Error),
+    TomlParseError(toml::de::Error),
+    InvalidConfig(String),
+}
 
 pub struct ConfigResolver<FR> {
     files_resolver: FR,
@@ -19,23 +35,48 @@ pub struct ConfigResolver<FR> {
 impl<FR> Resolver for ConfigResolver<FR>
 where
     FR: Resolver,
+    FR::ResourceDesc: Hash,
+    FR::Resource: AsRef<Utf8PathBuf>,
+    Config<FR::ResourceDesc>: DeserializeOwned,
 {
     type Config = ();
     type ResourceDesc = IngotDesc<FR::ResourceDesc>;
     type Resource = Config<FR::ResourceDesc>;
     type ResolutionError = ConfigResolutionError;
 
-    fn from_config(config: &Self::Config) -> Self {
+    fn from_config(_config: &Self::Config) -> Self {
         todo!()
     }
 
     fn resolve(
         &self,
         desc: &IngotDesc<FR::ResourceDesc>,
     ) -> Result<Config<FR::ResourceDesc>, ConfigResolutionError> {
-        // load the config file data
-        // parse the toml
-        // check toml content (version, features, etc)
-        //
+        let config_path = self
+            .files_resolver
+            .resolve(&desc.files_desc)
+            .map_err(|_| ConfigResolutionError::FileNotFound)?
+            .as_ref()
+            .join("fe.toml");
+
+        let file_content =
+            fs::read_to_string(&config_path).map_err(ConfigResolutionError::FileReadError)?;
+
+        let config: Config<FR::ResourceDesc> =
+            toml::from_str(&file_content).map_err(ConfigResolutionError::TomlParseError)?;
+
+        if config.name.is_empty() {
+            return Err(ConfigResolutionError::InvalidConfig(
+                "Invalid configuration: 'name' field is missing or empty.".to_string(),
+            ));
+        }
+
+        if config.version.is_empty() {
+            return Err(ConfigResolutionError::InvalidConfig(
+                "Invalid configuration: 'version' field is missing or empty.".to_string(),
+            ));
+        }
+
+        Ok(config)
     }
 }