cleanup having two AsyncStatus

Author: Stephan Dilly

asyncgit/src/lib.rs

@@ -8,14 +8,12 @@ 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},
+    status::{AsyncStatus, StatusParams},
     sync::{
         diff::{DiffLine, DiffLineType, FileDiff},
         status::{StatusItem, StatusItemType},
@@ -25,7 +23,6 @@ pub use crate::{
 use std::{
     collections::hash_map::DefaultHasher,
     hash::{Hash, Hasher},
-    time::{SystemTime, UNIX_EPOCH},
 };
 
 /// this type is used to communicate events back through the channel
@@ -48,11 +45,3 @@ pub fn hash<T: Hash + ?Sized>(v: &T) -> u64 {
     v.hash(&mut hasher);
     hasher.finish()
 }
-
-/// helper function to return the current tick since unix epoch
-pub fn current_tick() -> u64 {
-    SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .unwrap()
-        .as_millis() as u64
-}

asyncgit/src/status.rs

@@ -1,6 +1,5 @@
 use crate::{
-    error::Result, hash, sync, sync::status::StatusType,
-    AsyncNotification, StatusItem, CWD,
+    error::Result, hash, sync, AsyncNotification, StatusItem, CWD,
 };
 use crossbeam_channel::Sender;
 use log::trace;
@@ -10,12 +9,42 @@ use std::{
         atomic::{AtomicUsize, Ordering},
         Arc, Mutex,
     },
+    time::{SystemTime, UNIX_EPOCH},
 };
+use sync::status::StatusType;
+
+fn current_tick() -> u64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap()
+        .as_millis() as u64
+}
 
 #[derive(Default, Hash, Clone)]
 pub struct Status {
-    pub work_dir: Vec<StatusItem>,
-    pub stage: Vec<StatusItem>,
+    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>);
@@ -51,10 +80,13 @@ impl AsyncStatus {
     }
 
     ///
-    pub fn fetch(&mut self, request: u64) -> Result<Option<Status>> {
-        let hash_request = hash(&request);
+    pub fn fetch(
+        &mut self,
+        params: StatusParams,
+    ) -> Result<Option<Status>> {
+        let hash_request = hash(&params);
 
-        trace!("request: {} [hash: {}]", request, hash_request);
+        trace!("request: [hash: {}]", hash_request);
 
         {
             let mut current = self.current.lock()?;
@@ -71,10 +103,14 @@ impl AsyncStatus {
         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);
 
-            AsyncStatus::fetch_helper(
+            Self::fetch_helper(
+                status_type,
+                include_untracked,
                 hash_request,
                 arc_current,
                 arc_last,
@@ -92,11 +128,13 @@ impl AsyncStatus {
     }
 
     fn fetch_helper(
+        status_type: StatusType,
+        include_untracked: bool,
         hash_request: u64,
         arc_current: Arc<Mutex<Request<u64, Status>>>,
         arc_last: Arc<Mutex<Status>>,
     ) -> Result<()> {
-        let res = Self::get_status()?;
+        let res = Self::get_status(status_type, include_untracked)?;
         trace!("status fetched: {}", hash(&res));
 
         {
@@ -114,11 +152,16 @@ impl AsyncStatus {
         Ok(())
     }
 
-    fn get_status() -> Result<Status> {
-        let work_dir =
-            sync::status::get_status(CWD, StatusType::WorkingDir)?;
-        let stage = sync::status::get_status(CWD, StatusType::Stage)?;
-
-        Ok(Status { stage, work_dir })
+    fn get_status(
+        status_type: StatusType,
+        include_untracked: bool,
+    ) -> Result<Status> {
+        Ok(Status {
+            items: sync::status::get_status_new(
+                CWD,
+                status_type,
+                include_untracked,
+            )?,
+        })
     }
 }

asyncgit/src/status2.rs

@@ -10,7 +10,7 @@ use crate::{
 };
 use asyncgit::{
     sync::{self, status::StatusType},
-    AsyncNotification, AsyncStatus2, StatusParams, CWD,
+    AsyncNotification, AsyncStatus, StatusParams, CWD,
 };
 use crossbeam_channel::Sender;
 use crossterm::event::Event;
@@ -31,7 +31,7 @@ pub struct Stashing {
     options: Options,
     index: FileTreeComponent,
     theme: Theme,
-    git_status: AsyncStatus2,
+    git_status: AsyncStatus,
     queue: Queue,
 }
 
@@ -55,7 +55,7 @@ impl Stashing {
                 theme,
             ),
             theme: *theme,
-            git_status: AsyncStatus2::new(sender.clone()),
+            git_status: AsyncStatus::new(sender.clone()),
             queue: queue.clone(),
         }
     }