Support stash-apply,stash-drop

Author: Stephan Dilly

asyncgit/src/sync/commits_info.rs

@@ -3,6 +3,28 @@ use crate::error::Result;
 use git2::{Commit, Error, Oid};
 use scopetime::scope_time;
 
+/// identifies a single commit
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+pub struct CommitId(Oid);
+
+impl CommitId {
+    /// create new CommitId
+    pub fn new(id: Oid) -> Self {
+        Self(id)
+    }
+
+    ///
+    pub(crate) fn get_oid(self) -> Oid {
+        self.0
+    }
+}
+
+impl ToString for CommitId {
+    fn to_string(&self) -> String {
+        self.0.to_string()
+    }
+}
+
 ///
 #[derive(Debug)]
 pub struct CommitInfo {
@@ -13,7 +35,7 @@ pub struct CommitInfo {
     ///
     pub author: String,
     ///
-    pub hash: String,
+    pub id: CommitId,
 }
 
 ///
@@ -44,7 +66,7 @@ pub fn get_commits_info(
                 message,
                 author,
                 time: c.time().seconds(),
-                hash: c.id().to_string(),
+                id: CommitId(c.id()),
             }
         })
         .collect::<Vec<_>>();

asyncgit/src/sync/mod.rs

@@ -11,14 +11,14 @@ pub mod status;
 mod tags;
 pub mod utils;
 
-pub use commits_info::{get_commits_info, CommitInfo};
+pub use commits_info::{get_commits_info, CommitId, CommitInfo};
 pub use hooks::{hooks_commit_msg, hooks_post_commit, HookResult};
 pub use hunks::{stage_hunk, unstage_hunk};
 pub use logwalker::LogWalker;
 pub use reset::{
     reset_stage, reset_workdir_file, reset_workdir_folder,
 };
-pub use stash::stash_save;
+pub use stash::{get_stashes, stash_apply, stash_drop, stash_save};
 pub use tags::{get_tags, Tags};
 pub use utils::{
     commit, stage_add_all, stage_add_file, stage_addremoved,

asyncgit/src/sync/stash.rs

@@ -1,39 +1,71 @@
-use super::utils::repo;
-use crate::error::Result;
-use git2::{Oid, StashFlags};
+use super::{utils::repo, CommitId};
+use crate::error::{Error, Result};
+use git2::{Oid, Repository, StashFlags};
 use scopetime::scope_time;
 
 ///
-#[allow(dead_code)]
-pub struct StashItem {
-    pub msg: String,
-    index: usize,
-    id: Oid,
+pub fn get_stashes(repo_path: &str) -> Result<Vec<Oid>> {
+    scope_time!("get_stashes");
+
+    let mut repo = repo(repo_path)?;
+
+    let mut list = Vec::new();
+
+    repo.stash_foreach(|_index, _msg, id| {
+        list.push(*id);
+        true
+    })?;
+
+    Ok(list)
 }
 
 ///
-#[allow(dead_code)]
-pub struct StashItems(Vec<StashItem>);
+pub fn stash_drop(repo_path: &str, stash_id: CommitId) -> Result<()> {
+    scope_time!("stash_drop");
+
+    let mut repo = repo(repo_path)?;
+
+    let index = get_stash_index(&mut repo, stash_id.get_oid())?;
+
+    repo.stash_drop(index)?;
+
+    Ok(())
+}
 
 ///
-#[allow(dead_code)]
-pub fn get_stashes(repo_path: &str) -> Result<StashItems> {
-    scope_time!("get_stashes");
+pub fn stash_apply(
+    repo_path: &str,
+    stash_id: CommitId,
+) -> Result<()> {
+    scope_time!("stash_apply");
 
     let mut repo = repo(repo_path)?;
 
-    let mut list = Vec::new();
+    let index = get_stash_index(&mut repo, stash_id.get_oid())?;
 
-    repo.stash_foreach(|index, msg, id| {
-        list.push(StashItem {
-            msg: msg.to_string(),
-            index,
-            id: *id,
-        });
-        true
+    repo.stash_apply(index, None)?;
+
+    Ok(())
+}
+
+fn get_stash_index(
+    repo: &mut Repository,
+    stash_id: Oid,
+) -> Result<usize> {
+    let mut idx = None;
+
+    repo.stash_foreach(|index, _msg, id| {
+        if *id == stash_id {
+            idx = Some(index);
+            false
+        } else {
+            true
+        }
     })?;
 
-    Ok(StashItems(list))
+    idx.ok_or_else(|| {
+        Error::Generic("stash commit not found".to_string())
+    })
 }
 
 ///
@@ -66,7 +98,10 @@ pub fn stash_save(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::sync::tests::{get_statuses, repo_init};
+    use crate::sync::{
+        get_commits_info,
+        tests::{get_statuses, repo_init},
+    };
     use std::{fs::File, io::Write};
 
     #[test]
@@ -80,10 +115,7 @@ mod tests {
             false
         );
 
-        assert_eq!(
-            get_stashes(repo_path).unwrap().0.is_empty(),
-            true
-        );
+        assert_eq!(get_stashes(repo_path).unwrap().is_empty(), true);
     }
 
     #[test]
@@ -117,9 +149,28 @@ mod tests {
 
         let res = get_stashes(repo_path)?;
 
-        assert_eq!(res.0.len(), 1);
-        assert_eq!(res.0[0].msg, "On master: foo");
-        assert_eq!(res.0[0].index, 0);
+        assert_eq!(res.len(), 1);
+
+        let infos =
+            get_commits_info(repo_path, &[res[0]], 100).unwrap();
+
+        assert_eq!(infos[0].message, "On master: foo");
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_stash_nothing_untracked() -> Result<()> {
+        let (_td, repo) = repo_init().unwrap();
+        let root = repo.path().parent().unwrap();
+        let repo_path = root.as_os_str().to_str().unwrap();
+
+        File::create(&root.join("foo.txt"))?
+            .write_all(b"test\nfoo")?;
+
+        assert!(
+            stash_save(repo_path, Some("foo"), false, false).is_err()
+        );
 
         Ok(())
     }

asyncgit/src/sync/tags.rs

@@ -1,17 +1,17 @@
-use super::utils::repo;
+use super::{utils::repo, CommitId};
 use crate::error::Result;
 use scopetime::scope_time;
 use std::collections::HashMap;
 
 /// hashmap of tag target commit hash to tag names
-pub type Tags = HashMap<String, Vec<String>>;
+pub type Tags = HashMap<CommitId, Vec<String>>;
 
 /// returns `Tags` type filled with all tags found in repo
 pub fn get_tags(repo_path: &str) -> Result<Tags> {
     scope_time!("get_tags");
 
     let mut res = Tags::new();
-    let mut adder = |key: String, value: String| {
+    let mut adder = |key, value: String| {
         if let Some(key) = res.get_mut(&key) {
             key.push(value)
         } else {
@@ -26,9 +26,8 @@ pub fn get_tags(repo_path: &str) -> Result<Tags> {
             let obj = repo.revparse_single(name)?;
 
             if let Some(tag) = obj.as_tag() {
-                let target_hash = tag.target_id().to_string();
                 let tag_name = String::from(name);
-                adder(target_hash, tag_name);
+                adder(CommitId::new(tag.target_id()), tag_name);
             }
         }
     }
@@ -70,7 +69,7 @@ mod tests {
         repo.tag("b", &target, &sig, "", false).unwrap();
 
         assert_eq!(
-            get_tags(repo_path).unwrap()[&head_id.to_string()],
+            get_tags(repo_path).unwrap()[&CommitId::new(head_id)],
             vec!["a", "b"]
         );
     }