Add popup for tags

This closes gitui-org#483.

Author: cruessler

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,10 @@ impl App {
                 theme.clone(),
                 key_config.clone(),
             ),
+            tags_popup: TagListComponent::new(
+                theme.clone(),
+                key_config.clone(),
+            ),
             do_quit: false,
             cmdbar: RefCell::new(CommandBar::new(
                 theme.clone(),
@@ -395,6 +400,7 @@ impl App {
             rename_branch_popup,
             select_branch_popup,
             revision_files_popup,
+            tags_popup,
             help,
             revlog,
             status_tab,
@@ -548,6 +554,9 @@ 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)?;
@@ -694,6 +703,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()
     }
@@ -721,6 +731,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)?;

src/components/mod.rs

@@ -21,6 +21,7 @@ mod reset;
 mod revision_files;
 mod stashmsg;
 mod tag_commit;
+mod taglist;
 mod textinput;
 mod utils;
 
@@ -46,6 +47,7 @@ pub use reset::ResetComponent;
 pub use revision_files::RevisionFilesComponent;
 pub use stashmsg::StashMsgComponent;
 pub use tag_commit::TagCommitComponent;
+pub use taglist::TagListComponent;
 pub use textinput::{InputType, TextInputComponent};
 pub use utils::filetree::FileTreeItemKind;
 

src/components/taglist.rs

@@ -0,0 +1,312 @@
+use super::{
+    utils, visibility_blocking, CommandBlocking, CommandInfo,
+    Component, DrawableComponent, EventState,
+};
+use crate::{
+    components::ScrollType,
+    keys::SharedKeyConfig,
+    strings,
+    ui::{self, Size},
+};
+use anyhow::Result;
+use asyncgit::{
+    sync::{get_commit_info, get_tags, CommitId},
+    CWD,
+};
+use crossterm::event::Event;
+use std::convert::TryInto;
+use tui::{
+    backend::Backend,
+    layout::{Constraint, Margin, Rect},
+    text::Span,
+    widgets::{
+        Block, BorderType, Borders, Cell, Clear, Row, Table,
+        TableState,
+    },
+    Frame,
+};
+use ui::style::SharedTheme;
+
+///
+struct Tag {
+    name: String,
+    author: String,
+    time: i64,
+    message: String,
+    _commit_id: CommitId,
+}
+
+///
+pub struct TagListComponent {
+    theme: SharedTheme,
+    tags: Option<Vec<Tag>>,
+    visible: bool,
+    table_state: std::cell::Cell<TableState>,
+    current_height: std::cell::Cell<usize>,
+    key_config: SharedKeyConfig,
+}
+
+impl DrawableComponent for TagListComponent {
+    fn draw<B: Backend>(
+        &self,
+        f: &mut Frame<B>,
+        rect: Rect,
+    ) -> Result<()> {
+        if self.visible {
+            const PERCENT_SIZE: Size = Size::new(80, 50);
+            const MIN_SIZE: Size = Size::new(60, 20);
+
+            let area = ui::centered_rect(
+                PERCENT_SIZE.width,
+                PERCENT_SIZE.height,
+                f.size(),
+            );
+            let area =
+                ui::rect_inside(MIN_SIZE, f.size().into(), area);
+            let area = area.intersection(rect);
+
+            let tag_name_width =
+                self.tags.as_ref().map_or(0, |tags| {
+                    tags.iter()
+                        .fold(0, |acc, tag| acc.max(tag.name.len()))
+                });
+
+            let constraints = [
+                // tag name
+                Constraint::Length(tag_name_width.try_into()?),
+                // commit date
+                Constraint::Length(10),
+                // author width
+                Constraint::Length(19),
+                // commit id
+                Constraint::Min(0),
+            ];
+
+            let rows = self.get_rows();
+            let number_of_rows = rows.len();
+
+            let table = Table::new(rows)
+                .widths(&constraints)
+                .column_spacing(1)
+                .highlight_style(self.theme.text(true, true))
+                .block(
+                    Block::default()
+                        .borders(Borders::ALL)
+                        .title(Span::styled(
+                            strings::title_tags(),
+                            self.theme.title(true),
+                        ))
+                        .border_style(self.theme.block(true))
+                        .border_type(BorderType::Thick),
+                );
+
+            let mut table_state = self.table_state.take();
+
+            f.render_widget(Clear, area);
+            f.render_stateful_widget(table, area, &mut table_state);
+
+            let area = area.inner(&Margin {
+                vertical: 1,
+                horizontal: 0,
+            });
+
+            ui::draw_scrollbar(
+                f,
+                area,
+                &self.theme,
+                number_of_rows,
+                table_state.selected().unwrap_or(0),
+            );
+
+            self.table_state.set(table_state);
+            self.current_height.set(area.height.into());
+        }
+
+        Ok(())
+    }
+}
+
+impl Component for TagListComponent {
+    fn commands(
+        &self,
+        out: &mut Vec<CommandInfo>,
+        force_all: bool,
+    ) -> CommandBlocking {
+        if self.visible || force_all {
+            out.clear();
+
+            out.push(CommandInfo::new(
+                strings::commands::scroll(&self.key_config),
+                true,
+                true,
+            ));
+
+            out.push(CommandInfo::new(
+                strings::commands::close_popup(&self.key_config),
+                true,
+                true,
+            ));
+        }
+        visibility_blocking(self)
+    }
+
+    fn event(&mut self, event: Event) -> Result<EventState> {
+        if self.visible {
+            if let Event::Key(key) = event {
+                if key == self.key_config.exit_popup {
+                    self.hide()
+                } else if key == self.key_config.move_up {
+                    self.move_selection(ScrollType::Up);
+                } else if key == self.key_config.move_down {
+                    self.move_selection(ScrollType::Down);
+                } else if key == self.key_config.shift_up
+                    || key == self.key_config.home
+                {
+                    self.move_selection(ScrollType::Home);
+                } else if key == self.key_config.shift_down
+                    || key == self.key_config.end
+                {
+                    self.move_selection(ScrollType::End);
+                } else if key == self.key_config.page_down {
+                    self.move_selection(ScrollType::PageDown);
+                } else if key == self.key_config.page_up {
+                    self.move_selection(ScrollType::PageUp);
+                }
+            }
+
+            Ok(EventState::Consumed)
+        } else {
+            Ok(EventState::NotConsumed)
+        }
+    }
+
+    fn is_visible(&self) -> bool {
+        self.visible
+    }
+
+    fn hide(&mut self) {
+        self.visible = false
+    }
+
+    fn show(&mut self) -> Result<()> {
+        self.visible = true;
+
+        Ok(())
+    }
+}
+
+impl TagListComponent {
+    pub fn new(
+        theme: SharedTheme,
+        key_config: SharedKeyConfig,
+    ) -> Self {
+        Self {
+            theme,
+            tags: None,
+            visible: false,
+            table_state: std::cell::Cell::new(TableState::default()),
+            current_height: std::cell::Cell::new(0),
+            key_config,
+        }
+    }
+
+    ///
+    pub fn open(&mut self) -> Result<()> {
+        self.table_state.get_mut().select(Some(0));
+        self.show()?;
+
+        self.update_tags()?;
+
+        Ok(())
+    }
+
+    /// fetch list of tags
+    pub fn update_tags(&mut self) -> Result<()> {
+        let tags_grouped_by_commit_id = get_tags(CWD)?;
+
+        let mut tags: Vec<Tag> = tags_grouped_by_commit_id
+            .iter()
+            .flat_map(|(commit_id, tags)| {
+                tags.iter()
+                    .map(|tag| {
+                        let commit_info =
+                            get_commit_info(CWD, commit_id)
+                                .expect("could not get commit info");
+
+                        Tag {
+                            name: tag.clone(),
+                            author: commit_info.author,
+                            time: commit_info.time,
+                            message: commit_info.message,
+                            _commit_id: *commit_id,
+                        }
+                    })
+                    .collect::<Vec<Tag>>()
+            })
+            .collect();
+
+        tags.sort_by(|a, b| a.name.cmp(&b.name));
+
+        self.tags = Some(tags);
+
+        Ok(())
+    }
+
+    ///
+    fn move_selection(&mut self, scroll_type: ScrollType) -> bool {
+        let mut table_state = self.table_state.take();
+
+        let old_selection = table_state.selected().unwrap_or(0);
+        let max_selection =
+            self.tags.as_ref().map_or(0, |tags| tags.len() - 1);
+
+        let new_selection = match scroll_type {
+            ScrollType::Up => old_selection.saturating_sub(1),
+            ScrollType::Down => {
+                old_selection.saturating_add(1).min(max_selection)
+            }
+            ScrollType::Home => 0,
+            ScrollType::End => max_selection,
+            ScrollType::PageUp => old_selection.saturating_sub(
+                self.current_height.get().saturating_sub(2),
+            ),
+            ScrollType::PageDown => old_selection
+                .saturating_add(
+                    self.current_height.get().saturating_sub(2),
+                )
+                .min(max_selection),
+        };
+
+        let needs_update = new_selection != old_selection;
+
+        table_state.select(Some(new_selection));
+        self.table_state.set(table_state);
+
+        needs_update
+    }
+
+    ///
+    fn get_rows(&self) -> Vec<Row> {
+        if let Some(ref tags) = self.tags {
+            tags.iter().map(|tag| self.get_row(tag)).collect()
+        } else {
+            vec![]
+        }
+    }
+
+    ///
+    fn get_row(&self, tag: &Tag) -> Row {
+        let cells: Vec<Cell> = vec![
+            Cell::from(tag.name.clone())
+                .style(self.theme.text(true, false)),
+            Cell::from(utils::time_to_string(tag.time, true))
+                .style(self.theme.commit_time(false)),
+            Cell::from(tag.author.clone())
+                .style(self.theme.commit_author(false)),
+            Cell::from(tag.message.clone())
+                .style(self.theme.text(true, false)),
+        ];
+
+        Row::new(cells)
+    }
+}