Add popup for tags

This closes #483.

Author: cruessler

Diff for: asyncgit/src/revlog.rs

@@ -68,6 +68,14 @@ impl AsyncLog {
         Ok(list[min..max].to_vec())
     }
 
+    ///
+    pub fn position(&self, id: CommitId) -> Result<Option<usize>> {
+        let list = self.current.lock()?;
+        let position = list.iter().position(|&x| x == id);
+
+        Ok(position)
+    }
+
     ///
     pub fn is_pending(&self) -> bool {
         self.pending.load(Ordering::Relaxed)

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

@@ -64,7 +64,10 @@ pub use stash::{
     get_stashes, stash_apply, stash_drop, stash_pop, stash_save,
 };
 pub use state::{repo_state, RepoState};
-pub use tags::{get_tags, CommitTags, Tags};
+pub use tags::{
+    delete_tag, get_tags, get_tags_with_metadata, CommitTags,
+    TagWithMetadata, Tags,
+};
 pub use tree::{tree_file_content, tree_files, TreeFile};
 pub use utils::{
     get_head, get_head_tuple, is_bare_repo, is_repo, repo_dir,

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

@@ -1,13 +1,29 @@
-use super::{utils::repo, CommitId};
+use super::{get_commits_info, utils::repo, CommitId};
 use crate::error::Result;
 use scopetime::scope_time;
-use std::collections::BTreeMap;
+use std::collections::{BTreeMap, HashMap, HashSet};
 
 /// all tags pointing to a single commit
 pub type CommitTags = Vec<String>;
 /// hashmap of tag target commit hash to tag names
 pub type Tags = BTreeMap<CommitId, CommitTags>;
 
+///
+pub struct TagWithMetadata {
+    ///
+    pub name: String,
+    ///
+    pub author: String,
+    ///
+    pub time: i64,
+    ///
+    pub message: String,
+    ///
+    pub commit_id: CommitId,
+}
+
+static MAX_MESSAGE_WIDTH: usize = 100;
+
 /// returns `Tags` type filled with all tags found in repo
 pub fn get_tags(repo_path: &str) -> Result<Tags> {
     scope_time!("get_tags");
@@ -31,8 +47,12 @@ pub fn get_tags(repo_path: &str) -> Result<Tags> {
             //NOTE: find_tag (git_tag_lookup) only works on annotated tags
             // lightweight tags `id` already points to the target commit
             // see https://github.com/libgit2/libgit2/issues/5586
-            if let Ok(tag) = repo.find_tag(id) {
-                adder(CommitId::new(tag.target_id()), name);
+            if let Ok(commit) = repo
+                .find_tag(id)
+                .and_then(|tag| tag.target())
+                .and_then(|target| target.peel_to_commit())
+            {
+                adder(CommitId::new(commit.id()), name);
             } else if repo.find_commit(id).is_ok() {
                 adder(CommitId::new(id), name);
             }
@@ -45,6 +65,69 @@ pub fn get_tags(repo_path: &str) -> Result<Tags> {
     Ok(res)
 }
 
+///
+pub fn get_tags_with_metadata(
+    repo_path: &str,
+) -> Result<Vec<TagWithMetadata>> {
+    scope_time!("get_tags_with_metadata");
+
+    let tags_grouped_by_commit_id = get_tags(repo_path)?;
+
+    let tags_with_commit_id: Vec<(&str, &CommitId)> =
+        tags_grouped_by_commit_id
+            .iter()
+            .flat_map(|(commit_id, tags)| {
+                tags.iter()
+                    .map(|tag| (tag.as_ref(), commit_id))
+                    .collect::<Vec<(&str, &CommitId)>>()
+            })
+            .collect();
+
+    let unique_commit_ids: HashSet<_> = tags_with_commit_id
+        .iter()
+        .copied()
+        .map(|(_, &commit_id)| commit_id)
+        .collect();
+    let mut commit_ids = Vec::with_capacity(unique_commit_ids.len());
+    commit_ids.extend(unique_commit_ids);
+
+    let commit_infos =
+        get_commits_info(repo_path, &commit_ids, MAX_MESSAGE_WIDTH)?;
+    let unique_commit_infos: HashMap<_, _> = commit_infos
+        .iter()
+        .map(|commit_info| (commit_info.id, commit_info))
+        .collect();
+
+    let mut tags: Vec<TagWithMetadata> = tags_with_commit_id
+        .into_iter()
+        .filter_map(|(tag, commit_id)| {
+            unique_commit_infos.get(commit_id).map(|commit_info| {
+                TagWithMetadata {
+                    name: String::from(tag),
+                    author: commit_info.author.clone(),
+                    time: commit_info.time,
+                    message: commit_info.message.clone(),
+                    commit_id: *commit_id,
+                }
+            })
+        })
+        .collect();
+
+    tags.sort_unstable_by(|a, b| b.time.cmp(&a.time));
+
+    Ok(tags)
+}
+
+///
+pub fn delete_tag(repo_path: &str, tag_name: &str) -> Result<()> {
+    scope_time!("delete_tag");
+
+    let repo = repo(repo_path)?;
+    repo.tag_delete(tag_name)?;
+
+    Ok(())
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -82,5 +165,26 @@ mod tests {
             get_tags(repo_path).unwrap()[&CommitId::new(head_id)],
             vec!["a", "b"]
         );
+
+        let tags = get_tags_with_metadata(repo_path).unwrap();
+
+        assert_eq!(tags.len(), 2);
+        assert_eq!(tags[0].name, "a");
+        assert_eq!(tags[0].message, "initial");
+        assert_eq!(tags[1].name, "b");
+        assert_eq!(tags[1].message, "initial");
+        assert_eq!(tags[0].commit_id, tags[1].commit_id);
+
+        delete_tag(repo_path, "a").unwrap();
+
+        let tags = get_tags(repo_path).unwrap();
+
+        assert_eq!(tags.len(), 1);
+
+        delete_tag(repo_path, "b").unwrap();
+
+        let tags = get_tags(repo_path).unwrap();
+
+        assert_eq!(tags.len(), 0);
     }
 }

Diff for: src/app.rs

@@ -9,7 +9,7 @@ use crate::{
         InspectCommitComponent, MsgComponent, PullComponent,
         PushComponent, PushTagsComponent, RenameBranchComponent,
         ResetComponent, RevisionFilesComponent, StashMsgComponent,
-        TagCommitComponent,
+        TagCommitComponent, TagListComponent,
     },
     input::{Input, InputEvent, InputState},
     keys::{KeyConfig, SharedKeyConfig},
@@ -54,6 +54,7 @@ pub struct App {
     create_branch_popup: CreateBranchComponent,
     rename_branch_popup: RenameBranchComponent,
     select_branch_popup: BranchListComponent,
+    tags_popup: TagListComponent,
     cmdbar: RefCell<CommandBar>,
     tab: usize,
     revlog: Revlog,
@@ -162,6 +163,11 @@ impl App {
                 theme.clone(),
                 key_config.clone(),
             ),
+            tags_popup: TagListComponent::new(
+                &queue,
+                theme.clone(),
+                key_config.clone(),
+            ),
             do_quit: false,
             cmdbar: RefCell::new(CommandBar::new(
                 theme.clone(),
@@ -397,6 +403,7 @@ impl App {
             rename_branch_popup,
             select_branch_popup,
             revision_files_popup,
+            tags_popup,
             help,
             revlog,
             status_tab,
@@ -550,11 +557,19 @@ impl App {
             InternalEvent::SelectBranch => {
                 self.select_branch_popup.open()?;
             }
+            InternalEvent::Tags => {
+                self.tags_popup.open()?;
+            }
             InternalEvent::TabSwitch => self.set_tab(0)?,
             InternalEvent::InspectCommit(id, tags) => {
                 self.inspect_commit_popup.open(id, tags)?;
                 flags.insert(NeedsUpdate::ALL | NeedsUpdate::COMMANDS)
             }
+            InternalEvent::SelectCommitInRevlog(id) => {
+                self.revlog.select_commit(id);
+                self.tags_popup.hide();
+                flags.insert(NeedsUpdate::ALL)
+            }
             InternalEvent::OpenExternalEditor(path) => {
                 self.input.set_polling(false);
                 self.external_editor_popup.show()?;
@@ -620,6 +635,18 @@ impl App {
                     self.select_branch_popup.update_branches()?;
                 }
             }
+            Action::DeleteTag(tag_name) => {
+                if let Err(error) = sync::delete_tag(CWD, &tag_name) {
+                    self.queue.borrow_mut().push_back(
+                        InternalEvent::ShowErrorMsg(
+                            error.to_string(),
+                        ),
+                    )
+                } else {
+                    flags.insert(NeedsUpdate::ALL);
+                    self.tags_popup.update_tags()?;
+                }
+            }
             Action::ForcePush(branch, force) => self
                 .queue
                 .borrow_mut()
@@ -696,6 +723,7 @@ impl App {
             || self.push_tags_popup.is_visible()
             || self.pull_popup.is_visible()
             || self.select_branch_popup.is_visible()
+            || self.tags_popup.is_visible()
             || self.rename_branch_popup.is_visible()
             || self.revision_files_popup.is_visible()
     }
@@ -723,6 +751,7 @@ impl App {
         self.external_editor_popup.draw(f, size)?;
         self.tag_commit_popup.draw(f, size)?;
         self.select_branch_popup.draw(f, size)?;
+        self.tags_popup.draw(f, size)?;
         self.create_branch_popup.draw(f, size)?;
         self.rename_branch_popup.draw(f, size)?;
         self.revision_files_popup.draw(f, size)?;

Diff for: src/components/commitlist.rs

@@ -287,6 +287,10 @@ impl CommitList {
     fn relative_selection(&self) -> usize {
         self.selection.saturating_sub(self.items.index_offset())
     }
+
+    pub fn select_entry(&mut self, position: usize) {
+        self.selection = position;
+    }
 }
 
 impl DrawableComponent for CommitList {

Diff for: src/components/mod.rs

@@ -22,6 +22,7 @@ mod revision_files;
 mod stashmsg;
 mod syntax_text;
 mod tag_commit;
+mod taglist;
 mod textinput;
 mod utils;
 
@@ -48,6 +49,7 @@ pub use revision_files::RevisionFilesComponent;
 pub use stashmsg::StashMsgComponent;
 pub use syntax_text::SyntaxTextComponent;
 pub use tag_commit::TagCommitComponent;
+pub use taglist::TagListComponent;
 pub use textinput::{InputType, TextInputComponent};
 pub use utils::filetree::FileTreeItemKind;
 

Diff for: src/components/reset.rs

@@ -168,6 +168,15 @@ impl ResetComponent {
                         branch_ref,
                     ),
                 ),
+                Action::DeleteTag(tag_name) => (
+                    strings::confirm_title_delete_tag(
+                        &self.key_config,
+                    ),
+                    strings::confirm_msg_delete_tag(
+                        &self.key_config,
+                        tag_name,
+                    ),
+                ),
                 Action::ForcePush(branch, _force) => (
                     strings::confirm_title_force_push(
                         &self.key_config,