make tag fetching async (#170)

Author: Stephan Dilly

Diff for: asyncgit/src/lib.rs

@@ -13,6 +13,7 @@ mod error;
 mod revlog;
 mod status;
 pub mod sync;
+mod tags;
 
 pub use crate::{
     commit_files::AsyncCommitFiles,
@@ -23,6 +24,7 @@ pub use crate::{
         diff::{DiffLine, DiffLineType, FileDiff},
         status::{StatusItem, StatusItemType},
     },
+    tags::{AsyncTags, TagsResult},
 };
 use std::{
     collections::hash_map::DefaultHasher,
@@ -40,6 +42,8 @@ pub enum AsyncNotification {
     Log,
     ///
     CommitFiles,
+    ///
+    Tags,
 }
 
 /// current working director `./`

Diff for: asyncgit/src/sync/commits_info.rs

@@ -4,7 +4,7 @@ use git2::{Commit, Error, Oid};
 use scopetime::scope_time;
 
 /// identifies a single commit
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Ord, PartialOrd)]
 pub struct CommitId(Oid);
 
 impl CommitId {

Diff for: asyncgit/src/sync/mod.rs

@@ -17,6 +17,7 @@ mod tags;
 pub mod utils;
 
 pub(crate) use branch::get_branch_name;
+
 pub use commit::{amend, commit};
 pub use commit_details::{get_commit_details, CommitDetails};
 pub use commit_files::get_commit_files;

Diff for: asyncgit/src/sync/tags.rs

@@ -1,10 +1,10 @@
 use super::{utils::repo, CommitId};
 use crate::error::Result;
 use scopetime::scope_time;
-use std::collections::HashMap;
+use std::collections::BTreeMap;
 
 /// hashmap of tag target commit hash to tag names
-pub type Tags = HashMap<CommitId, Vec<String>>;
+pub type Tags = BTreeMap<CommitId, Vec<String>>;
 
 /// returns `Tags` type filled with all tags found in repo
 pub fn get_tags(repo_path: &str) -> Result<Tags> {

Diff for: asyncgit/src/tags.rs

@@ -0,0 +1,115 @@
+use crate::{
+    error::Result,
+    hash,
+    sync::{self},
+    AsyncNotification, CWD,
+};
+use crossbeam_channel::Sender;
+use std::sync::{
+    atomic::{AtomicUsize, Ordering},
+    Arc, Mutex,
+};
+use sync::Tags;
+
+///
+#[derive(Default, Clone)]
+pub struct TagsResult {
+    ///
+    pub hash: u64,
+    ///
+    pub tags: Tags,
+}
+
+///
+pub struct AsyncTags {
+    last: Arc<Mutex<Option<TagsResult>>>,
+    sender: Sender<AsyncNotification>,
+    pending: Arc<AtomicUsize>,
+}
+
+impl AsyncTags {
+    ///
+    pub fn new(sender: &Sender<AsyncNotification>) -> Self {
+        Self {
+            last: Arc::new(Mutex::new(None)),
+            sender: sender.clone(),
+            pending: Arc::new(AtomicUsize::new(0)),
+        }
+    }
+
+    ///
+    pub fn last(&mut self) -> Result<Option<TagsResult>> {
+        let last = self.last.lock()?;
+
+        Ok(last.clone())
+    }
+
+    ///
+    fn last_hash(
+        last: Arc<Mutex<Option<TagsResult>>>,
+    ) -> Option<u64> {
+        if let Ok(last) = last.lock() {
+            last.as_ref().map(|last| last.hash)
+        } else {
+            None
+        }
+    }
+
+    ///
+    pub fn is_pending(&self) -> bool {
+        self.pending.load(Ordering::Relaxed) > 0
+    }
+
+    ///
+    pub fn request(&mut self) -> Result<()> {
+        log::trace!("request");
+
+        if self.is_pending() {
+            return Ok(());
+        }
+
+        let arc_last = Arc::clone(&self.last);
+        let sender = self.sender.clone();
+        let arc_pending = Arc::clone(&self.pending);
+        rayon_core::spawn(move || {
+            arc_pending.fetch_add(1, Ordering::Relaxed);
+
+            let notify = AsyncTags::getter(arc_last)
+                .expect("error getting tags");
+
+            arc_pending.fetch_sub(1, Ordering::Relaxed);
+
+            if notify {
+                log::trace!("NOTIFY TAGS");
+
+                sender
+                    .send(AsyncNotification::Tags)
+                    .expect("error sending notify");
+            }
+        });
+
+        Ok(())
+    }
+
+    fn getter(
+        arc_last: Arc<Mutex<Option<TagsResult>>>,
+    ) -> Result<bool> {
+        let tags = sync::get_tags(CWD)?;
+
+        let hash = hash(&tags);
+
+        if Self::last_hash(arc_last.clone())
+            .map(|last| last == hash)
+            .unwrap_or_default()
+        {
+            return Ok(false);
+        }
+
+        {
+            let mut last = arc_last.lock()?;
+            *last = Some(TagsResult { tags, hash });
+        }
+
+        Ok(true)
+    }
+}

Diff for: src/components/commit_details/details.rs

@@ -40,7 +40,7 @@ impl DetailsComponent {
     pub fn set_commit(
         &mut self,
         id: Option<CommitId>,
-        tags: &Tags,
+        tags: Option<&Tags>,
     ) -> Result<()> {
         self.tags.clear();
 
@@ -51,8 +51,10 @@ impl DetailsComponent {
         };
 
         if let Some(id) = id {
-            if let Some(tags) = tags.get(&id) {
-                self.tags.extend(tags.clone());
+            if let Some(tags) = tags {
+                if let Some(tags) = tags.get(&id) {
+                    self.tags.extend(tags.clone());
+                }
             }
         }
 

Diff for: src/components/commit_details/mod.rs

@@ -68,7 +68,7 @@ impl CommitDetailsComponent {
     pub fn set_commit(
         &mut self,
         id: Option<CommitId>,
-        tags: &Tags,
+        tags: Option<&Tags>,
     ) -> Result<()> {
         self.details.set_commit(id, tags)?;
 

Diff for: src/components/commitlist.rs

@@ -10,7 +10,7 @@ use crate::{
     ui::style::{SharedTheme, Theme},
 };
 use anyhow::Result;
-use asyncgit::sync::Tags;
+use asyncgit::TagsResult;
 use crossterm::event::Event;
 use std::{
     borrow::Cow, cell::Cell, cmp, convert::TryFrom, time::Instant,
@@ -33,7 +33,7 @@ pub struct CommitList {
     count_total: usize,
     items: ItemBatch,
     scroll_state: (Instant, f32),
-    tags: Option<Tags>,
+    tags: Option<TagsResult>,
     current_size: Cell<(u16, u16)>,
     scroll_top: Cell<usize>,
     theme: SharedTheme,
@@ -88,23 +88,17 @@ impl CommitList {
     }
 
     ///
-    pub fn tags(&self) -> Option<&Tags> {
+    pub fn tags(&self) -> Option<&TagsResult> {
         self.tags.as_ref()
     }
 
-    ///
-    pub fn has_tags(&self) -> bool {
-        self.tags.is_some()
-    }
-
     ///
     pub fn clear(&mut self) {
-        self.tags = None;
         self.items.clear();
     }
 
     ///
-    pub fn set_tags(&mut self, tags: Tags) {
+    pub fn set_tags(&mut self, tags: TagsResult) {
         self.tags = Some(tags);
     }
 
@@ -251,7 +245,7 @@ impl CommitList {
             .enumerate()
         {
             let tags = if let Some(tags) =
-                self.tags.as_ref().and_then(|t| t.get(&e.id))
+                self.tags.as_ref().and_then(|t| t.tags.get(&e.id))
             {
                 Some(tags.join(" "))
             } else {

Diff for: src/components/inspect_commit.rs

@@ -9,8 +9,8 @@ use crate::{
 };
 use anyhow::Result;
 use asyncgit::{
-    sync::{CommitId, Tags},
-    AsyncDiff, AsyncNotification, DiffParams, DiffType,
+    sync::CommitId, AsyncDiff, AsyncNotification, DiffParams,
+    DiffType,
 };
 use crossbeam_channel::Sender;
 use crossterm::event::Event;
@@ -225,7 +225,7 @@ impl InspectCommitComponent {
     }
 
     fn update(&mut self) -> Result<()> {
-        self.details.set_commit(self.commit_id, &Tags::new())?;
+        self.details.set_commit(self.commit_id, None)?;
         self.update_diff()?;
 
         Ok(())

Diff for: src/tabs/revlog.rs

@@ -13,7 +13,7 @@ use anyhow::Result;
 use asyncgit::{
     cached,
     sync::{self, CommitId},
-    AsyncLog, AsyncNotification, FetchStatus, CWD,
+    AsyncLog, AsyncNotification, AsyncTags, FetchStatus, CWD,
 };
 use crossbeam_channel::Sender;
 use crossterm::event::Event;
@@ -30,6 +30,7 @@ pub struct Revlog {
     commit_details: CommitDetailsComponent,
     list: CommitList,
     git_log: AsyncLog,
+    git_tags: AsyncTags,
     queue: Queue,
     visible: bool,
     branch_name: cached::BranchName,
@@ -51,6 +52,7 @@ impl Revlog {
             ),
             list: CommitList::new(strings::LOG_TITLE, theme),
             git_log: AsyncLog::new(sender),
+            git_tags: AsyncTags::new(sender),
             visible: false,
             branch_name: cached::BranchName::new(CWD),
         }
@@ -78,9 +80,7 @@ impl Revlog {
                 self.fetch_commits()?;
             }
 
-            if !self.list.has_tags() || log_changed {
-                self.list.set_tags(sync::get_tags(CWD)?);
-            }
+            self.git_tags.request()?;
 
             self.list.set_branch(
                 self.branch_name.lookup().map(Some).unwrap_or(None),
@@ -89,7 +89,7 @@ impl Revlog {
             if self.commit_details.is_visible() {
                 self.commit_details.set_commit(
                     self.selected_commit(),
-                    self.list.tags().expect("tags"),
+                    self.list.tags().map(|tags| &tags.tags),
                 )?;
             }
         }
@@ -106,6 +106,12 @@ impl Revlog {
             match ev {
                 AsyncNotification::CommitFiles
                 | AsyncNotification::Log => self.update()?,
+                AsyncNotification::Tags => {
+                    if let Some(tags) = self.git_tags.last()? {
+                        self.list.set_tags(tags);
+                        self.update()?;
+                    }
+                }
                 _ => (),
             }
         }