stashing support (#70)

Author: Stephan Dilly

assets/stashing.drawio

@@ -0,0 +1 @@
+<mxfile host="app.diagrams.net" modified="2020-05-19T12:41:55.023Z" agent="5.0 (Macintosh; Intel Mac OS X 10_15_4) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/13.1 Safari/605.1.15" etag="G_7kN2nuUboj_f0S3bPh" version="13.1.3" type="device" pages="2"><diagram id="hAseTAaTBIQ-p2lVXsqS" name="Page-1">7Vlbk5owFP41zLQPO0NAUB+97LZ92Je1l+coEegGQiGu2l/f3CBEcNzuiLK2L5p8JyTk+87JSYLlzpLdpxxm0SMJELYcO9hZ7txynOHIZ78c2EvAc8cSCPM4kBDQwCL+jRRoK3QTB6gwGlJCMI0zE1yRNEUramAwz8nWbLYm2Bw1gyFqAIsVxE30RxzQSKIjZ6jxzygOo3Jk4Kv5JbBsrGZSRDAg2xrk3lvuLCeEylKymyHMuSt5kc89HLFWL5ajlL7mgadvOMToyV8+foFPYA6+D4Y/71QvLxBv1ITVy9J9yUBONmmAeCe25U63UUzRIoMrbt0yyRkW0QSzGmBF1R3KKdodfU9QzZ55DSIJovmeNSkfsBVhpceo6lbT7/oKi2rUOyUIleRh1bVmhRUUMX9BktNDkoBJ0qhJUuV4BkmgK5LcBkkLCummaFDFJk1NPgqak2c0I5jkDElJylpO1zHGBxDEcZiy6oqRhBg+5RTGLFYnypDEQcCHaRXAlKgDDVocddAmQVcKDNoUKKI4DXuqwZqkdKFeCpxDEO+kIK0LR1eC+E1B4AvqqRgdBIQzvnJEjPu3cA/8Yc+yWylar1gamiy1pDe31ZM6S2+guVO69fx2KMK18xto24f5mJNdZDBl5ZCKmUtsWQIiC7IzhMLZ2MvDtgwzu+ilpvV8aZ9BYO+0wBfNl6C5h4yYdJbDurO/xgmSpcmGRoxiURbapjDpIqtitKa9C8K2jf5lo7C5zZxkGd6boVhTwv+14Ufc6UqyPGHGPFzCD+wFbSlia+kjL3IKbe72d2uYxGwQ8XhCUlII3o0mhbg84A3sbKfH1UHtHV5TeGzeHBWH8KpW8uAJJhgy52X+Yh6fucfoO9UWVG1Lqd/UjaO7kXRXljL3lGZJd2UWzs9q0v05DES1HgIcFR7PDToMDFiGAofU+sVBMyC4UYUEN9aCgltEWHC8DAwO2gKpzU0GyGvYq0wVcTpkPB40uiXQTNt7jXs1WAZRZRrUTCqWtBQ1Gyw0HtaGP1RVVCtp66DpcKpdwzPfU27qYKm7+vEBeI2lbp6T7HYV8MBpBbyLKtA8Qj/EGIFbzfavuda7bAgMWwVonhBvVIDqMvp6Coz+b4pPZYrrq1R2fLZLlAO+z0BadWFyfG2pvL/O2bgzzlo+PnnTneXNBW/Cye1NSnO4euY7x9v05bfK0p0rt1yzNGRh/+G/o0nb+nJhUVo/r8lrrVvdjTqnv69ddDPqvOsPbGe5MASXujC01BlZ22qnY/f+Dw==</diagram><diagram id="o9nFayAMEWxc9pClOnIG" name="Page-2">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</diagram></mxfile>

asyncgit/src/lib.rs

@@ -8,12 +8,14 @@ mod diff;
 mod error;
 mod revlog;
 mod status;
+mod status2;
 pub mod sync;
 
 pub use crate::{
     diff::{AsyncDiff, DiffParams},
     revlog::AsyncLog,
     status::AsyncStatus,
+    status2::{AsyncStatus2, StatusParams},
     sync::{
         diff::{DiffLine, DiffLineType, FileDiff},
         status::{StatusItem, StatusItemType},

asyncgit/src/status2.rs

@@ -0,0 +1,160 @@
+use crate::{
+    current_tick, error::Result, hash, sync, AsyncNotification,
+    StatusItem, CWD,
+};
+use crossbeam_channel::Sender;
+use log::trace;
+use std::{
+    hash::Hash,
+    sync::{
+        atomic::{AtomicUsize, Ordering},
+        Arc, Mutex,
+    },
+};
+use sync::status::StatusType;
+
+#[derive(Default, Hash, Clone)]
+pub struct Status2 {
+    pub items: Vec<StatusItem>,
+}
+
+///
+#[derive(Default, Hash, Clone, PartialEq)]
+pub struct StatusParams {
+    tick: u64,
+    status_type: StatusType,
+    include_untracked: bool,
+}
+
+impl StatusParams {
+    ///
+    pub fn new(
+        status_type: StatusType,
+        include_untracked: bool,
+    ) -> Self {
+        Self {
+            tick: current_tick(),
+            status_type,
+            include_untracked,
+        }
+    }
+}
+
+struct Request<R, A>(R, Option<A>);
+
+///TODO: merge functionality with AsyncStatus
+pub struct AsyncStatus2 {
+    current: Arc<Mutex<Request<u64, Status2>>>,
+    last: Arc<Mutex<Status2>>,
+    sender: Sender<AsyncNotification>,
+    pending: Arc<AtomicUsize>,
+}
+
+impl AsyncStatus2 {
+    ///
+    pub fn new(sender: Sender<AsyncNotification>) -> Self {
+        Self {
+            current: Arc::new(Mutex::new(Request(0, None))),
+            last: Arc::new(Mutex::new(Status2::default())),
+            sender,
+            pending: Arc::new(AtomicUsize::new(0)),
+        }
+    }
+
+    ///
+    pub fn last(&mut self) -> Result<Status2> {
+        let last = self.last.lock()?;
+        Ok(last.clone())
+    }
+
+    ///
+    pub fn is_pending(&self) -> bool {
+        self.pending.load(Ordering::Relaxed) > 0
+    }
+
+    ///
+    pub fn fetch(
+        &mut self,
+        params: StatusParams,
+    ) -> Result<Option<Status2>> {
+        let hash_request = hash(&params);
+
+        trace!("request: [hash: {}]", hash_request);
+
+        {
+            let mut current = self.current.lock()?;
+
+            if current.0 == hash_request {
+                return Ok(current.1.clone());
+            }
+
+            current.0 = hash_request;
+            current.1 = None;
+        }
+
+        let arc_current = Arc::clone(&self.current);
+        let arc_last = Arc::clone(&self.last);
+        let sender = self.sender.clone();
+        let arc_pending = Arc::clone(&self.pending);
+        let status_type = params.status_type;
+        let include_untracked = params.include_untracked;
+        rayon_core::spawn(move || {
+            arc_pending.fetch_add(1, Ordering::Relaxed);
+
+            Self::fetch_helper(
+                status_type,
+                include_untracked,
+                hash_request,
+                arc_current,
+                arc_last,
+            )
+            .expect("failed to fetch status");
+
+            arc_pending.fetch_sub(1, Ordering::Relaxed);
+
+            sender
+                .send(AsyncNotification::Status)
+                .expect("error sending status");
+        });
+
+        Ok(None)
+    }
+
+    fn fetch_helper(
+        status_type: StatusType,
+        include_untracked: bool,
+        hash_request: u64,
+        arc_current: Arc<Mutex<Request<u64, Status2>>>,
+        arc_last: Arc<Mutex<Status2>>,
+    ) -> Result<()> {
+        let res = Self::get_status(status_type, include_untracked)?;
+        trace!("status fetched: {}", hash(&res));
+
+        {
+            let mut current = arc_current.lock()?;
+            if current.0 == hash_request {
+                current.1 = Some(res.clone());
+            }
+        }
+
+        {
+            let mut last = arc_last.lock()?;
+            *last = res;
+        }
+
+        Ok(())
+    }
+
+    fn get_status(
+        status_type: StatusType,
+        include_untracked: bool,
+    ) -> Result<Status2> {
+        Ok(Status2 {
+            items: sync::status::get_status_new(
+                CWD,
+                status_type,
+                include_untracked,
+            )?,
+        })
+    }
+}

asyncgit/src/sync/mod.rs

@@ -6,6 +6,7 @@ mod hooks;
 mod hunks;
 mod logwalker;
 mod reset;
+mod stash;
 pub mod status;
 mod tags;
 pub mod utils;
@@ -17,6 +18,7 @@ pub use logwalker::LogWalker;
 pub use reset::{
     reset_stage, reset_workdir_file, reset_workdir_folder,
 };
+pub use stash::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

@@ -0,0 +1,124 @@
+#![allow(dead_code)]
+use super::utils::repo;
+use crate::error::Result;
+use git2::{Oid, StashFlags};
+use scopetime::scope_time;
+
+///
+pub struct StashItem {
+    pub msg: String,
+    index: usize,
+    id: Oid,
+}
+
+///
+pub struct StashItems(Vec<StashItem>);
+
+///
+pub fn get_stashes(repo_path: &str) -> Result<StashItems> {
+    scope_time!("get_stashes");
+
+    let mut repo = repo(repo_path)?;
+
+    let mut list = Vec::new();
+
+    repo.stash_foreach(|index, msg, id| {
+        list.push(StashItem {
+            msg: msg.to_string(),
+            index,
+            id: *id,
+        });
+        true
+    })?;
+
+    Ok(StashItems(list))
+}
+
+///
+pub fn stash_save(
+    repo_path: &str,
+    message: Option<&str>,
+    include_untracked: bool,
+    keep_index: bool,
+) -> Result<()> {
+    scope_time!("stash_save");
+
+    let mut repo = repo(repo_path)?;
+
+    let sig = repo.signature()?;
+
+    let mut options = StashFlags::DEFAULT;
+
+    if include_untracked {
+        options.insert(StashFlags::INCLUDE_UNTRACKED);
+    }
+    if keep_index {
+        options.insert(StashFlags::KEEP_INDEX)
+    }
+
+    repo.stash_save2(&sig, message, Some(options))?;
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::sync::tests::{get_statuses, repo_init};
+    use std::{fs::File, io::Write};
+
+    #[test]
+    fn test_smoke() {
+        let (_td, repo) = repo_init().unwrap();
+        let root = repo.path().parent().unwrap();
+        let repo_path = root.as_os_str().to_str().unwrap();
+
+        assert_eq!(
+            stash_save(repo_path, None, true, false).is_ok(),
+            false
+        );
+
+        assert_eq!(
+            get_stashes(repo_path).unwrap().0.is_empty(),
+            true
+        );
+    }
+
+    #[test]
+    fn test_stashing() -> 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_eq!(get_statuses(repo_path), (1, 0));
+
+        stash_save(repo_path, None, true, false)?;
+
+        assert_eq!(get_statuses(repo_path), (0, 0));
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_stashes() -> 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")?;
+
+        stash_save(repo_path, Some("foo"), true, false)?;
+
+        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);
+
+        Ok(())
+    }
+}

asyncgit/src/sync/status.rs

@@ -46,36 +46,54 @@ pub struct StatusItem {
 }
 
 ///
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, Hash, PartialEq)]
 pub enum StatusType {
     ///
     WorkingDir,
     ///
     Stage,
+    ///
+    Both,
+}
+
+impl Default for StatusType {
+    fn default() -> Self {
+        StatusType::WorkingDir
+    }
 }
 
 impl Into<StatusShow> for StatusType {
     fn into(self) -> StatusShow {
         match self {
             StatusType::WorkingDir => StatusShow::Workdir,
             StatusType::Stage => StatusShow::Index,
+            StatusType::Both => StatusShow::IndexAndWorkdir,
         }
     }
 }
 
-///
+/// TODO: migrate
 pub fn get_status(
     repo_path: &str,
     status_type: StatusType,
 ) -> Result<Vec<StatusItem>> {
-    scope_time!("get_index");
+    get_status_new(repo_path, status_type, true)
+}
+
+/// TODO: migrate
+pub fn get_status_new(
+    repo_path: &str,
+    status_type: StatusType,
+    include_untracked: bool,
+) -> Result<Vec<StatusItem>> {
+    scope_time!("get_status");
 
     let repo = utils::repo(repo_path)?;
 
     let statuses = repo.statuses(Some(
         StatusOptions::default()
             .show(status_type.into())
-            .include_untracked(true)
+            .include_untracked(include_untracked)
             .renames_head_to_index(true)
             .recurse_untracked_dirs(true),
     ))?;