Add folder actions unstage/stage/reset

Author: Stephan Dilly

asyncgit/src/sync/diff.rs

@@ -238,7 +238,7 @@ fn new_file_content(path: &Path) -> String {
 mod tests {
     use super::get_diff;
     use crate::sync::{
-        stage_add,
+        stage_add_file,
         status::{get_status, StatusType},
         tests::{repo_init, repo_init_empty},
     };
@@ -288,7 +288,7 @@ mod tests {
             .write_all(b"test\nfoo")
             .unwrap();
 
-        assert_eq!(stage_add(repo_path, file_path), true);
+        assert_eq!(stage_add_file(repo_path, file_path), true);
 
         let diff = get_diff(
             repo_path,
@@ -347,7 +347,7 @@ mod tests {
         assert_eq!(res.len(), 1);
         assert_eq!(res[0].path, "bar.txt");
 
-        let res = stage_add(repo_path, Path::new("bar.txt"));
+        let res = stage_add_file(repo_path, Path::new("bar.txt"));
         assert_eq!(res, true);
         assert_eq!(get_status(repo_path, StatusType::Stage).len(), 1);
         assert_eq!(

asyncgit/src/sync/mod.rs

@@ -9,8 +9,12 @@ pub mod utils;
 
 pub use hooks::{hooks_commit_msg, hooks_post_commit, HookResult};
 pub use hunks::{stage_hunk, unstage_hunk};
-pub use reset::{reset_stage, reset_workdir};
-pub use utils::{commit, stage_add, stage_addremoved};
+pub use reset::{
+    reset_stage, reset_workdir_file, reset_workdir_folder,
+};
+pub use utils::{
+    commit, stage_add_all, stage_add_file, stage_addremoved,
+};
 
 #[cfg(test)]
 mod tests {

asyncgit/src/sync/reset.rs

@@ -26,14 +26,14 @@ pub fn reset_stage(repo_path: &str, path: &Path) -> bool {
 }
 
 ///
-pub fn reset_workdir(repo_path: &str, path: &Path) -> bool {
-    scope_time!("reset_workdir");
+pub fn reset_workdir_file(repo_path: &str, path: &str) -> bool {
+    scope_time!("reset_workdir_file");
 
     let repo = repo(repo_path);
 
     // Note: early out for removing untracked files, due to bug in checkout_head code:
     // see https://github.com/libgit2/libgit2/issues/5089
-    if let Ok(status) = repo.status_file(&path) {
+    if let Ok(status) = repo.status_file(Path::new(path)) {
         let removed_file_wd = if status == Status::WT_NEW
             || (status == Status::WT_MODIFIED | Status::INDEX_NEW)
         {
@@ -51,25 +51,44 @@ pub fn reset_workdir(repo_path: &str, path: &Path) -> bool {
             .update_index(true) // windows: needs this to be true WTF?!
             .allow_conflicts(true)
             .force()
-            .path(&path);
+            .path(path);
 
         repo.checkout_index(None, Some(&mut checkout_opts)).is_ok()
     } else {
         false
     }
 }
 
+///
+pub fn reset_workdir_folder(repo_path: &str, path: &str) -> bool {
+    scope_time!("reset_workdir_folder");
+
+    let repo = repo(repo_path);
+
+    let mut checkout_opts = CheckoutBuilder::new();
+    checkout_opts
+        .update_index(true) // windows: needs this to be true WTF?!
+        .allow_conflicts(true)
+        .remove_untracked(true)
+        .force()
+        .path(path);
+
+    repo.checkout_index(None, Some(&mut checkout_opts)).is_ok()
+}
+
 #[cfg(test)]
 mod tests {
-    use super::{reset_stage, reset_workdir};
+    use super::{
+        reset_stage, reset_workdir_file, reset_workdir_folder,
+    };
     use crate::sync::{
         status::{get_status, StatusType},
         tests::{debug_cmd_print, repo_init, repo_init_empty},
-        utils::stage_add,
+        utils::{commit, stage_add_all, stage_add_file},
     };
     use std::{
         fs::{self, File},
-        io::Write,
+        io::{Error, Write},
         path::Path,
     };
 
@@ -119,7 +138,7 @@ mod tests {
 
         debug_cmd_print(repo_path, "git status");
 
-        stage_add(repo_path, Path::new("bar.txt"));
+        stage_add_file(repo_path, Path::new("bar.txt"));
 
         debug_cmd_print(repo_path, "git status");
 
@@ -139,7 +158,7 @@ mod tests {
             1
         );
 
-        let res = reset_workdir(repo_path, Path::new("bar.txt"));
+        let res = reset_workdir_file(repo_path, "bar.txt");
         assert_eq!(res, true);
 
         debug_cmd_print(repo_path, "git status");
@@ -172,7 +191,7 @@ mod tests {
             1
         );
 
-        let res = reset_workdir(repo_path, Path::new("foo/bar.txt"));
+        let res = reset_workdir_file(repo_path, "foo/bar.txt");
         assert_eq!(res, true);
 
         debug_cmd_print(repo_path, "git status");
@@ -183,6 +202,56 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_reset_folder() -> Result<(), Error> {
+        let (_td, repo) = repo_init();
+        let root = repo.path().parent().unwrap();
+        let repo_path = root.as_os_str().to_str().unwrap();
+
+        {
+            fs::create_dir(&root.join("foo"))?;
+            File::create(&root.join("foo/file1.txt"))?
+                .write_all(b"file1")?;
+            File::create(&root.join("foo/file2.txt"))?
+                .write_all(b"file1")?;
+            File::create(&root.join("file3.txt"))?
+                .write_all(b"file3")?;
+        }
+
+        assert!(stage_add_all(repo_path, "*"));
+        commit(repo_path, "msg");
+
+        {
+            File::create(&root.join("foo/file1.txt"))?
+                .write_all(b"file1\nadded line")?;
+            fs::remove_file(&root.join("foo/file2.txt"))?;
+            File::create(&root.join("foo/file4.txt"))?
+                .write_all(b"file4")?;
+            File::create(&root.join("foo/file5.txt"))?
+                .write_all(b"file5")?;
+            File::create(&root.join("file3.txt"))?
+                .write_all(b"file3\nadded line")?;
+        }
+
+        stage_add_file(repo_path, Path::new("foo/file5.txt"));
+
+        assert_eq!(
+            get_status(repo_path, StatusType::WorkingDir).len(),
+            4
+        );
+        assert_eq!(get_status(repo_path, StatusType::Stage).len(), 1);
+
+        assert!(reset_workdir_folder(repo_path, "foo"));
+
+        assert_eq!(
+            get_status(repo_path, StatusType::WorkingDir).len(),
+            1
+        );
+        assert_eq!(get_status(repo_path, StatusType::Stage).len(), 1);
+
+        Ok(())
+    }
+
     #[test]
     fn test_reset_untracked_in_subdir_and_index() {
         let (_td, repo) = repo_init();
@@ -219,7 +288,7 @@ mod tests {
             1
         );
 
-        let res = reset_workdir(repo_path, Path::new(file));
+        let res = reset_workdir_file(repo_path, file);
         assert_eq!(res, true);
 
         debug_cmd_print(repo_path, "git status");
@@ -243,7 +312,7 @@ mod tests {
             .write_all(b"test\nfoo")
             .unwrap();
 
-        assert_eq!(stage_add(repo_path, file_path), true);
+        assert_eq!(stage_add_file(repo_path, file_path), true);
 
         assert_eq!(reset_stage(repo_path, file_path), true);
     }

asyncgit/src/sync/utils.rs

@@ -1,6 +1,6 @@
 //! sync git api (various methods)
 
-use git2::{Repository, RepositoryOpenFlags};
+use git2::{IndexAddOption, Repository, RepositoryOpenFlags};
 use scopetime::scope_time;
 use std::path::Path;
 
@@ -63,8 +63,8 @@ pub fn commit(repo_path: &str, msg: &str) {
 }
 
 /// add a file diff from workingdir to stage (will not add removed files see `stage_addremoved`)
-pub fn stage_add(repo_path: &str, path: &Path) -> bool {
-    scope_time!("stage_add");
+pub fn stage_add_file(repo_path: &str, path: &Path) -> bool {
+    scope_time!("stage_add_file");
 
     let repo = repo(repo_path);
 
@@ -78,6 +78,25 @@ pub fn stage_add(repo_path: &str, path: &Path) -> bool {
     false
 }
 
+/// like `stage_add_file` but uses a pattern to match/glob multiple files/folders
+pub fn stage_add_all(repo_path: &str, pattern: &str) -> bool {
+    scope_time!("stage_add_all");
+
+    let repo = repo(repo_path);
+
+    let mut index = repo.index().unwrap();
+
+    if index
+        .add_all(vec![pattern], IndexAddOption::DEFAULT, None)
+        .is_ok()
+    {
+        index.write().unwrap();
+        return true;
+    }
+
+    false
+}
+
 /// stage a removed file
 pub fn stage_addremoved(repo_path: &str, path: &Path) -> bool {
     scope_time!("stage_addremoved");
@@ -98,13 +117,12 @@ pub fn stage_addremoved(repo_path: &str, path: &Path) -> bool {
 mod tests {
     use super::*;
     use crate::sync::{
-        stage_add,
         status::{get_status, StatusType},
         tests::{repo_init, repo_init_empty},
     };
     use std::{
-        fs::{remove_file, File},
-        io::Write,
+        fs::{self, remove_file, File},
+        io::{Error, Write},
         path::Path,
     };
 
@@ -126,7 +144,7 @@ mod tests {
 
         assert_eq!(status_count(StatusType::WorkingDir), 1);
 
-        assert_eq!(stage_add(repo_path, file_path), true);
+        assert_eq!(stage_add_file(repo_path, file_path), true);
 
         assert_eq!(status_count(StatusType::WorkingDir), 0);
         assert_eq!(status_count(StatusType::Stage), 1);
@@ -149,7 +167,7 @@ mod tests {
             .write_all(b"test\nfoo")
             .unwrap();
 
-        assert_eq!(stage_add(repo_path, file_path), true);
+        assert_eq!(stage_add_file(repo_path, file_path), true);
 
         commit(repo_path, "commit msg");
     }
@@ -161,7 +179,7 @@ mod tests {
         let root = repo.path().parent().unwrap();
         let repo_path = root.as_os_str().to_str().unwrap();
 
-        assert_eq!(stage_add(repo_path, file_path), false);
+        assert_eq!(stage_add_file(repo_path, file_path), false);
     }
 
     #[test]
@@ -187,12 +205,40 @@ mod tests {
 
         assert_eq!(status_count(StatusType::WorkingDir), 2);
 
-        assert_eq!(stage_add(repo_path, file_path), true);
+        assert_eq!(stage_add_file(repo_path, file_path), true);
 
         assert_eq!(status_count(StatusType::WorkingDir), 1);
         assert_eq!(status_count(StatusType::Stage), 1);
     }
 
+    #[test]
+    fn test_staging_folder() -> Result<(), Error> {
+        let (_td, repo) = repo_init();
+        let root = repo.path().parent().unwrap();
+        let repo_path = root.as_os_str().to_str().unwrap();
+
+        let status_count = |s: StatusType| -> usize {
+            get_status(repo_path, s).len()
+        };
+
+        fs::create_dir_all(&root.join("a/d"))?;
+        File::create(&root.join(Path::new("a/d/f1.txt")))?
+            .write_all(b"foo")?;
+        File::create(&root.join(Path::new("a/d/f2.txt")))?
+            .write_all(b"foo")?;
+        File::create(&root.join(Path::new("a/f3.txt")))?
+            .write_all(b"foo")?;
+
+        assert_eq!(status_count(StatusType::WorkingDir), 3);
+
+        assert_eq!(stage_add_all(repo_path, "a/d"), true);
+
+        assert_eq!(status_count(StatusType::WorkingDir), 1);
+        assert_eq!(status_count(StatusType::Stage), 2);
+
+        Ok(())
+    }
+
     #[test]
     fn test_staging_deleted_file() {
         let file_path = Path::new("file1.txt");
@@ -211,7 +257,7 @@ mod tests {
             .write_all(b"test file1 content")
             .unwrap();
 
-        assert_eq!(stage_add(repo_path, file_path), true);
+        assert_eq!(stage_add_file(repo_path, file_path), true);
 
         commit(repo_path, "commit msg");