├── .gitignore
├── .github
    ├── pull_request_template.md
    └── workflows
    │   ├── winget.yml
    │   ├── publish.yml
    │   └── test.yml
├── src
    ├── ui
    │   ├── panel
    │   │   ├── mod.rs
    │   │   ├── details_panel.rs
    │   │   └── log_panel.rs
    │   ├── styles.rs
    │   ├── message_popup.rs
    │   ├── utils.rs
    │   ├── help_popup.rs
    │   ├── mod.rs
    │   ├── command_popup.rs
    │   ├── rebase_popup.rs
    │   ├── command_log_tab.rs
    │   └── bookmark_set_popup.rs
    ├── commander
    │   ├── snapshots
    │   │   ├── lazyjj__commander__log__tests__get_log.snap
    │   │   ├── lazyjj__commander__files__tests__get_file_diff.snap
    │   │   ├── lazyjj__commander__files__tests__get_file_diff-3.snap
    │   │   ├── lazyjj__commander__files__tests__get_file_diff-7.snap
    │   │   ├── lazyjj__commander__files__tests__get_file_diff-5.snap
    │   │   ├── lazyjj__commander__files__tests__get_file_diff-6.snap
    │   │   ├── lazyjj__commander__log__tests__get_commit_show.snap
    │   │   ├── lazyjj__commander__bookmarks__tests__get_bookmark_show.snap
    │   │   ├── lazyjj__commander__files__tests__get_file_diff-2.snap
    │   │   ├── lazyjj__commander__files__tests__get_file_diff-8.snap
    │   │   └── lazyjj__commander__files__tests__get_file_diff-4.snap
    │   ├── ids.rs
    │   ├── bookmarks.rs
    │   ├── mod.rs
    │   ├── files.rs
    │   └── log.rs
    ├── keybinds
    │   ├── config.rs
    │   ├── keybinds_store.rs
    │   ├── rebase_popup.rs
    │   ├── log_tab.rs
    │   └── mod.rs
    ├── main.rs
    ├── env.rs
    └── app.rs
├── CHANGELOG.md
├── docs
    └── keybindings.md
├── Cargo.toml
├── README.md
└── LICENSE


/.gitignore:
--------------------------------------------------------------------------------
1 | /target
2 | lazyjj.log
3 | trace-*.json
4 | 


--------------------------------------------------------------------------------
/.github/pull_request_template.md:
--------------------------------------------------------------------------------
1 | <!-- Please use conventionalcommits.org for PR title. E.g. prefix with feat:, fix:, chore:, etc -->
2 | 


--------------------------------------------------------------------------------
/src/ui/panel/mod.rs:
--------------------------------------------------------------------------------
1 | mod details_panel;
2 | mod log_panel;
3 | 
4 | pub use details_panel::DetailsPanel;
5 | pub use log_panel::LogPanel;
6 | 


--------------------------------------------------------------------------------
/src/commander/snapshots/lazyjj__commander__log__tests__get_log.snap:
--------------------------------------------------------------------------------
1 | ---
2 | source: src/commander/log.rs
3 | expression: log.graph
4 | ---
5 | "@  [LINE]\n│  (empty) (no description set)\n◆  [LINE]\n"
6 | 


--------------------------------------------------------------------------------
/src/commander/snapshots/lazyjj__commander__files__tests__get_file_diff.snap:
--------------------------------------------------------------------------------
1 | ---
2 | source: src/commander/files.rs
3 | expression: "test_repo.commander.get_file_diff(&head, &file, &DiffFormat::ColorWords)?"
4 | ---
5 | Some(
6 |     "Added regular file README:\n        1: AAA\n",
7 | )
8 | 


--------------------------------------------------------------------------------
/src/commander/snapshots/lazyjj__commander__files__tests__get_file_diff-3.snap:
--------------------------------------------------------------------------------
1 | ---
2 | source: src/commander/files.rs
3 | expression: "test_repo.commander.get_file_diff(&head, &file, &DiffFormat::ColorWords)?"
4 | ---
5 | Some(
6 |     "Modified regular file README:\n   1    1: AAABBB\n",
7 | )
8 | 


--------------------------------------------------------------------------------
/src/commander/snapshots/lazyjj__commander__files__tests__get_file_diff-7.snap:
--------------------------------------------------------------------------------
1 | ---
2 | source: src/commander/files.rs
3 | expression: "test_repo.commander.get_file_diff(&head, &file, &DiffFormat::ColorWords)?"
4 | ---
5 | Some(
6 |     "Removed regular file README2:\n   1     : BBB\n",
7 | )
8 | 


--------------------------------------------------------------------------------
/src/commander/snapshots/lazyjj__commander__files__tests__get_file_diff-5.snap:
--------------------------------------------------------------------------------
1 | ---
2 | source: src/commander/files.rs
3 | expression: "test_repo.commander.get_file_diff(&head, &file, &DiffFormat::ColorWords)?"
4 | ---
5 | Some(
6 |     "Modified regular file README2 (README => README2):\n",
7 | )
8 | 


--------------------------------------------------------------------------------
/src/commander/snapshots/lazyjj__commander__files__tests__get_file_diff-6.snap:
--------------------------------------------------------------------------------
1 | ---
2 | source: src/commander/files.rs
3 | expression: "test_repo.commander.get_file_diff(&head, &file, &DiffFormat::Git)?"
4 | ---
5 | Some(
6 |     "diff --git a/README b/README2\nrename from README\nrename to README2\n",
7 | )
8 | 


--------------------------------------------------------------------------------
/src/commander/snapshots/lazyjj__commander__log__tests__get_commit_show.snap:
--------------------------------------------------------------------------------
1 | ---
2 | source: src/commander/log.rs
3 | expression: show
4 | ---
5 | "Commit ID: [COMMIT_ID]\nChange ID: [Change ID]\nAuthor   : lazyjj <lazyjj@example.com> (([DATE_TIME]))\nCommitter: lazyjj <lazyjj@example.com> (([DATE_TIME]))\n\n    (no description set)\n\nAdded regular file README:\n        1: AAA"
6 | 


--------------------------------------------------------------------------------
/src/commander/snapshots/lazyjj__commander__bookmarks__tests__get_bookmark_show.snap:
--------------------------------------------------------------------------------
1 | ---
2 | source: src/commander/bookmarks.rs
3 | expression: bookmark_show
4 | ---
5 | "Commit ID: [COMMIT_ID]\nChange ID: [Change ID]\nBookmarks: test test@git\nAuthor   : lazyjj <lazyjj@example.com> (([DATE_TIME]))\nCommitter: lazyjj <lazyjj@example.com> (([DATE_TIME]))\n\n    (no description set)\n"
6 | 


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
 1 | # Changelog
 2 | 
 3 | All notable changes to this project will be documented in this file.
 4 | 
 5 | The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 6 | and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 7 | 
 8 | ## [Unreleased]
 9 | 
10 | ### Added
11 | 
12 | - Details panel responds to mouse scroll in all tabs
13 | 


--------------------------------------------------------------------------------
/src/commander/snapshots/lazyjj__commander__files__tests__get_file_diff-2.snap:
--------------------------------------------------------------------------------
1 | ---
2 | source: src/commander/files.rs
3 | expression: "test_repo.commander.get_file_diff(&head, &file, &DiffFormat::Git)?"
4 | ---
5 | Some(
6 |     "diff --git a/README b/README\nnew file mode 100644\nindex 0000000000..43d88b6586\n--- /dev/null\n+++ b/README\n@@ -0,0 +1,1 @@\n+AAA\n\\ No newline at end of file\n",
7 | )
8 | 


--------------------------------------------------------------------------------
/src/commander/snapshots/lazyjj__commander__files__tests__get_file_diff-8.snap:
--------------------------------------------------------------------------------
1 | ---
2 | source: src/commander/files.rs
3 | expression: "test_repo.commander.get_file_diff(&head, &file, &DiffFormat::Git)?"
4 | ---
5 | Some(
6 |     "diff --git a/README2 b/README2\ndeleted file mode 100644\nindex f6d5afa370..0000000000\n--- a/README2\n+++ /dev/null\n@@ -1,1 +0,0 @@\n-BBB\n\\ No newline at end of file\n",
7 | )
8 | 


--------------------------------------------------------------------------------
/src/commander/snapshots/lazyjj__commander__files__tests__get_file_diff-4.snap:
--------------------------------------------------------------------------------
1 | ---
2 | source: src/commander/files.rs
3 | expression: "test_repo.commander.get_file_diff(&head, &file, &DiffFormat::Git)?"
4 | ---
5 | Some(
6 |     "diff --git a/README b/README\nindex 43d88b6586..f6d5afa370 100644\n--- a/README\n+++ b/README\n@@ -1,1 +1,1 @@\n-AAA\n\\ No newline at end of file\n+BBB\n\\ No newline at end of file\n",
7 | )
8 | 


--------------------------------------------------------------------------------
/src/ui/styles.rs:
--------------------------------------------------------------------------------
 1 | use std::sync::LazyLock;
 2 | 
 3 | use ratatui::{
 4 |     layout::Alignment,
 5 |     style::{Color, Style, Stylize},
 6 |     text::Span,
 7 |     widgets::{Block, BorderType, Padding},
 8 | };
 9 | 
10 | pub static POPUP_BLOCK: LazyLock<Block<'static>> = LazyLock::new(|| {
11 |     Block::<'static>::bordered()
12 |         .padding(Padding::horizontal(1))
13 |         .border_type(BorderType::Rounded)
14 |         .border_style(Style::default().fg(Color::Green))
15 | });
16 | pub static POPUP_BLOCK_TITLE_STYLE: LazyLock<Style> = LazyLock::new(|| Style::new().bold().cyan());
17 | 
18 | pub fn create_popup_block(title: &str) -> Block<'_> {
19 |     POPUP_BLOCK
20 |         .clone()
21 |         .title(Span::styled(format!(" {title} "), *POPUP_BLOCK_TITLE_STYLE))
22 |         .title_alignment(Alignment::Center)
23 | }
24 | 


--------------------------------------------------------------------------------
/docs/keybindings.md:
--------------------------------------------------------------------------------
 1 | ## Configuring keybindings
 2 | 
 3 | ```toml
 4 | # change keybinding
 5 | save = "ctrl+s"
 6 | # set multiple keybindings
 7 | save = ["ctrl+s", "ctrl+shift+g"]
 8 | # disable keybinding
 9 | save = false
10 | ```
11 | 
12 | In below examples default values are used.
13 | 
14 | ### Log tab
15 | 
16 | ```toml
17 | [lazyjj.keybinds.log_tab]
18 | save = "ctrl+s"
19 | cancel = "esc"
20 | 
21 | close-popup = "q"
22 | 
23 | scroll-down = ["j", "down"]
24 | scroll-up = ["k", "up"]
25 | scroll-down-half = "shift+j"
26 | scroll-up-half = "shift+k"
27 | 
28 | focus-current = "@"
29 | toggle-diff-format = "w"
30 | 
31 | refresh = ["shift+r", "f5"]
32 | create-new = "n"
33 | create-new-describe = "shift+n"
34 | squash = "s"
35 | squash-ignore-immutable = "shift+s"
36 | edit-change = "e"
37 | edit-change-ignore-immutable = "shift+e"
38 | abandon = "a"
39 | describe = "d"
40 | edit-revset = "r"
41 | set-bookmark = "b"
42 | open-files = "enter"
43 | 
44 | push = "p"
45 | push-new = "ctrl+p"
46 | push-all = "shift+p"
47 | push-all-new = "ctrl+shift+p"
48 | fetch = "f"
49 | fetch-all = "shift+f"
50 | 
51 | open-help = "?"
52 | ```
53 | 


--------------------------------------------------------------------------------
/.github/workflows/winget.yml:
--------------------------------------------------------------------------------
 1 | name: WinGet submission on release
 2 | # based off of https://raw.githubusercontent.com/microsoft/PowerToys/main/.github/workflows/package-submissions.yml
 3 | 
 4 | on:
 5 |   workflow_dispatch:
 6 |   release:
 7 |     types: [published]
 8 | 
 9 | jobs:
10 |   winget:
11 |     name: Publish winget package
12 |     runs-on: windows-latest
13 |     steps:
14 |       - name: Submit Cretezy.lazyjj package to Windows Package Manager Community Repository
15 |         run: |
16 |           $ErrorActionPreference = 'Stop'
17 |           $wingetPackage = "Cretezy.lazyjj"
18 |           $gitToken = "${{ secrets.PAT_WINGET }}"
19 | 
20 |           $github = Invoke-RestMethod -uri "https://api.github.com/repos/Cretezy/lazyjj/releases" 
21 | 
22 |           if ($github.Length -gt 0) {
23 |             $targetRelease = $github[0]
24 |             $installer = ($targetRelease.assets | where-object name -match 'x86_64-pc-windows')[0].browser_download_url
25 |             $ver = $targetRelease.tag_name.Trim("v")
26 | 
27 |             # getting latest wingetcreate file
28 |             Invoke-WebRequest https://aka.ms/wingetcreate/latest -OutFile wingetcreate.exe
29 |             Write-Output "wingetcreate.exe update $wingetPackage -s -v $ver -u $installer -t <TOKEN>"
30 |             .\wingetcreate.exe update $wingetPackage -s -v $ver -u $installer -t $gitToken
31 |           }
32 |           else {
33 |             Write-Error "Failed to find any releases"
34 |             return 1
35 |           }
36 | 
37 | 


--------------------------------------------------------------------------------
/src/commander/ids.rs:
--------------------------------------------------------------------------------
 1 | /*!
 2 | Helper structs [ChangeId] and [CommitId]
 3 | */
 4 | use std::{ffi::OsStr, fmt::Display};
 5 | 
 6 | /// Wrapper around change ID.
 7 | #[derive(Clone, PartialEq, Eq, Hash, Debug)]
 8 | pub struct ChangeId(pub String);
 9 | 
10 | impl ChangeId {
11 |     pub fn as_os_str(&self) -> &OsStr {
12 |         OsStr::new(&self.0)
13 |     }
14 | 
15 |     pub fn as_str(&self) -> &str {
16 |         &self.0
17 |     }
18 | 
19 |     pub fn as_string(&self) -> String {
20 |         self.0.to_owned()
21 |     }
22 | }
23 | 
24 | impl AsRef<OsStr> for ChangeId {
25 |     fn as_ref(&self) -> &OsStr {
26 |         self.as_os_str()
27 |     }
28 | }
29 | 
30 | impl Display for ChangeId {
31 |     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
32 |         write!(f, "{}", self.as_str())
33 |     }
34 | }
35 | 
36 | /// Wrapper around commit ID.
37 | #[derive(Clone, PartialEq, Eq, Hash, Debug)]
38 | pub struct CommitId(pub String);
39 | 
40 | impl CommitId {
41 |     pub fn as_os_str(&self) -> &OsStr {
42 |         OsStr::new(&self.0)
43 |     }
44 | 
45 |     pub fn as_str(&self) -> &str {
46 |         &self.0
47 |     }
48 | 
49 |     // pub fn as_string(&self) -> String {
50 |     //     self.0.to_owned()
51 |     // }
52 | }
53 | 
54 | impl AsRef<OsStr> for CommitId {
55 |     fn as_ref(&self) -> &OsStr {
56 |         self.as_os_str()
57 |     }
58 | }
59 | 
60 | impl Display for CommitId {
61 |     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
62 |         write!(f, "{}", self.as_str())
63 |     }
64 | }
65 | 


--------------------------------------------------------------------------------
/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "lazyjj"
 3 | description = "TUI for Jujutsu/jj"
 4 | version = "0.6.1"
 5 | edition = "2024"
 6 | license = "Apache-2.0"
 7 | readme = "README.md"
 8 | repository = "https://github.com/Cretezy/lazyjj"
 9 | authors = ["Charles Crete <charles@cretezy.com>"]
10 | 
11 | 
12 | [package.metadata.binstall]
13 | # `cargo binstall` gets confused by the `v` before versions in archive name.
14 | pkg-url = "{ repo }/releases/download/v{ version }/lazyjj-v{ version }-{ target }.{ archive-format }"
15 | 
16 | 
17 | [dependencies]
18 | ansi-to-tui = { git = "https://github.com/Cretezy/ansi-to-tui.git", rev = "74bd97e" }
19 | anyhow = "1.0.95"
20 | chrono = "0.4.39"
21 | clap = { version = "4.5.31", features = ["derive", "env"] }
22 | insta = { version = "1.42.1", features = ["filters"] }
23 | itertools = "0.14.0"
24 | ratatui = { version = "0.29.0", features = [
25 |   "serde",
26 |   "unstable-rendered-line-info",
27 | ] }
28 | regex = "1.11.1"
29 | serde = { version = "1.0.217", features = ["derive"] }
30 | serde_with = "3.12.0"
31 | shell-words = "1.1.0"
32 | tempdir = "0.3.7"
33 | thiserror = "2.0.11"
34 | toml = "0.8.19"
35 | tracing = { version = "0.1.41", features = ["attributes"] }
36 | tracing-chrome = "0.7.2"
37 | tracing-log = "0.2.0"
38 | tracing-subscriber = "0.3.19"
39 | tui-textarea = "0.7.0"
40 | tui_confirm_dialog = "0.3.1"
41 | version-compare = "0.2.0"
42 | 
43 | # Release build optimize size.
44 | # Run strip manually after build to reduce further.
45 | [profile.release]
46 | lto = true
47 | opt-level = 's'     # Optimize for size.
48 | codegen-units = 1
49 | strip = "symbols"
50 | 


--------------------------------------------------------------------------------
/src/keybinds/config.rs:
--------------------------------------------------------------------------------
 1 | use super::Shortcut;
 2 | 
 3 | #[derive(Debug, Clone, serde::Deserialize)]
 4 | pub struct KeybindsConfig {
 5 |     pub log_tab: Option<LogTabKeybindsConfig>,
 6 | }
 7 | 
 8 | #[derive(Debug, Clone, serde::Deserialize)]
 9 | #[serde(untagged)]
10 | pub enum Keybind {
11 |     Single(Shortcut),
12 |     Multiple(Vec<Shortcut>),
13 |     Enable(bool),
14 | }
15 | 
16 | #[derive(Debug, Clone, serde::Deserialize)]
17 | #[serde(rename_all = "kebab-case")]
18 | pub struct LogTabKeybindsConfig {
19 |     pub save: Option<Keybind>,
20 |     pub cancel: Option<Keybind>,
21 | 
22 |     pub close_popup: Option<Keybind>,
23 | 
24 |     pub scroll_down: Option<Keybind>,
25 |     pub scroll_up: Option<Keybind>,
26 |     pub scroll_down_half: Option<Keybind>,
27 |     pub scroll_up_half: Option<Keybind>,
28 | 
29 |     pub focus_current: Option<Keybind>,
30 |     pub toggle_diff_format: Option<Keybind>,
31 | 
32 |     pub refresh: Option<Keybind>,
33 |     pub create_new: Option<Keybind>,
34 |     pub create_new_describe: Option<Keybind>,
35 |     pub squash: Option<Keybind>,
36 |     pub squash_ignore_immutable: Option<Keybind>,
37 |     pub edit_change: Option<Keybind>,
38 |     pub edit_change_ignore_immutable: Option<Keybind>,
39 |     pub abandon: Option<Keybind>,
40 |     pub describe: Option<Keybind>,
41 |     pub edit_revset: Option<Keybind>,
42 |     pub set_bookmark: Option<Keybind>,
43 |     pub open_files: Option<Keybind>,
44 |     pub rebase: Option<Keybind>,
45 | 
46 |     pub push: Option<Keybind>,
47 |     pub push_new: Option<Keybind>,
48 |     pub push_all: Option<Keybind>,
49 |     pub push_all_new: Option<Keybind>,
50 |     pub fetch: Option<Keybind>,
51 |     pub fetch_all: Option<Keybind>,
52 | 
53 |     pub open_help: Option<Keybind>,
54 | }
55 | 


--------------------------------------------------------------------------------
/src/ui/message_popup.rs:
--------------------------------------------------------------------------------
 1 | use anyhow::Result;
 2 | use ratatui::{
 3 |     Frame,
 4 |     crossterm::event::Event,
 5 |     layout::{Alignment, Rect},
 6 |     style::{Color, Style, Stylize},
 7 |     text::{Span, Text},
 8 |     widgets::{BorderType, Borders, block::Title},
 9 | };
10 | use tui_confirm_dialog::PopupMessage;
11 | 
12 | use crate::{ComponentInputResult, commander::Commander, ui::Component};
13 | 
14 | pub struct MessagePopup<'a> {
15 |     pub title: Title<'a>,
16 |     pub messages: Text<'a>,
17 |     pub text_align: Option<Alignment>,
18 | }
19 | 
20 | impl Component for MessagePopup<'_> {
21 |     /// Render the parent into the area.
22 |     fn draw(&mut self, f: &mut Frame<'_>, area: Rect) -> Result<()> {
23 |         let mut title = self.title.clone();
24 |         title.content.spans = [
25 |             vec![Span::raw(" ")],
26 |             title.content.spans,
27 |             vec![Span::raw(" ")],
28 |         ]
29 |         .concat();
30 | 
31 |         title.content = title.content.fg(Color::Cyan).bold();
32 | 
33 |         let text_align = match self.text_align {
34 |             Some(align) => align,
35 |             None => Alignment::Center,
36 |         };
37 | 
38 |         // TODO: Support scrolling long messages
39 |         let popup = PopupMessage::new(title, self.messages.clone())
40 |             .title_alignment(Alignment::Center)
41 |             .text_alignment(text_align)
42 |             .borders(Borders::ALL)
43 |             .border_type(BorderType::Rounded)
44 |             .border_style(Style::default().fg(Color::Green));
45 | 
46 |         f.render_widget(popup, area);
47 | 
48 |         Ok(())
49 |     }
50 | 
51 |     fn input(&mut self, _commander: &mut Commander, _event: Event) -> Result<ComponentInputResult> {
52 |         Ok(ComponentInputResult::NotHandled)
53 |     }
54 | }
55 | 


--------------------------------------------------------------------------------
/src/keybinds/keybinds_store.rs:
--------------------------------------------------------------------------------
 1 | use std::collections::HashMap;
 2 | 
 3 | use ratatui::crossterm::event::KeyEvent;
 4 | 
 5 | use super::{Keybind, Shortcut};
 6 | 
 7 | #[derive(Debug)]
 8 | pub struct KeybindsStore<A> {
 9 |     shortcut_actions: HashMap<Shortcut, A>,
10 | }
11 | 
12 | impl<A> KeybindsStore<A>
13 | where
14 |     A: Clone + Eq,
15 | {
16 |     pub fn match_event(&self, event: KeyEvent) -> Option<A> {
17 |         self.shortcut_actions
18 |             .get(&Shortcut::from_event(event))
19 |             .map(ToOwned::to_owned)
20 |     }
21 |     pub fn add_action(&mut self, shortcut: Shortcut, action: A) {
22 |         self.shortcut_actions.insert(shortcut, action);
23 |     }
24 |     pub fn get_shortcuts(&self, action: A) -> Vec<Shortcut> {
25 |         self.shortcut_actions
26 |             .iter()
27 |             .filter(|(_, a)| **a == action)
28 |             .map(|(s, _)| *s)
29 |             .collect()
30 |     }
31 |     pub fn replace_action_from_config(&mut self, action: A, key: &Keybind) {
32 |         // just ignore this case
33 |         if matches!(key, Keybind::Enable(true)) {
34 |             return;
35 |         }
36 | 
37 |         self.remove_action(action.clone());
38 |         match key {
39 |             Keybind::Single(s) => self.add_action(*s, action),
40 |             Keybind::Multiple(list) => {
41 |                 for s in list {
42 |                     self.add_action(*s, action.clone());
43 |                 }
44 |             }
45 |             // in case Enable(false) action is only removed
46 |             Keybind::Enable(_) => (),
47 |         }
48 |     }
49 |     /// Remove all shortcuts for specified action
50 |     fn remove_action(&mut self, action: A) {
51 |         self.shortcut_actions.retain(|_, a| action != *a);
52 |     }
53 |     pub fn len(&self) -> usize {
54 |         self.shortcut_actions.len()
55 |     }
56 | }
57 | 
58 | impl<A> Default for KeybindsStore<A> {
59 |     fn default() -> Self {
60 |         Self {
61 |             shortcut_actions: HashMap::new(),
62 |         }
63 |     }
64 | }
65 | 


--------------------------------------------------------------------------------
/src/keybinds/rebase_popup.rs:
--------------------------------------------------------------------------------
 1 | /*! Key bindings specific for rebase popup */
 2 | 
 3 | use ratatui::crossterm::event::KeyEvent;
 4 | use std::str::FromStr; // used by set_keybinds macro
 5 | 
 6 | use super::{Shortcut, keybinds_store::KeybindsStore};
 7 | use crate::set_keybinds;
 8 | 
 9 | /// How should rebase cut revisions from source
10 | #[derive(Debug, PartialEq, Eq, Clone, Copy)]
11 | pub enum CutOption {
12 |     IncludeDescendants, // -s
13 |     IncludeBranch,      // -b
14 |     SingleRevision,     // -r
15 | }
16 | 
17 | /// How should rebase paste revisions at target
18 | #[derive(Debug, PartialEq, Eq, Clone, Copy)]
19 | pub enum PasteOption {
20 |     NewBranch,    // -d
21 |     InsertAfter,  // -A
22 |     InsertBefore, // -B
23 | }
24 | 
25 | /// Actions available inside a RebasePopup
26 | #[derive(Debug, PartialEq, Eq, Clone, Copy)]
27 | pub enum PopupAction {
28 |     None,
29 |     Ok,
30 |     Cancel,
31 |     SetSourceMode(CutOption),
32 |     SetTargetMode(PasteOption),
33 | }
34 | 
35 | fn default_keybinds() -> KeybindsStore<PopupAction> {
36 |     let mut keys = KeybindsStore::<PopupAction>::default();
37 |     set_keybinds!(
38 |         keys,
39 |         PopupAction::Ok => "enter",
40 |         PopupAction::Cancel => "esc",
41 |         PopupAction::Cancel => "q",
42 |         PopupAction::SetSourceMode(CutOption::IncludeDescendants) => "s",
43 |         PopupAction::SetSourceMode(CutOption::IncludeBranch) => "b",
44 |         PopupAction::SetSourceMode(CutOption::SingleRevision) => "r",
45 |         PopupAction::SetTargetMode(PasteOption::NewBranch) => "d",
46 |         PopupAction::SetTargetMode(PasteOption::InsertAfter) => "shift+a",
47 |         PopupAction::SetTargetMode(PasteOption::InsertBefore) => "shift+b",
48 |     );
49 |     keys
50 | }
51 | 
52 | #[derive(Debug)]
53 | pub struct Keybinds {
54 |     keys: KeybindsStore<PopupAction>,
55 | }
56 | 
57 | impl Default for Keybinds {
58 |     fn default() -> Self {
59 |         Self {
60 |             keys: default_keybinds(),
61 |         }
62 |     }
63 | }
64 | 
65 | impl Keybinds {
66 |     pub fn match_event(&self, event: KeyEvent) -> PopupAction {
67 |         if let Some(action) = self.keys.match_event(event) {
68 |             action
69 |         } else {
70 |             PopupAction::None
71 |         }
72 |     }
73 | }
74 | 


--------------------------------------------------------------------------------
/.github/workflows/publish.yml:
--------------------------------------------------------------------------------
 1 | name: Release
 2 | 
 3 | on:
 4 |   release:
 5 |     types: [created]
 6 | 
 7 | permissions: read-all
 8 | 
 9 | env:
10 |   CARGO_INCREMENTAL: 0
11 | 
12 | jobs:
13 |   publish-binaries:
14 |     name: Publish binaries
15 |     permissions:
16 |       contents: write
17 |     strategy:
18 |       fail-fast: false
19 |       matrix:
20 |         build: [linux-musl, macos-x86_64, macos-aarch64, win-msvc]
21 |         include:
22 |           - build: linux-musl
23 |             os: ubuntu-22.04
24 |             target: x86_64-unknown-linux-musl
25 |           - build: macos-x86_64
26 |             os: macos-13
27 |             target: x86_64-apple-darwin
28 |           - build: macos-aarch64
29 |             os: macos-14
30 |             target: aarch64-apple-darwin
31 |           - build: win-msvc
32 |             os: windows-2022
33 |             target: x86_64-pc-windows-msvc
34 |     runs-on: ${{ matrix.os }}
35 |     steps:
36 |       - uses: actions/checkout@v4
37 |       - name: Install Rust
38 |         uses: dtolnay/rust-toolchain@stable
39 |         with:
40 |           target: ${{ matrix.target }}
41 |       - name: Build release binary
42 |         run: cargo build --target ${{ matrix.target }} --verbose --release --locked
43 |       - name: Build archive
44 |         shell: bash
45 |         run: |
46 |           # TODO: Create a third action to combine both in one archive
47 |           outdir="target/${{ matrix.target }}/release"
48 |           name="lazyjj-${{ github.event.release.tag_name }}-${{ matrix.target }}"
49 |           cd "$outdir"
50 |           ls # Debug
51 |           if [ "${{ matrix.os }}" = "windows-2022" ]; then
52 |             7z a "../../../$name.zip" lazyjj.exe
53 |             echo "ASSET=$name.zip" >> $GITHUB_ENV
54 |           else
55 |             tar czf "../../../$name.tar.gz" lazyjj
56 |             echo "ASSET=$name.tar.gz" >> $GITHUB_ENV
57 |           fi
58 |       - name: Upload release archive
59 |         uses: shogo82148/actions-upload-release-asset@v1.7.5
60 |         env:
61 |           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
62 |         with:
63 |           upload_url: ${{ github.event.release.upload_url }}
64 |           asset_path: ${{ env.ASSET }}
65 |           asset_name: ${{ env.ASSET }}
66 |           asset_content_type: application/octet-stream
67 |   publish-cargo:
68 |     name: Publish crates.io
69 |     runs-on: ubuntu-latest
70 |     steps:
71 |       - uses: actions/checkout@v4
72 |       - name: Install Rust
73 |         uses: dtolnay/rust-toolchain@stable
74 |         with:
75 |           target: x86_64-unknown-linux-musl
76 |       - name: Publish to crates.io
77 |         run: cargo publish
78 |         env:
79 |           CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}
80 | 


--------------------------------------------------------------------------------
/src/ui/utils.rs:
--------------------------------------------------------------------------------
  1 | use ratatui::layout::{Constraint, Direction, Layout, Rect};
  2 | 
  3 | pub fn centered_rect(r: Rect, percent_x: u16, percent_y: u16) -> Rect {
  4 |     let popup_layout = Layout::default()
  5 |         .direction(Direction::Vertical)
  6 |         .constraints([
  7 |             Constraint::Percentage((100 - percent_y) / 2),
  8 |             Constraint::Percentage(percent_y),
  9 |             Constraint::Percentage((100 - percent_y) / 2),
 10 |         ])
 11 |         .split(r);
 12 | 
 13 |     Layout::default()
 14 |         .direction(Direction::Horizontal)
 15 |         .constraints([
 16 |             Constraint::Percentage((100 - percent_x) / 2),
 17 |             Constraint::Percentage(percent_x),
 18 |             Constraint::Percentage((100 - percent_x) / 2),
 19 |         ])
 20 |         .split(popup_layout[1])[1]
 21 | }
 22 | 
 23 | pub fn centered_rect_line_height(r: Rect, percent_x: u16, lines_y: u16) -> Rect {
 24 |     let popup_layout = Layout::default()
 25 |         .direction(Direction::Vertical)
 26 |         .constraints([
 27 |             Constraint::Fill(1),
 28 |             Constraint::Length(lines_y),
 29 |             Constraint::Fill(1),
 30 |         ])
 31 |         .split(r);
 32 | 
 33 |     Layout::default()
 34 |         .direction(Direction::Horizontal)
 35 |         .constraints([
 36 |             Constraint::Percentage((100 - percent_x) / 2),
 37 |             Constraint::Percentage(percent_x),
 38 |             Constraint::Percentage((100 - percent_x) / 2),
 39 |         ])
 40 |         .split(popup_layout[1])[1]
 41 | }
 42 | 
 43 | /// replaces tabs in a string by spaces
 44 | ///
 45 | /// ratatui doesn't work well displaying tabs, so any
 46 | /// string that is rendered and might contain tabs
 47 | /// needs to have the tabs converted to spaces.
 48 | ///
 49 | /// this function aligns tabs in the input string to
 50 | /// virtual tab stops 4 spaces apart, taking care
 51 | /// to count ansi control sequences as zero width.
 52 | pub fn tabs_to_spaces(line: &str) -> String {
 53 |     const TAB_WIDTH: usize = 4;
 54 | 
 55 |     enum AnsiState {
 56 |         Neutral,
 57 |         Escape,
 58 |         Csi,
 59 |     }
 60 | 
 61 |     let mut out = String::new();
 62 |     let mut x = 0;
 63 |     let mut ansi_state = AnsiState::Neutral;
 64 |     for c in line.chars() {
 65 |         match ansi_state {
 66 |             AnsiState::Neutral => {
 67 |                 if c == '\t' {
 68 |                     loop {
 69 |                         out.push(' ');
 70 |                         x += 1;
 71 |                         if x % TAB_WIDTH == 0 {
 72 |                             break;
 73 |                         }
 74 |                     }
 75 |                 } else {
 76 |                     out.push(c);
 77 |                     if c == '\x1b' {
 78 |                         ansi_state = AnsiState::Escape;
 79 |                     } else {
 80 |                         x += 1;
 81 |                     }
 82 |                 }
 83 |                 if c == '\r' || c == '\n' {
 84 |                     x = 0;
 85 |                 }
 86 |             }
 87 |             AnsiState::Escape => {
 88 |                 out.push(c);
 89 |                 ansi_state = if c == '[' {
 90 |                     AnsiState::Csi
 91 |                 } else {
 92 |                     AnsiState::Neutral
 93 |                 };
 94 |             }
 95 |             AnsiState::Csi => {
 96 |                 out.push(c);
 97 |                 if ('\x40'..='\x7f').contains(&c) {
 98 |                     ansi_state = AnsiState::Neutral;
 99 |                 }
100 |             }
101 |         }
102 |     }
103 |     out
104 | }
105 | 


--------------------------------------------------------------------------------
/src/ui/help_popup.rs:
--------------------------------------------------------------------------------
  1 | use ratatui::{
  2 |     crossterm::event::{self, Event, KeyCode},
  3 |     layout::{Constraint, Direction, Layout},
  4 |     style::Stylize,
  5 |     text::Span,
  6 |     widgets::{Block, Clear, Row, Table},
  7 | };
  8 | 
  9 | use crate::{
 10 |     ComponentInputResult,
 11 |     ui::{Component, styles::create_popup_block, utils::centered_rect},
 12 | };
 13 | 
 14 | pub struct HelpPopup {
 15 |     pub left_items: Vec<(String, String)>,
 16 |     pub right_items: Vec<(String, String)>,
 17 |     height: u16,
 18 |     scroll: usize,
 19 | }
 20 | 
 21 | impl HelpPopup {
 22 |     pub fn new(left_items: Vec<(String, String)>, right_items: Vec<(String, String)>) -> Self {
 23 |         Self {
 24 |             left_items,
 25 |             right_items,
 26 |             height: 0,
 27 |             // Can't use TableState as it's broken: https://github.com/ratatui-org/ratatui/issues/1179
 28 |             scroll: 0,
 29 |         }
 30 |     }
 31 | 
 32 |     fn create_table(&self, items: &[(String, String)], title: String) -> Table<'_> {
 33 |         let items: Vec<&(String, String)> = items.iter().skip(self.scroll).collect();
 34 | 
 35 |         let max_first_row_width = items.iter().map(|row| row.0.len()).max().unwrap_or(0);
 36 |         let rows: Vec<Row> = items
 37 |             .iter()
 38 |             .map(|row| Row::new([row.0.clone(), row.1.clone()]))
 39 |             .collect();
 40 |         let widths = [
 41 |             Constraint::Length(max_first_row_width as u16 + 2),
 42 |             Constraint::Fill(1),
 43 |         ];
 44 | 
 45 |         Table::new(rows, widths).block(Block::new().title(Span::from(title).bold()))
 46 |     }
 47 | }
 48 | 
 49 | impl Component for HelpPopup {
 50 |     fn draw(
 51 |         &mut self,
 52 |         f: &mut ratatui::prelude::Frame<'_>,
 53 |         area: ratatui::prelude::Rect,
 54 |     ) -> anyhow::Result<()> {
 55 |         let area = centered_rect(area, 60, 60);
 56 |         f.render_widget(Clear, area);
 57 | 
 58 |         let block = create_popup_block("Help");
 59 |         let block_inner = block.inner(area);
 60 |         self.height = block_inner.height;
 61 |         f.render_widget(&block, area);
 62 | 
 63 |         let chunks = Layout::default()
 64 |             .direction(Direction::Horizontal)
 65 |             .constraints([
 66 |                 Constraint::Fill(1),
 67 |                 Constraint::Length(2),
 68 |                 Constraint::Fill(1),
 69 |             ])
 70 |             .split(block_inner);
 71 | 
 72 |         f.render_widget(
 73 |             self.create_table(&self.left_items, "Main panel".into()),
 74 |             chunks[0],
 75 |         );
 76 |         f.render_widget(
 77 |             self.create_table(&self.right_items, "Details panel".into()),
 78 |             chunks[2],
 79 |         );
 80 | 
 81 |         Ok(())
 82 |     }
 83 | 
 84 |     fn input(
 85 |         &mut self,
 86 |         _commander: &mut crate::commander::Commander,
 87 |         event: Event,
 88 |     ) -> anyhow::Result<crate::ComponentInputResult> {
 89 |         if let Event::Key(key) = event
 90 |             && key.kind == event::KeyEventKind::Press
 91 |         {
 92 |             match key.code {
 93 |                 KeyCode::Char('j') => {
 94 |                     let max = self.left_items.len().max(self.right_items.len());
 95 |                     self.scroll = (self.scroll + 1).min(max.saturating_sub(self.height as usize));
 96 |                 }
 97 |                 KeyCode::Char('k') => self.scroll = self.scroll.saturating_sub(1),
 98 |                 _ => return Ok(ComponentInputResult::NotHandled),
 99 |             }
100 | 
101 |             return Ok(ComponentInputResult::Handled);
102 |         }
103 | 
104 |         Ok(ComponentInputResult::NotHandled)
105 |     }
106 | }
107 | 


--------------------------------------------------------------------------------
/src/ui/mod.rs:
--------------------------------------------------------------------------------
  1 | pub mod bookmark_set_popup;
  2 | pub mod bookmarks_tab;
  3 | pub mod command_log_tab;
  4 | pub mod command_popup;
  5 | pub mod files_tab;
  6 | pub mod help_popup;
  7 | pub mod log_tab;
  8 | pub mod message_popup;
  9 | pub mod panel;
 10 | pub mod rebase_popup;
 11 | pub mod styles;
 12 | pub mod utils;
 13 | 
 14 | use std::time::Instant;
 15 | 
 16 | use crate::{
 17 |     ComponentInputResult,
 18 |     app::{App, Tab},
 19 |     commander::{Commander, log::Head},
 20 | };
 21 | use anyhow::Result;
 22 | use ratatui::{
 23 |     Frame,
 24 |     crossterm::event::Event,
 25 |     layout::{Constraint, Direction, Layout, Rect},
 26 |     style::{Color, Style},
 27 |     symbols,
 28 | };
 29 | use ratatui::{prelude::*, widgets::*};
 30 | 
 31 | pub enum ComponentAction {
 32 |     ViewFiles(Head),
 33 |     ViewLog(Head),
 34 |     ChangeHead(Head),
 35 |     SetPopup(Option<Box<dyn Component>>),
 36 |     Multiple(Vec<ComponentAction>),
 37 |     RefreshTab(),
 38 | }
 39 | 
 40 | pub trait Component {
 41 |     // Called when switching to tab
 42 |     fn focus(&mut self, _commander: &mut Commander) -> Result<()> {
 43 |         Ok(())
 44 |     }
 45 | 
 46 |     fn update(&mut self, _commander: &mut Commander) -> Result<Option<ComponentAction>> {
 47 |         Ok(None)
 48 |     }
 49 | 
 50 |     fn draw(&mut self, f: &mut Frame<'_>, area: Rect) -> Result<()>;
 51 | 
 52 |     fn input(&mut self, commander: &mut Commander, event: Event) -> Result<ComponentInputResult>;
 53 | }
 54 | 
 55 | pub fn ui(f: &mut Frame, app: &mut App) -> Result<()> {
 56 |     let start_time = Instant::now();
 57 | 
 58 |     let chunks = Layout::default()
 59 |         .direction(Direction::Vertical)
 60 |         .constraints([Constraint::Length(3), Constraint::Min(1)])
 61 |         .split(f.area());
 62 | 
 63 |     let header_chunks = Layout::default()
 64 |         .direction(Direction::Horizontal)
 65 |         .constraints([Constraint::Percentage(50), Constraint::Percentage(50)])
 66 |         .split(chunks[0]);
 67 | 
 68 |     {
 69 |         let tabs = Tabs::new(
 70 |             Tab::VALUES
 71 |                 .iter()
 72 |                 .enumerate()
 73 |                 .map(|(i, tab)| format!("[{}] {}", i + 1, tab)),
 74 |         )
 75 |         .block(
 76 |             Block::bordered()
 77 |                 .title(" Tabs ")
 78 |                 .border_type(BorderType::Rounded),
 79 |         )
 80 |         .highlight_style(Style::default().bg(app.env.config.highlight_color()))
 81 |         .select(
 82 |             Tab::VALUES
 83 |                 .iter()
 84 |                 .position(|tab| tab == &app.current_tab)
 85 |                 .unwrap_or(0),
 86 |         )
 87 |         .divider(symbols::line::VERTICAL);
 88 | 
 89 |         f.render_widget(tabs, header_chunks[0]);
 90 |     }
 91 |     {
 92 |         let tabs = Paragraph::new("q: quit | ?: help | R: refresh | 1/2/3/4: change tab")
 93 |             .fg(Color::DarkGray)
 94 |             .block(
 95 |                 Block::bordered()
 96 |                     .title(" lazyjj ")
 97 |                     .border_type(BorderType::Rounded)
 98 |                     .fg(Color::default()),
 99 |             );
100 | 
101 |         f.render_widget(tabs, header_chunks[1]);
102 |     }
103 | 
104 |     if let Some(current_tab) = app.get_current_tab() {
105 |         current_tab.draw(f, chunks[1])?;
106 |     }
107 | 
108 |     if let Some(popup) = app.popup.as_mut() {
109 |         popup.draw(f, f.area())?;
110 |     }
111 | 
112 |     {
113 |         let paragraph = Paragraph::new(format!("{}ms", start_time.elapsed().as_millis()))
114 |             .alignment(Alignment::Right);
115 |         let position = Rect {
116 |             x: 0,
117 |             y: 1,
118 |             height: 1,
119 |             width: f.area().width - 1,
120 |         };
121 |         f.render_widget(paragraph, position);
122 |     }
123 | 
124 |     Ok(())
125 | }
126 | 


--------------------------------------------------------------------------------
/.github/workflows/test.yml:
--------------------------------------------------------------------------------
  1 | name: Test & Build
  2 | 
  3 | on:
  4 |   push:
  5 |     branches:
  6 |       - main
  7 |   pull_request:
  8 | 
  9 | permissions: read-all
 10 | 
 11 | env:
 12 |   CARGO_INCREMENTAL: 0
 13 |   CARGO_PROFILE_DEV_DEBUG: 0
 14 | 
 15 | jobs:
 16 |   test:
 17 |     name: Test
 18 |     strategy:
 19 |       fail-fast: false
 20 |       matrix:
 21 |         build: [linux-musl, macos-x86_64, macos-aarch64, win-msvc]
 22 |         include:
 23 |           - build: linux-musl
 24 |             os: ubuntu-22.04
 25 |             target: x86_64-unknown-linux-musl
 26 |           - build: macos-x86_64
 27 |             os: macos-13
 28 |             target: x86_64-apple-darwin
 29 |           - build: macos-aarch64
 30 |             os: macos-14
 31 |             target: aarch64-apple-darwin
 32 |           - build: win-msvc
 33 |             os: windows-2022
 34 |             target: x86_64-pc-windows-msvc
 35 |     runs-on: ${{ matrix.os }}
 36 | 
 37 |     timeout-minutes: 15
 38 |     # this often fails for some reason because of cargo-binstall
 39 |     continue-on-error: ${{ matrix.build == 'macos-aarch64' || matrix.build == 'macos-x86_64' }}
 40 | 
 41 |     steps:
 42 |       - uses: actions/checkout@v4
 43 |       - name: Install Rust
 44 |         uses: dtolnay/rust-toolchain@stable
 45 |         with:
 46 |           target: ${{ matrix.target }}
 47 |       - name: Install cargo-binstall
 48 |         uses: cargo-bins/cargo-binstall@main
 49 |       - name: Install jj
 50 |         run: cargo binstall --no-confirm --strategies crate-meta-data jj-cli
 51 |         env:
 52 |           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 53 |       - name: Test
 54 |         run: cargo test --all-targets --verbose
 55 |         env:
 56 |           RUST_BACKTRACE: 1
 57 | 
 58 |   build:
 59 |     name: Build
 60 |     strategy:
 61 |       fail-fast: false
 62 |       matrix:
 63 |         build: [linux-musl, macos-x86_64, macos-aarch64, win-msvc]
 64 |         include:
 65 |           - build: linux-musl
 66 |             os: ubuntu-24.04
 67 |             target: x86_64-unknown-linux-musl
 68 |           - build: macos-x86_64
 69 |             os: macos-13
 70 |             target: x86_64-apple-darwin
 71 |           - build: macos-aarch64
 72 |             os: macos-14
 73 |             target: aarch64-apple-darwin
 74 |           - build: win-msvc
 75 |             os: windows-2022
 76 |             target: x86_64-pc-windows-msvc
 77 |     runs-on: ${{ matrix.os }}
 78 | 
 79 |     timeout-minutes: 15
 80 | 
 81 |     steps:
 82 |       - uses: actions/checkout@v4
 83 |       - name: Install Rust
 84 |         uses: dtolnay/rust-toolchain@stable
 85 |         with:
 86 |           target: ${{ matrix.target }}
 87 |       - name: Build lazyjj
 88 |         run: cargo build --target ${{ matrix.target }} --verbose --release --locked
 89 |       - name: Build archive
 90 |         shell: bash
 91 |         run: |
 92 |           # TODO: Create a third action to combine both in one archive
 93 |           short_sha=`echo ${GITHUB_SHA} | cut -c1-8`
 94 |           outdir="target/${{ matrix.target }}/release"
 95 |           name="lazyjj-$short_sha-${{ matrix.target }}"
 96 |           cd "$outdir"
 97 |           ls # Debug
 98 |           if [ "${{ matrix.os }}" = "windows-2022" ]; then
 99 |             7z a "../../../$name.zip" lazyjj.exe
100 |             echo "ASSET=$name.zip" >> $GITHUB_ENV
101 |           else
102 |             tar czf "../../../$name.tar.gz" lazyjj
103 |             echo "ASSET=$name.tar.gz" >> $GITHUB_ENV
104 |           fi
105 |       - name: Upload archive
106 |         uses: actions/upload-artifact@v4
107 |         with:
108 |           name: ${{ env.ASSET }}
109 |           path: ${{ env.ASSET }}
110 | 
111 |   clippy:
112 |     name: Clippy
113 |     runs-on: ubuntu-latest
114 |     steps:
115 |       - uses: actions/checkout@v4
116 |       - name: Install Rust
117 |         uses: dtolnay/rust-toolchain@stable
118 |         with:
119 |           components: clippy
120 |       - name: Clippy
121 |         run: cargo clippy --workspace --all-targets --verbose -- -D warnings
122 | 
123 |   rustfmt:
124 |     name: Format
125 |     runs-on: ubuntu-latest
126 |     steps:
127 |       - uses: actions/checkout@v4
128 |       - name: Install Rust
129 |         uses: dtolnay/rust-toolchain@stable
130 |         with:
131 |           components: rustfmt
132 |       - run: cargo fmt --all -- --check
133 | 


--------------------------------------------------------------------------------
/src/ui/command_popup.rs:
--------------------------------------------------------------------------------
  1 | use anyhow::{Context, Result};
  2 | use ratatui::{
  3 |     crossterm::event::{Event, KeyCode},
  4 |     layout::{Alignment, Constraint, Direction, Layout},
  5 |     style::{Color, Style, Stylize},
  6 |     text::Span,
  7 |     widgets::{Block, BorderType, Borders, Clear, Paragraph},
  8 | };
  9 | use shell_words::split;
 10 | use tui_textarea::TextArea;
 11 | 
 12 | use crate::{
 13 |     ComponentInputResult,
 14 |     commander::Commander,
 15 |     ui::{
 16 |         Component, ComponentAction, message_popup::MessagePopup, utils::centered_rect_line_height,
 17 |     },
 18 | };
 19 | 
 20 | pub struct CommandPopup<'a> {
 21 |     command_textarea: TextArea<'a>,
 22 | }
 23 | 
 24 | impl CommandPopup<'_> {
 25 |     pub fn new() -> Self {
 26 |         Self {
 27 |             command_textarea: TextArea::new(vec![]),
 28 |         }
 29 |     }
 30 | }
 31 | 
 32 | impl Component for CommandPopup<'_> {
 33 |     fn draw(
 34 |         &mut self,
 35 |         f: &mut ratatui::Frame<'_>,
 36 |         area: ratatui::prelude::Rect,
 37 |     ) -> anyhow::Result<()> {
 38 |         let block = Block::bordered()
 39 |             .title(Span::styled(" Command ", Style::new().bold().cyan()))
 40 |             .title_alignment(Alignment::Center)
 41 |             .border_type(BorderType::Rounded)
 42 |             .border_style(Style::default().fg(Color::Green));
 43 |         let area = centered_rect_line_height(area, 60, 5);
 44 |         f.render_widget(Clear, area);
 45 |         f.render_widget(&block, area);
 46 | 
 47 |         let popup_chunks = Layout::default()
 48 |             .direction(Direction::Vertical)
 49 |             .constraints([Constraint::Fill(1), Constraint::Length(2)])
 50 |             .split(block.inner(area));
 51 | 
 52 |         f.render_widget(&self.command_textarea, popup_chunks[0]);
 53 | 
 54 |         let help = Paragraph::new(vec!["Enter: run | Escape: cancel".into()])
 55 |             .fg(Color::DarkGray)
 56 |             .alignment(Alignment::Center)
 57 |             .block(
 58 |                 Block::default()
 59 |                     .borders(Borders::TOP)
 60 |                     .border_type(BorderType::Rounded)
 61 |                     .border_style(Style::default().fg(Color::DarkGray)),
 62 |             );
 63 | 
 64 |         f.render_widget(help, popup_chunks[1]);
 65 |         Ok(())
 66 |     }
 67 | 
 68 |     fn input(
 69 |         &mut self,
 70 |         commander: &mut Commander,
 71 |         event: Event,
 72 |     ) -> anyhow::Result<ComponentInputResult> {
 73 |         if let Event::Key(key) = event {
 74 |             match key.code {
 75 |                 KeyCode::Enter => {
 76 |                     let command_input = self.command_textarea.lines().join(" ");
 77 |                     let mut command_input = command_input.as_str();
 78 | 
 79 |                     if command_input.trim().is_empty() {
 80 |                         return Ok(ComponentInputResult::HandledAction(
 81 |                             ComponentAction::SetPopup(None),
 82 |                         ));
 83 |                     }
 84 | 
 85 |                     if command_input == "jj" {
 86 |                         command_input = "";
 87 |                     }
 88 |                     command_input = command_input.trim_start_matches("jj ");
 89 | 
 90 |                     let res: Result<String> = split(command_input)
 91 |                         .context("Failed to split command input")
 92 |                         .and_then(|command| {
 93 |                             // TODO: Support color. PopupMessage (used by MessagePopup) breaks when colored
 94 |                             Ok(commander.execute_jj_command(command, false, false)?)
 95 |                         });
 96 |                     let message = match res {
 97 |                         Ok(str) => str,
 98 |                         Err(err) => [
 99 |                             format!("Failed to execute jj command: jj {command_input}"),
100 |                             String::new(),
101 |                             err.to_string(),
102 |                         ]
103 |                         .join("\n"),
104 |                     };
105 | 
106 |                     if message.trim().is_empty() {
107 |                         return Ok(ComponentInputResult::HandledAction(
108 |                             ComponentAction::Multiple(vec![
109 |                                 ComponentAction::SetPopup(None),
110 |                                 ComponentAction::RefreshTab(),
111 |                             ]),
112 |                         ));
113 |                     }
114 | 
115 |                     return Ok(ComponentInputResult::HandledAction(
116 |                         ComponentAction::Multiple(vec![
117 |                             ComponentAction::SetPopup(Some(Box::new(MessagePopup {
118 |                                 title: format!("jj {command_input}").into(),
119 |                                 messages: message.into(),
120 |                                 text_align: Alignment::Left.into(),
121 |                             }))),
122 |                             ComponentAction::RefreshTab(),
123 |                         ]),
124 |                     ));
125 |                 }
126 |                 KeyCode::Esc => {
127 |                     return Ok(ComponentInputResult::HandledAction(
128 |                         ComponentAction::SetPopup(None),
129 |                     ));
130 |                 }
131 |                 _ => {}
132 |             }
133 |         };
134 |         self.command_textarea.input(event);
135 |         Ok(ComponentInputResult::Handled)
136 |     }
137 | }
138 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # lazyjj
  2 | 
  3 | TUI for [Jujutsu/jj](https://github.com/martinvonz/jj). Built in Rust with Ratatui. Interacts with `jj` CLI.
  4 | 
  5 | https://github.com/Cretezy/lazyjj/assets/2672503/b5e6b4f1-ebdb-448f-af9e-361e86f0c148
  6 | 
  7 | ## Features
  8 | 
  9 | - Log
 10 |   - Scroll through the jj log and view change details in side panel
 11 |   - Create new changes from selected change with `n`
 12 |   - Edit changes with `e`/`E`
 13 |   - Describe changes with `d`
 14 |   - Abandon changes with `a`
 15 |   - Toggle between color words and git diff with `p`
 16 |   - See different revset with `r`
 17 |   - Set a bookmark to selected change with `b`
 18 |   - Fetch/push with `f`/`p`
 19 |   - Squash current changes to selected change with `s`/`S`
 20 | - Files
 21 |   - View files in current change and diff in side panel
 22 |   - See a change's files from the log tab with `Enter`
 23 |   - View conflicts list in current change
 24 |   - Toggle between color words and git diff with `w`
 25 |   - Untrack file with `x`
 26 | - Bookmarks
 27 |   - View list of bookmarks, including from all remotes with `a`
 28 |   - Create with `c`, rename with `r`, delete with `d`, forget with `f`
 29 |   - Track bookmarks with `t`, untrack bookmarks with `T`
 30 |   - Create new change with `n`, edit change with `e`/`E`
 31 | - Command log: View every command lazyjj executes
 32 | - Config: Configure lazyjj with your jj config
 33 | - Command box: Run jj commands directly in lazyjj with `:`
 34 | - Help: See all key mappings with `?`
 35 | 
 36 | ## Setup
 37 | 
 38 | Make sure you have [`jj`](https://martinvonz.github.io/jj/latest/install-and-setup) installed first.
 39 | 
 40 | - With [`cargo binstall`](https://github.com/cargo-bins/cargo-binstall): `cargo binstall lazyjj`
 41 | - With `cargo install`: `cargo install lazyjj --locked` (may take a few moments to compile)
 42 | - With pre-built binaries: [View releases](https://github.com/Cretezy/lazyjj/releases)
 43 | - For Arch Linux: `pacman -S lazyjj`
 44 | 
 45 | To build and install a pre-release version: `cargo install --git https://github.com/Cretezy/lazyjj.git --locked`
 46 | 
 47 | ## Configuration
 48 | 
 49 | You can optionally configure the following options through your jj config:
 50 | 
 51 | - `lazyjj.highlight-color`: Changes the highlight color. Can use named colors. Defaults to `#323264`
 52 | - `lazyjj.diff-format`: Change the default diff format. Can be `color-words` or `git`. Defaults to `color_words`
 53 |   - If `lazyjj.diff-format` is not set but `ui.diff.format` is, the latter will be used
 54 | - `lazyjj.diff-tool`: Specify which diff tool to use by default
 55 |   - If `lazyjj.diff-tool` is not set but `ui.diff.tool` is, the latter will be used
 56 | - `lazyjj.bookmark-prefix`: Change the bookmark name prefix for generated bookmark names. Defaults to `push-`
 57 |   - If `lazyjj.bookmark-prefix` is not set but `git.push-bookmark-prefix` is, the latter will be used
 58 | - `lazyjj.layout`: Changes the layout of the main and details panel. Can be `horizontal` (default) or `vertical`
 59 | - `lazyjj.layout-percent`: Changes the layout split of the main page. Should be number between 0 and 100. Defaults to `50`
 60 | 
 61 | Example: `jj config set --user lazyjj.diff-format "color-words"` (for storing in [user config file](https://martinvonz.github.io/jj/latest/config/#user-config-file), repo config is also supported)
 62 | 
 63 | ## Usage
 64 | 
 65 | To start lazyjj for the repository in the current directory: `lazyjj`
 66 | 
 67 | To use a different repository: `lazyjj --path ~/path/to/repo`
 68 | 
 69 | To start with a different default revset: `lazyjj -r '::@'`
 70 | 
 71 | ## Key mappings
 72 | 
 73 | See all key mappings for the current tab with `?`.
 74 | 
 75 | ### Basic navigation
 76 | 
 77 | - Quit with `q`
 78 | - Change tab with `1`/`2`/`3` or with `h`/`l`
 79 | - Scrolling in main panel
 80 |   - Scroll down/up by one line with `j`/`k` or down/up arrow
 81 |   - Scroll down/up by half page with `J`/`K` or down/up arrow
 82 | - Scrolling in details panel
 83 |   - Scroll down/up by one line with `Ctrl+e`/`Ctrl+y`
 84 |   - Scroll down/up by a half page with `Ctrl+d`/`Ctrl+u`
 85 |   - Scroll down/up by a full page with `Ctrl+f`/`Ctrl+b`
 86 | - Open a command popup to run jj commands using `:` (jj prefix not required, e.g. write `new main` instead of `jj new main`)
 87 | 
 88 | ### Log tab
 89 | 
 90 | - Select current change with `@`
 91 | - View change files in files tab with `Enter`
 92 | - Display different revset with `r` (`jj log -r`)
 93 | - Change details panel diff format between color words (default) and Git (and diff tool if set) with `w`
 94 | - Toggle details panel wrapping with `W`
 95 | - Create new change after highlighted change with `n` (`jj new`)
 96 |   - Create new change and describe with `N` (`jj new -m`)
 97 | - Edit highlighted change with `e` (`jj edit`)
 98 |   - Edit highlighted change ignoring immutability with `E` (`jj edit --ignore-immutable`)
 99 | - Abandon a change with `a` (`jj abandon`)
100 | - Describe the highlighted change with `d` (`jj describe`)
101 |   - Save with `Ctrl+s`
102 |   - Cancel with `Esc`
103 | - Set a bookmark to the highlighted change with `b` (`jj bookmark set`)
104 |   - Scroll in bookmark list with `j`/`k`
105 |   - Create a new bookmark with `c`
106 |   - Use auto-generated name with `g`
107 | - Squash current changes (in @) to the selected change with `s` (`jj squash`)
108 |   - Squash current changes to the selected change ignoring immutability with `S` (`jj squash --ignore-immutable`)
109 | - Git fetch with `f` (`jj git fetch`)
110 |   - Git fetch all remotes with `F` (`jj git fetch --all-remotes`)
111 | - Git push with `p` (`jj git push`)
112 |   - Git push all bookmarks with `P` (`jj git push --all`)
113 |   - Use `Ctrl+p` or `Ctrl+P` to include pushing new bookmarks (`--allow-new`)
114 | 
115 | ### Files tab
116 | 
117 | - Select current change with `@`
118 | - Change details panel diff format between color words (default) and Git (and diff tool if set) with `w`
119 | - Toggle details panel wrapping with `W`
120 | 
121 | ### Bookmarks tab
122 | 
123 | - Show bookmarks with all remotes with `a` (`jj bookmark list --all`)
124 | - Create a bookmark with `c` (`jj bookmark create`)
125 | - Rename a bookmark with `r` (`jj bookmark rename`)
126 | - Delete a bookmark with `d` (`jj bookmark delete`)
127 | - Forget a bookmark with `f` (`jj bookmark forget`)
128 | - Track a bookmark with `t` (only works for bookmarks with remotes) (`jj bookmark track`)
129 | - Untrack a bookmark with `T` (only works for bookmarks with remotes) (`jj bookmark untrack`)
130 | - Change details panel diff format between color words (default) and Git (and diff tool if set) with `w`
131 | - Toggle details panel wrapping with `W`
132 | - Create a new change after the highlighted bookmark's change with `n` (`jj new`)
133 |   - Create a new change and describe with `N` (`jj new -m`)
134 | - Edit the highlighted bookmark's change with `e` (`jj edit`)
135 |   - Edit the highlighted bookmark's change ignoring immutability with `E` (`jj edit --ignore-immutable`)
136 | 
137 | ### Command log tab
138 | 
139 | - Select latest command with `@`
140 | - Toggle details panel wrapping with `W`
141 | 
142 | ### Configuring
143 | 
144 | Keys can be configured
145 | 
146 | ```toml
147 | [lazyjj.keybinds.log_tab]
148 | save = "ctrl+s"
149 | ```
150 | 
151 | See more in [keybindings.md](docs/keybindings.md)
152 | 
153 | ## Development
154 | 
155 | ### Setup
156 | 
157 | 1. Install Rust and
158 | 2. Clone repository
159 | 3. Run with `cargo run`
160 | 4. Build with `cargo build --release` (output in `target/release`)
161 | 5. You can point it to another jj repo with `--path`: `cargo run -- --path ~/other-repo`
162 | 
163 | ### Logging/Tracing
164 | 
165 | lazyjj has 2 debugging tools:
166 | 
167 | 1. Logging: Enabled by setting `LAZYJJ_LOG=1` when running. Produces a `lazyjj.log` log file
168 | 2. Tracing: Enabled by setting `LAZYJJ_TRACE=1` when running. Produces `trace-*.json` Chrome trace file, for `chrome://tracing` or [ui.perfetto.dev](https://ui.perfetto.dev)
169 | 


--------------------------------------------------------------------------------
/src/keybinds/log_tab.rs:
--------------------------------------------------------------------------------
  1 | use std::str::FromStr;
  2 | 
  3 | use ratatui::crossterm::event::KeyEvent;
  4 | 
  5 | use crate::{make_keybinds_help, set_keybinds, update_keybinds};
  6 | 
  7 | use super::{Shortcut, config::LogTabKeybindsConfig, keybinds_store::KeybindsStore};
  8 | 
  9 | #[derive(Debug)]
 10 | pub struct LogTabKeybinds {
 11 |     // todo: probably split keys for different contexts, e.g when describe_textarea is opened
 12 |     keys: KeybindsStore<LogTabEvent>,
 13 | }
 14 | 
 15 | #[derive(Debug, PartialEq, Eq, Clone, Copy)]
 16 | pub enum LogTabEvent {
 17 |     Save,
 18 |     Cancel,
 19 | 
 20 |     ClosePopup,
 21 | 
 22 |     ScrollDown,
 23 |     ScrollUp,
 24 |     ScrollDownHalf,
 25 |     ScrollUpHalf,
 26 | 
 27 |     FocusCurrent,
 28 |     ToggleDiffFormat,
 29 | 
 30 |     Refresh,
 31 |     CreateNew {
 32 |         describe: bool,
 33 |     },
 34 |     Rebase,
 35 |     Squash {
 36 |         ignore_immutable: bool,
 37 |     },
 38 |     EditChange {
 39 |         ignore_immutable: bool,
 40 |     },
 41 |     Abandon,
 42 |     Describe,
 43 |     EditRevset,
 44 |     SetBookmark,
 45 |     OpenFiles,
 46 | 
 47 |     Push {
 48 |         all_bookmarks: bool,
 49 |         allow_new: bool,
 50 |     },
 51 |     Fetch {
 52 |         all_remotes: bool,
 53 |     },
 54 | 
 55 |     OpenHelp,
 56 | 
 57 |     Unbound,
 58 | }
 59 | 
 60 | impl Default for LogTabKeybinds {
 61 |     fn default() -> Self {
 62 |         let mut keys = KeybindsStore::<LogTabEvent>::default();
 63 |         set_keybinds!(
 64 |             keys,
 65 |             LogTabEvent::Save => "ctrl+s",
 66 |             LogTabEvent::Cancel => "esc",
 67 |             LogTabEvent::ClosePopup => "q",
 68 |             LogTabEvent::ScrollDown => "j",
 69 |             LogTabEvent::ScrollDown => "down",
 70 |             LogTabEvent::ScrollUp => "k",
 71 |             LogTabEvent::ScrollUp => "up",
 72 |             LogTabEvent::ScrollDownHalf => "shift+j",
 73 |             LogTabEvent::ScrollUpHalf => "shift+k",
 74 |             LogTabEvent::FocusCurrent => "@",
 75 |             // todo: move to DetailsKeybindings
 76 |             LogTabEvent::ToggleDiffFormat => "w",
 77 |             LogTabEvent::Refresh => "shift+r",
 78 |             LogTabEvent::Refresh => "f5",
 79 |             LogTabEvent::CreateNew { describe: false } => "n",
 80 |             LogTabEvent::CreateNew { describe: true } => "shift+n",
 81 |             LogTabEvent::Rebase => "ctrl+r",
 82 |             LogTabEvent::Squash { ignore_immutable: false } => "s",
 83 |             LogTabEvent::Squash { ignore_immutable: true } => "shift+s",
 84 |             LogTabEvent::EditChange { ignore_immutable: false } => "e",
 85 |             LogTabEvent::EditChange { ignore_immutable: true } => "shift+e",
 86 |             LogTabEvent::Abandon => "a",
 87 |             LogTabEvent::Describe => "d",
 88 |             LogTabEvent::EditRevset => "r",
 89 |             LogTabEvent::SetBookmark => "b",
 90 |             LogTabEvent::OpenFiles => "enter",
 91 |             event_push(false, false) => "p",
 92 |             event_push(false, true) => "ctrl+p",
 93 |             event_push(true, false) => "shift+p",
 94 |             event_push(true, true) => "ctrl+shift+p",
 95 |             LogTabEvent::Fetch { all_remotes: false } => "f",
 96 |             LogTabEvent::Fetch { all_remotes: true } => "shift+f",
 97 |             LogTabEvent::OpenHelp => "?",
 98 |         );
 99 | 
100 |         Self { keys }
101 |     }
102 | }
103 | 
104 | impl LogTabKeybinds {
105 |     pub fn match_event(&self, event: KeyEvent) -> LogTabEvent {
106 |         if let Some(action) = self.keys.match_event(event) {
107 |             action
108 |         } else {
109 |             LogTabEvent::Unbound
110 |         }
111 |     }
112 |     pub fn extend_from_config(&mut self, config: &LogTabKeybindsConfig) {
113 |         update_keybinds!(
114 |             self.keys,
115 |             LogTabEvent::Save => config.save,
116 |             LogTabEvent::Cancel => config.cancel,
117 |             LogTabEvent::ClosePopup => config.close_popup,
118 |             LogTabEvent::ScrollDown => config.scroll_down,
119 |             LogTabEvent::ScrollUp => config.scroll_up,
120 |             LogTabEvent::ScrollDownHalf => config.scroll_down_half,
121 |             LogTabEvent::ScrollUpHalf => config.scroll_up_half,
122 |             LogTabEvent::FocusCurrent => config.focus_current,
123 |             LogTabEvent::ToggleDiffFormat => config.toggle_diff_format,
124 |             LogTabEvent::Refresh => config.refresh,
125 |             LogTabEvent::CreateNew { describe: false } => config.create_new,
126 |             LogTabEvent::CreateNew { describe: true } => config.create_new_describe,
127 |             LogTabEvent::Squash { ignore_immutable: false } => config.squash,
128 |             LogTabEvent::Squash { ignore_immutable: true } => config.squash_ignore_immutable,
129 |             LogTabEvent::EditChange { ignore_immutable: false } => config.edit_change,
130 |             LogTabEvent::EditChange { ignore_immutable: true } => config.edit_change_ignore_immutable,
131 |             LogTabEvent::Abandon => config.abandon,
132 |             LogTabEvent::Describe => config.describe,
133 |             LogTabEvent::EditRevset => config.edit_revset,
134 |             LogTabEvent::SetBookmark => config.set_bookmark,
135 |             LogTabEvent::OpenFiles => config.open_files,
136 |             LogTabEvent::Rebase => config.rebase,
137 |             event_push(false, false) => config.push,
138 |             event_push(false, true) => config.push_new,
139 |             event_push(true, false) => config.push_all,
140 |             event_push(true, true) => config.push_all_new,
141 |             LogTabEvent::Fetch { all_remotes: false } => config.fetch,
142 |             LogTabEvent::Fetch { all_remotes: true } => config.fetch_all,
143 |             LogTabEvent::OpenHelp => config.open_help,
144 |         );
145 |     }
146 |     pub fn make_main_panel_help(&self) -> Vec<(String, String)> {
147 |         make_keybinds_help!(
148 |             self.keys,
149 |             LogTabEvent::ScrollDown => "scroll down",
150 |             LogTabEvent::ScrollUp => "scroll up",
151 |             LogTabEvent::ScrollDownHalf => "scroll down by ½ page",
152 |             LogTabEvent::ScrollUpHalf => "scroll up by ½ page",
153 |             LogTabEvent::OpenFiles => "see files",
154 |             LogTabEvent::FocusCurrent => "current change",
155 |             LogTabEvent::EditRevset => "set revset",
156 |             LogTabEvent::Describe => "describe change",
157 |             LogTabEvent::EditChange { ignore_immutable: false } => "edit change",
158 |             LogTabEvent::EditChange { ignore_immutable: true } => "edit change ignoring immutability",
159 |             LogTabEvent::CreateNew { describe: false } => "new change",
160 |             LogTabEvent::CreateNew { describe: true } => "new with message",
161 |             LogTabEvent::Abandon => "abandon change",
162 |             LogTabEvent::Rebase => "rebase @ to the selected change",
163 |             LogTabEvent::Squash { ignore_immutable: false } => "squash @ into the selected change",
164 |             LogTabEvent::Squash { ignore_immutable: true } => "squash @ into the selected change ignoring immutability",
165 |             LogTabEvent::SetBookmark => "set bookmark",
166 |             LogTabEvent::Fetch { all_remotes: false } => "git fetch",
167 |             LogTabEvent::Fetch { all_remotes: true } => "git fetch all remotes",
168 |             event_push(false, false) => "git push",
169 |             event_push(false, true) => "git push with new bookmarks",
170 |             event_push(true, false) => "git push all bookmarks, except new",
171 |             event_push(true, true) => "git push all bookmarks",
172 |         )
173 |     }
174 | }
175 | 
176 | fn event_push(all_bookmarks: bool, allow_new: bool) -> LogTabEvent {
177 |     LogTabEvent::Push {
178 |         all_bookmarks,
179 |         allow_new,
180 |     }
181 | }
182 | 
183 | #[test]
184 | fn test_log_tab_keybinds_default() {
185 |     let _ = LogTabKeybinds::default();
186 | }
187 | 


--------------------------------------------------------------------------------
/src/ui/panel/details_panel.rs:
--------------------------------------------------------------------------------
  1 | use ratatui::{
  2 |     crossterm::event::{KeyCode, KeyEvent, KeyModifiers, MouseEvent, MouseEventKind},
  3 |     layout::{Margin, Position, Rect},
  4 |     text::{Line, Text},
  5 |     widgets::{
  6 |         Block, BorderType, Padding, Paragraph, Scrollbar, ScrollbarOrientation, ScrollbarState,
  7 |         Wrap,
  8 |     },
  9 | };
 10 | use tracing::trace;
 11 | 
 12 | /// Details panel used for the right side of each tab.
 13 | /// This handles scrolling and wrapping.
 14 | pub struct DetailsPanel {
 15 |     panel_rect: Rect,
 16 |     scroll: u16,
 17 |     height: u16,
 18 |     lines: u16,
 19 |     wrap: bool,
 20 | }
 21 | 
 22 | /// Transient object holding render data
 23 | pub struct DetailsPanelRenderContext<'a> {
 24 |     panel: &'a mut DetailsPanel,
 25 |     title: Option<Line<'a>>,
 26 |     content: Option<Text<'a>>,
 27 | }
 28 | 
 29 | /// Commands that can be handled by the details panel
 30 | pub enum DetailsPanelEvent {
 31 |     ScrollDown,
 32 |     ScrollUp,
 33 |     ScrollDownHalfPage,
 34 |     ScrollUpHalfPage,
 35 |     ScrollDownPage,
 36 |     ScrollUpPage,
 37 |     ToggleWrap,
 38 | }
 39 | 
 40 | impl<'a> DetailsPanelRenderContext<'a> {
 41 |     pub fn new(panel: &'a mut DetailsPanel) -> Self {
 42 |         Self {
 43 |             panel,
 44 |             title: None,
 45 |             content: None,
 46 |         }
 47 |     }
 48 |     /// Set the title on the frame that surrounds the content
 49 |     pub fn title<T>(&mut self, title: T) -> &mut Self
 50 |     where
 51 |         T: Into<Line<'a>>,
 52 |     {
 53 |         self.title = Some(title.into());
 54 |         self
 55 |     }
 56 |     /// Set the text inside the panel
 57 |     pub fn content<T>(&mut self, content: T) -> &mut Self
 58 |     where
 59 |         T: Into<Text<'a>>,
 60 |     {
 61 |         self.content = Some(content.into());
 62 |         self
 63 |     }
 64 | 
 65 |     pub fn draw(&mut self, f: &mut ratatui::prelude::Frame<'_>, area: ratatui::prelude::Rect) {
 66 |         // Remember last rendered rect for mouse event handling
 67 |         self.panel.panel_rect = area;
 68 | 
 69 |         // Define border block
 70 |         let mut border = Block::bordered()
 71 |             .border_type(BorderType::Rounded)
 72 |             .padding(Padding::horizontal(1));
 73 |         // Apply title if provided
 74 |         if let Some(title) = &self.title {
 75 |             border = border.title_top(title.clone());
 76 |         }
 77 | 
 78 |         // Find text inside border
 79 |         let content_text = match &self.content {
 80 |             Some(text) => text,
 81 |             None => &Text::raw(""),
 82 |         };
 83 |         // Create content widget that uses border
 84 |         let paragraph_area = border.inner(area);
 85 |         let paragraph = self
 86 |             .panel
 87 |             .render(content_text.clone(), paragraph_area)
 88 |             .block(border);
 89 | 
 90 |         // render content and border
 91 |         f.render_widget(paragraph, area);
 92 | 
 93 |         // render scrollbar on top of border
 94 |         if self.panel.lines > paragraph_area.height {
 95 |             let scrollbar = Scrollbar::new(ScrollbarOrientation::VerticalRight);
 96 | 
 97 |             let mut scrollbar_state =
 98 |                 ScrollbarState::new(self.panel.lines.into()).position(self.panel.scroll.into());
 99 | 
100 |             f.render_stateful_widget(
101 |                 scrollbar,
102 |                 area.inner(Margin {
103 |                     vertical: 1,
104 |                     horizontal: 0,
105 |                 }),
106 |                 &mut scrollbar_state,
107 |             );
108 |         }
109 |     }
110 | }
111 | 
112 | impl DetailsPanel {
113 |     pub fn new() -> Self {
114 |         Self {
115 |             panel_rect: Rect::ZERO,
116 |             scroll: 0,
117 |             height: 0,
118 |             lines: 0,
119 |             wrap: true,
120 |         }
121 |     }
122 | 
123 |     pub fn render_context(&mut self) -> DetailsPanelRenderContext<'_> {
124 |         DetailsPanelRenderContext::new(self)
125 |     }
126 | 
127 |     /// Render the parent into the area.
128 |     pub fn render<'a, T>(&mut self, content: T, area: Rect) -> Paragraph<'a>
129 |     where
130 |         T: Into<Text<'a>>,
131 |     {
132 |         let mut paragraph = Paragraph::new(content);
133 | 
134 |         if self.wrap {
135 |             paragraph = paragraph.wrap(Wrap { trim: false });
136 |         }
137 | 
138 |         self.height = area.height;
139 |         self.lines = paragraph.line_count(area.width) as u16;
140 | 
141 |         paragraph = paragraph.scroll((self.scroll.min(self.lines.saturating_sub(1)), 0));
142 | 
143 |         paragraph
144 |     }
145 | 
146 |     pub fn scroll_to(&mut self, line_no: u16) {
147 |         self.scroll = line_no.min(self.lines.saturating_sub(1))
148 |     }
149 | 
150 |     pub fn scroll(&mut self, scroll: isize) {
151 |         self.scroll_to(self.scroll.saturating_add_signed(scroll as i16))
152 |     }
153 | 
154 |     pub fn handle_event(&mut self, details_panel_event: DetailsPanelEvent) {
155 |         match details_panel_event {
156 |             DetailsPanelEvent::ScrollDown => self.scroll(1),
157 |             DetailsPanelEvent::ScrollUp => self.scroll(-1),
158 |             DetailsPanelEvent::ScrollDownHalfPage => self.scroll(self.height as isize / 2),
159 |             DetailsPanelEvent::ScrollUpHalfPage => {
160 |                 self.scroll((self.height as isize / 2).saturating_neg())
161 |             }
162 |             DetailsPanelEvent::ScrollDownPage => self.scroll(self.height as isize),
163 |             DetailsPanelEvent::ScrollUpPage => self.scroll((self.height as isize).saturating_neg()),
164 |             DetailsPanelEvent::ToggleWrap => self.wrap = !self.wrap,
165 |         }
166 |     }
167 | 
168 |     /// Handle input. Returns bool of if event was handled
169 |     pub fn input(&mut self, key: KeyEvent) -> bool {
170 |         match key.code {
171 |             KeyCode::Char('e') if key.modifiers.contains(KeyModifiers::CONTROL) => {
172 |                 self.handle_event(DetailsPanelEvent::ScrollDown)
173 |             }
174 |             KeyCode::Char('y') if key.modifiers.contains(KeyModifiers::CONTROL) => {
175 |                 self.handle_event(DetailsPanelEvent::ScrollUp)
176 |             }
177 |             KeyCode::Char('d') if key.modifiers.contains(KeyModifiers::CONTROL) => {
178 |                 self.handle_event(DetailsPanelEvent::ScrollDownHalfPage)
179 |             }
180 |             KeyCode::Char('u') if key.modifiers.contains(KeyModifiers::CONTROL) => {
181 |                 self.handle_event(DetailsPanelEvent::ScrollUpHalfPage)
182 |             }
183 |             KeyCode::Char('f') if key.modifiers.contains(KeyModifiers::CONTROL) => {
184 |                 self.handle_event(DetailsPanelEvent::ScrollDownPage)
185 |             }
186 |             KeyCode::Char('b') if key.modifiers.contains(KeyModifiers::CONTROL) => {
187 |                 self.handle_event(DetailsPanelEvent::ScrollUpPage)
188 |             }
189 |             KeyCode::Char('W') => self.handle_event(DetailsPanelEvent::ToggleWrap),
190 |             _ => return false,
191 |         };
192 | 
193 |         true
194 |     }
195 | 
196 |     /// Handle input. Returns bool of if event was handled
197 |     pub fn input_mouse(&mut self, mouse: MouseEvent) -> bool {
198 |         if !self.panel_rect.contains(Position {
199 |             y: mouse.row,
200 |             x: mouse.column,
201 |         }) {
202 |             trace!("mouse {:?} not in rect {:?}", &mouse, &self.panel_rect);
203 |             return false;
204 |         }
205 |         trace!("mouse {:?} inside  rect {:?}", &mouse, &self.panel_rect);
206 |         match mouse.kind {
207 |             MouseEventKind::ScrollUp => {
208 |                 self.handle_event(DetailsPanelEvent::ScrollUp);
209 |                 self.handle_event(DetailsPanelEvent::ScrollUp);
210 |                 self.handle_event(DetailsPanelEvent::ScrollUp);
211 |             }
212 |             MouseEventKind::ScrollDown => {
213 |                 self.handle_event(DetailsPanelEvent::ScrollDown);
214 |                 self.handle_event(DetailsPanelEvent::ScrollDown);
215 |                 self.handle_event(DetailsPanelEvent::ScrollDown);
216 |             }
217 |             _ => return false,
218 |         }
219 |         true
220 |     }
221 | }
222 | 


--------------------------------------------------------------------------------
/src/keybinds/mod.rs:
--------------------------------------------------------------------------------
  1 | use std::{fmt::Display, str::FromStr};
  2 | 
  3 | use ratatui::crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
  4 | 
  5 | pub use config::{Keybind, KeybindsConfig};
  6 | pub use log_tab::{LogTabEvent, LogTabKeybinds};
  7 | 
  8 | mod config;
  9 | mod keybinds_store;
 10 | mod log_tab;
 11 | pub mod rebase_popup;
 12 | 
 13 | /*#[derive(Debug)]
 14 | pub struct Keybinds {
 15 |     log_tab: LogTabKeybinds,
 16 | }*/
 17 | 
 18 | /// Add keybindings to [`keybinds_store::KeybindsStore`]. Checks that shortcuts not duplicated
 19 | #[macro_export]
 20 | macro_rules! set_keybinds {
 21 |     () => {};
 22 |     ($keys:ident, $($action:expr => $shortcut:literal),* $(,)?) => {
 23 |         let mut __shortcuts_count = 0;
 24 |         $(
 25 |             $keys.add_action(Shortcut::from_str($shortcut).unwrap(), $action);
 26 |             __shortcuts_count += 1;
 27 |         )*
 28 |         debug_assert_eq!(__shortcuts_count, $keys.len(), "shortcuts should not duplicate");
 29 |     };
 30 | }
 31 | 
 32 | /// Replace keybindings in [`keybinds_store::KeybindsStore`] from config
 33 | #[macro_export]
 34 | macro_rules! update_keybinds {
 35 |     () => {};
 36 |     ($keys:expr, $($action:expr => $config:expr),* $(,)?) => {
 37 |         $(
 38 |             if let Some(ref k) = $config {
 39 |                 $keys.replace_action_from_config($action, k);
 40 |             }
 41 |         )*
 42 |     };
 43 | }
 44 | 
 45 | #[macro_export]
 46 | macro_rules! make_keybinds_help {
 47 |     () => {};
 48 |     ($keys:expr, $($action:expr => $desc:literal),* $(,)?) => {
 49 |         #[allow(clippy::vec_init_then_push)]
 50 |         {
 51 |             let mut res = vec![];
 52 |             $(
 53 |                 let shortcuts = $keys.get_shortcuts($action)
 54 |                     .iter()
 55 |                     .map(|s| s.to_string())
 56 |                     .collect::<Vec<_>>()
 57 |                     .join("/");
 58 |                 if shortcuts.is_empty() {
 59 |                     res.push(("[disabled]".to_string(), $desc.to_string()));
 60 |                 } else {
 61 |                     res.push((shortcuts, $desc.to_string()));
 62 |                 }
 63 |             )*
 64 |             res
 65 |         }
 66 |     };
 67 | }
 68 | 
 69 | #[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, serde_with::DeserializeFromStr)]
 70 | pub struct Shortcut {
 71 |     key: KeyCode,
 72 |     modifiers: KeyModifiers,
 73 | }
 74 | 
 75 | impl Shortcut {
 76 |     pub fn new_mod_key(modifiers: KeyModifiers, key: KeyCode) -> Self {
 77 |         Self { key, modifiers }
 78 |     }
 79 |     pub fn from_event(event: KeyEvent) -> Self {
 80 |         Self {
 81 |             key: match event.code {
 82 |                 // when shift is pressed character is in upper case, so normalize it here
 83 |                 KeyCode::Char(c) => KeyCode::Char(c.to_ascii_lowercase()),
 84 |                 c => c,
 85 |             },
 86 |             modifiers: event.modifiers,
 87 |         }
 88 |     }
 89 | }
 90 | 
 91 | impl FromStr for Shortcut {
 92 |     type Err = ShortcutParseError;
 93 | 
 94 |     fn from_str(s: &str) -> Result<Self, Self::Err> {
 95 |         let mut modifiers = KeyModifiers::empty();
 96 |         let mut key = None;
 97 |         for s in s.to_lowercase().split('+').map(|s| s.trim()) {
 98 |             match s {
 99 |                 "ctrl" => modifiers |= KeyModifiers::CONTROL,
100 |                 "shift" => modifiers |= KeyModifiers::SHIFT,
101 |                 "enter" => key = Some(KeyCode::Enter),
102 |                 "esc" => key = Some(KeyCode::Esc),
103 |                 "left" => key = Some(KeyCode::Left),
104 |                 "right" => key = Some(KeyCode::Right),
105 |                 "up" => key = Some(KeyCode::Up),
106 |                 "down" => key = Some(KeyCode::Down),
107 |                 s if s.starts_with('f') && s.chars().count() > 1 => {
108 |                     let s = s.trim_start_matches('f');
109 |                     match s.parse::<u8>() {
110 |                         Ok(k) => key = Some(KeyCode::F(k)),
111 |                         Err(_) => return Err(ShortcutParseError::InvalidF),
112 |                     }
113 |                 }
114 |                 s if s.chars().count() == 1 => {
115 |                     let s = s.chars().next().unwrap();
116 |                     key = Some(KeyCode::Char(s));
117 |                 }
118 |                 _ => (),
119 |             }
120 |         }
121 | 
122 |         if let Some(key) = key {
123 |             Ok(Self::new_mod_key(modifiers, key))
124 |         } else {
125 |             Err(ShortcutParseError::NoKey)
126 |         }
127 |     }
128 | }
129 | 
130 | impl Display for Shortcut {
131 |     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
132 |         let mut parts = Vec::with_capacity(3);
133 |         if self.modifiers.contains(KeyModifiers::CONTROL) {
134 |             parts.push("Control".to_string());
135 |         }
136 |         if self.modifiers.contains(KeyModifiers::SHIFT) {
137 |             parts.push("Shift".to_string());
138 |         }
139 |         let k = match self.key {
140 |             KeyCode::Enter => "Enter".to_string(),
141 |             KeyCode::Left => "Left".to_string(),
142 |             KeyCode::Right => "Right".to_string(),
143 |             KeyCode::Up => "Up".to_string(),
144 |             KeyCode::Down => "Down".to_string(),
145 |             KeyCode::F(n) => format!("F{n}"),
146 |             KeyCode::Char(c) => c.to_string(),
147 |             KeyCode::Esc => "Esc".to_string(),
148 |             _ => "Unknown".to_string(),
149 |         };
150 |         parts.push(k);
151 | 
152 |         parts.join("+").fmt(f)
153 |     }
154 | }
155 | 
156 | #[derive(Debug, thiserror::Error, PartialEq, Eq)]
157 | pub enum ShortcutParseError {
158 |     #[error("invalid number after f")]
159 |     InvalidF,
160 |     #[error("no key specified")]
161 |     NoKey,
162 | }
163 | 
164 | #[cfg(test)]
165 | mod tests {
166 |     use super::*;
167 | 
168 |     impl Shortcut {
169 |         pub fn new_mod_char(modifiers: KeyModifiers, key: char) -> Self {
170 |             Self::new_mod_key(modifiers, KeyCode::Char(key))
171 |         }
172 |         pub fn new_char(key: char) -> Self {
173 |             Self::new_mod_key(KeyModifiers::empty(), KeyCode::Char(key))
174 |         }
175 |         pub fn new_key(key: KeyCode) -> Self {
176 |             Self::new_mod_key(KeyModifiers::empty(), key)
177 |         }
178 |     }
179 | 
180 |     #[test]
181 |     fn test_shortcut_from_str() {
182 |         let ctrl = KeyModifiers::CONTROL;
183 |         let shift = KeyModifiers::SHIFT;
184 |         let ctrl_shift = ctrl | shift;
185 | 
186 |         let table = [
187 |             ("q", Ok(Shortcut::new_char('q'))),
188 |             ("Q", Ok(Shortcut::new_char('q'))),
189 |             ("f", Ok(Shortcut::new_char('f'))),
190 |             ("@", Ok(Shortcut::new_char('@'))),
191 |             ("super+q", Ok(Shortcut::new_char('q'))),
192 |             ("ctrl+q", Ok(Shortcut::new_mod_char(ctrl, 'q'))),
193 |             ("ctrl+a+q", Ok(Shortcut::new_mod_char(ctrl, 'q'))),
194 |             ("ctrl+Q", Ok(Shortcut::new_mod_char(ctrl, 'q'))),
195 |             ("ctrl+ctrl+q", Ok(Shortcut::new_mod_char(ctrl, 'q'))),
196 |             ("ctrl+shift+q", Ok(Shortcut::new_mod_char(ctrl_shift, 'q'))),
197 |             (
198 |                 "ctrl+shift+f5",
199 |                 Ok(Shortcut::new_mod_key(ctrl_shift, KeyCode::F(5))),
200 |             ),
201 |             (
202 |                 "ctrl+shift+f25",
203 |                 Ok(Shortcut::new_mod_key(ctrl_shift, KeyCode::F(25))),
204 |             ),
205 |             ("enter", Ok(Shortcut::new_key(KeyCode::Enter))),
206 |             (
207 |                 "ctrl+enter",
208 |                 Ok(Shortcut::new_mod_key(ctrl, KeyCode::Enter)),
209 |             ),
210 |             ("esc", Ok(Shortcut::new_key(KeyCode::Esc))),
211 |             ("left", Ok(Shortcut::new_key(KeyCode::Left))),
212 |             ("right", Ok(Shortcut::new_key(KeyCode::Right))),
213 |             ("up", Ok(Shortcut::new_key(KeyCode::Up))),
214 |             ("down", Ok(Shortcut::new_key(KeyCode::Down))),
215 |             ("ctrl+ff", Err(ShortcutParseError::InvalidF)),
216 |             ("qq", Err(ShortcutParseError::NoKey)),
217 |             ("", Err(ShortcutParseError::NoKey)),
218 |         ];
219 | 
220 |         for (s, expected) in table {
221 |             assert_eq!(
222 |                 Shortcut::from_str(s),
223 |                 expected,
224 |                 "Shortcut::from_str(\"{s}\")"
225 |             );
226 |         }
227 |     }
228 | }
229 | 


--------------------------------------------------------------------------------
/src/main.rs:
--------------------------------------------------------------------------------
  1 | extern crate thiserror;
  2 | 
  3 | use std::{
  4 |     env::current_dir,
  5 |     fs::{OpenOptions, canonicalize},
  6 |     io::{self, ErrorKind},
  7 |     process::Command,
  8 |     time::Instant,
  9 | };
 10 | 
 11 | use anyhow::{Context, Result, bail};
 12 | use clap::Parser;
 13 | use ratatui::{
 14 |     Terminal,
 15 |     backend::{Backend, CrosstermBackend},
 16 |     crossterm::{
 17 |         event::{
 18 |             self, DisableFocusChange, DisableMouseCapture, EnableFocusChange, EnableMouseCapture,
 19 |             Event, KeyboardEnhancementFlags, MouseEvent, MouseEventKind,
 20 |             PopKeyboardEnhancementFlags, PushKeyboardEnhancementFlags,
 21 |         },
 22 |         execute,
 23 |         terminal::{
 24 |             EnterAlternateScreen, LeaveAlternateScreen, disable_raw_mode, enable_raw_mode,
 25 |             supports_keyboard_enhancement,
 26 |         },
 27 |     },
 28 |     layout::{Alignment, Rect},
 29 |     widgets::Paragraph,
 30 | };
 31 | use tracing::{info, trace_span};
 32 | use tracing_chrome::ChromeLayerBuilder;
 33 | use tracing_subscriber::layer::SubscriberExt;
 34 | 
 35 | mod app;
 36 | mod commander;
 37 | mod env;
 38 | mod keybinds;
 39 | mod ui;
 40 | 
 41 | use crate::{
 42 |     app::App,
 43 |     commander::Commander,
 44 |     env::Env,
 45 |     ui::{ComponentAction, ui},
 46 | };
 47 | 
 48 | /// Simple program to greet a person
 49 | #[derive(Parser, Debug)]
 50 | #[command(version, about, long_about = None)]
 51 | struct Args {
 52 |     /// Path to jj repo. Defaults to current directory
 53 |     #[arg(short, long)]
 54 |     path: Option<String>,
 55 | 
 56 |     /// Default revset
 57 |     #[arg(short, long)]
 58 |     revisions: Option<String>,
 59 | 
 60 |     /// Path to jj binary
 61 |     #[arg(long, env = "JJ_BIN")]
 62 |     jj_bin: Option<String>,
 63 | 
 64 |     /// Do not exit if jj version check fails
 65 |     #[arg(long)]
 66 |     ignore_jj_version: bool,
 67 | }
 68 | 
 69 | fn main() -> Result<()> {
 70 |     let should_log = std::env::var("LAZYJJ_LOG")
 71 |         .map(|log| log == "1" || log.eq_ignore_ascii_case("true"))
 72 |         .unwrap_or(false);
 73 | 
 74 |     let log_layer = if should_log {
 75 |         let log_file = OpenOptions::new()
 76 |             .append(true)
 77 |             .create(true)
 78 |             .open("lazyjj.log")
 79 |             .unwrap();
 80 | 
 81 |         Some(
 82 |             tracing_subscriber::fmt::layer()
 83 |                 .compact()
 84 |                 .with_writer(log_file)
 85 |                 // Add log when span ends with their duration
 86 |                 .with_span_events(tracing_subscriber::fmt::format::FmtSpan::CLOSE),
 87 |         )
 88 |     } else {
 89 |         None
 90 |     };
 91 | 
 92 |     let should_trace = std::env::var("LAZYJJ_TRACE")
 93 |         .map(|log| log == "1" || log.eq_ignore_ascii_case("true"))
 94 |         .unwrap_or(false);
 95 |     let (trace_layer, _guard) = if should_trace {
 96 |         let (chrome_layer, _guard) = ChromeLayerBuilder::new().build();
 97 |         (Some(chrome_layer), Some(_guard))
 98 |     } else {
 99 |         (None, None)
100 |     };
101 | 
102 |     let subscriber = tracing_subscriber::Registry::default()
103 |         .with(log_layer)
104 |         .with(trace_layer);
105 |     tracing::subscriber::set_global_default(subscriber)?;
106 | 
107 |     info!("Starting lazyjj");
108 | 
109 |     // Parse arguments and determine path
110 |     let args = Args::parse();
111 |     let path = match args.path {
112 |         Some(path) => {
113 |             canonicalize(&path).with_context(|| format!("Could not find path {}", &path))?
114 |         }
115 |         None => current_dir()?,
116 |     };
117 | 
118 |     let jj_bin = args.jj_bin.unwrap_or("jj".to_string());
119 | 
120 |     // Check that jj exists
121 |     if let Err(err) = Command::new(&jj_bin).arg("help").output()
122 |         && err.kind() == ErrorKind::NotFound
123 |     {
124 |         bail!(
125 |             "jj command not found. Please make sure it is installed: https://martinvonz.github.io/jj/latest/install-and-setup"
126 |         );
127 |     }
128 | 
129 |     // Setup environment
130 |     let env = Env::new(path, args.revisions, jj_bin)?;
131 |     let mut commander = Commander::new(&env);
132 | 
133 |     if !args.ignore_jj_version {
134 |         commander.check_jj_version()?;
135 |     }
136 | 
137 |     // Setup app
138 |     let mut app = App::new(env.clone())?;
139 | 
140 |     let mut terminal = setup_terminal()?;
141 |     install_panic_hook();
142 | 
143 |     // Run app
144 |     let res = run_app(&mut terminal, &mut app, &mut commander);
145 |     restore_terminal()?;
146 |     res?;
147 | 
148 |     Ok(())
149 | }
150 | 
151 | fn run_app<B: Backend>(
152 |     terminal: &mut Terminal<B>,
153 |     app: &mut App,
154 |     commander: &mut Commander,
155 | ) -> Result<()> {
156 |     let mut start_time = Instant::now();
157 |     loop {
158 |         // Draw
159 |         let mut terminal_draw_res = Ok(());
160 |         terminal.draw(|f| {
161 |             // Update current tab
162 |             let update_span = trace_span!("update");
163 |             terminal_draw_res = update_span.in_scope(|| -> Result<()> {
164 |                 if let Some(component_action) =
165 |                     app.get_or_init_current_tab(commander)?.update(commander)?
166 |                 {
167 |                     app.handle_action(component_action, commander)?;
168 |                 }
169 | 
170 |                 Ok(())
171 |             });
172 |             if terminal_draw_res.is_err() {
173 |                 return;
174 |             }
175 | 
176 |             let draw_span = trace_span!("draw");
177 |             terminal_draw_res = draw_span.in_scope(|| -> Result<()> {
178 |                 ui(f, app)?;
179 | 
180 |                 {
181 |                     let paragraph =
182 |                         Paragraph::new(format!("{}ms", start_time.elapsed().as_millis()))
183 |                             .alignment(Alignment::Right);
184 |                     let position = Rect {
185 |                         x: 0,
186 |                         y: 1,
187 |                         height: 1,
188 |                         width: f.area().width - 1,
189 |                     };
190 |                     f.render_widget(paragraph, position);
191 |                 }
192 |                 Ok(())
193 |             });
194 |         })?;
195 |         terminal_draw_res?;
196 | 
197 |         // Input
198 |         let input_spawn = trace_span!("input");
199 |         let event = loop {
200 |             match event::read()? {
201 |                 event::Event::FocusLost => continue,
202 |                 Event::Mouse(MouseEvent {
203 |                     kind: MouseEventKind::Moved,
204 |                     ..
205 |                 }) => continue,
206 |                 event => break event,
207 |             }
208 |         };
209 | 
210 |         start_time = Instant::now();
211 | 
212 |         let should_stop = input_spawn.in_scope(|| -> Result<bool> {
213 |             if app.input(event, commander)? {
214 |                 return Ok(true);
215 |             }
216 | 
217 |             Ok(false)
218 |         })?;
219 | 
220 |         if should_stop {
221 |             return Ok(());
222 |         }
223 |     }
224 | }
225 | 
226 | fn setup_terminal() -> Result<Terminal<CrosstermBackend<io::Stdout>>> {
227 |     enable_raw_mode()?;
228 |     let mut stdout = io::stdout();
229 |     execute!(
230 |         stdout,
231 |         EnterAlternateScreen,
232 |         EnableMouseCapture,
233 |         EnableFocusChange
234 |     )?;
235 | 
236 |     if supports_keyboard_enhancement()? {
237 |         execute!(
238 |             stdout,
239 |             // required to properly detect ctrl+shift
240 |             PushKeyboardEnhancementFlags(KeyboardEnhancementFlags::DISAMBIGUATE_ESCAPE_CODES)
241 |         )?;
242 |     }
243 | 
244 |     let backend = CrosstermBackend::new(stdout);
245 |     Ok(Terminal::new(backend)?)
246 | }
247 | 
248 | fn restore_terminal() -> Result<()> {
249 |     disable_raw_mode()?;
250 |     let mut stdout = io::stdout();
251 |     execute!(
252 |         stdout,
253 |         LeaveAlternateScreen,
254 |         DisableMouseCapture,
255 |         DisableFocusChange
256 |     )?;
257 | 
258 |     if supports_keyboard_enhancement()? {
259 |         execute!(stdout, PopKeyboardEnhancementFlags)?;
260 |     }
261 | 
262 |     Ok(())
263 | }
264 | 
265 | fn install_panic_hook() {
266 |     let original_hook = std::panic::take_hook();
267 |     std::panic::set_hook(Box::new(move |info| {
268 |         if let Err(err) = restore_terminal() {
269 |             eprintln!("Failed to restore terminal: {err}");
270 |         }
271 |         original_hook(info);
272 |     }));
273 | }
274 | 
275 | enum ComponentInputResult {
276 |     Handled,
277 |     HandledAction(ComponentAction),
278 |     NotHandled,
279 | }
280 | 
281 | impl ComponentInputResult {
282 |     pub fn is_handled(&self) -> bool {
283 |         match self {
284 |             ComponentInputResult::Handled => true,
285 |             ComponentInputResult::HandledAction(_) => true,
286 |             ComponentInputResult::NotHandled => false,
287 |         }
288 |     }
289 | }
290 | 


--------------------------------------------------------------------------------
/src/commander/bookmarks.rs:
--------------------------------------------------------------------------------
  1 | /*!
  2 | [Commander] member functions related to jj bookmark.
  3 | 
  4 | This module has features to parse the `jj bookmark list` output. The
  5 | other jj bookmark commands are defined in module [jj][super::jj].
  6 | 
  7 | It is mostly used in the [bookmarks_tab][crate::ui::bookmarks_tab] module.
  8 | */
  9 | use crate::{
 10 |     commander::{CommandError, Commander, RemoveEndLine},
 11 |     env::DiffFormat,
 12 | };
 13 | use ansi_to_tui::IntoText;
 14 | use anyhow::Result;
 15 | use itertools::Itertools;
 16 | use ratatui::text::Text;
 17 | use regex::Regex;
 18 | use std::{fmt::Display, sync::LazyLock};
 19 | use tracing::instrument;
 20 | 
 21 | #[derive(Clone, Debug, PartialEq)]
 22 | pub struct Bookmark {
 23 |     pub name: String,
 24 |     pub remote: Option<String>,
 25 |     pub present: bool,
 26 |     pub timestamp: i64,
 27 | }
 28 | 
 29 | impl Display for Bookmark {
 30 |     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 31 |         let mut text = self.name.clone();
 32 |         if let Some(remote) = self.remote.as_ref() {
 33 |             text.push('@');
 34 |             text.push_str(remote);
 35 |         }
 36 |         write!(f, "{text}")
 37 |     }
 38 | }
 39 | 
 40 | // Template which outputs `[name@remote]`. Used to parse data from bookmark list
 41 | const BRANCH_TEMPLATE: &str = r#""[" ++ name ++ "@" ++ remote ++ "|" ++ present ++ "|" ++ self.normal_target().committer().timestamp().format("%s") ++ "]""#;
 42 | // Regex to parse bookmark
 43 | static BRANCH_REGEX: LazyLock<Regex> =
 44 |     LazyLock::new(|| Regex::new(r"^\[(.*)@(.*)\|(true|false)\|(\d+)\]$").unwrap());
 45 | 
 46 | fn parse_bookmark(text: &str) -> Option<Bookmark> {
 47 |     let captured = BRANCH_REGEX.captures(text);
 48 |     captured.as_ref().and_then(|captured| {
 49 |         let name = captured.get(1);
 50 |         let remote = captured.get(2);
 51 |         let present = captured.get(3);
 52 |         let timestamp = captured.get(4);
 53 |         if let (Some(name), Some(remote), Some(present), Some(timestamp)) =
 54 |             (name, remote, present, timestamp)
 55 |         {
 56 |             let remote = remote.as_str().to_owned();
 57 |             Some(Bookmark {
 58 |                 remote: if remote.is_empty() {
 59 |                     None
 60 |                 } else {
 61 |                     Some(remote)
 62 |                 },
 63 |                 name: name.as_str().to_owned(),
 64 |                 present: present.as_str() == "true",
 65 |                 timestamp: timestamp.as_str().parse::<i64>().unwrap_or(0),
 66 |             })
 67 |         } else {
 68 |             None
 69 |         }
 70 |     })
 71 | }
 72 | 
 73 | #[derive(Clone, Debug)]
 74 | pub enum BookmarkLine {
 75 |     Unparsable(String),
 76 |     Parsed { text: String, bookmark: Bookmark },
 77 | }
 78 | 
 79 | impl BookmarkLine {
 80 |     pub fn to_text(&self) -> Result<Text<'_>, ansi_to_tui::Error> {
 81 |         match self {
 82 |             BookmarkLine::Unparsable(text) => text.to_text(),
 83 |             BookmarkLine::Parsed { text, .. } => text.to_text(),
 84 |         }
 85 |     }
 86 | }
 87 | 
 88 | impl Commander {
 89 |     /// Get bookmarks.
 90 |     /// Maps to `jj bookmark list`
 91 |     #[instrument(level = "trace", skip(self))]
 92 |     pub fn get_bookmarks(&self, show_all: bool) -> Result<Vec<BookmarkLine>, CommandError> {
 93 |         let mut args = vec![];
 94 |         if show_all {
 95 |             args.push("--all-remotes");
 96 |         }
 97 |         args.push("--sort");
 98 |         args.push("committer-date-");
 99 |         let bookmarks_colored = self.execute_jj_command(
100 |             [
101 |                 vec![
102 |                     "bookmark",
103 |                     "list",
104 |                     "--config",
105 |                     // Override format_ref_targets to not list conflicts
106 |                     r#"template-aliases.'format_ref_targets(ref)'='''
107 |                         if(ref.conflict(),
108 |                           " " ++ label("conflict", "(conflicted)"),
109 |                           ": " ++ format_commit_summary_with_refs(ref.normal_target(), ""),
110 |                         )
111 |                     '''"#,
112 |                 ],
113 |                 args.clone(),
114 |             ]
115 |             .concat(),
116 |             true,
117 |             true,
118 |         )?;
119 | 
120 |         let bookmarks: Vec<BookmarkLine> = self
121 |             .execute_jj_command(
122 |                 [
123 |                     vec![
124 |                         "bookmark",
125 |                         "list",
126 |                         "-T",
127 |                         &format!(r#"{BRANCH_TEMPLATE} ++ "\n""#),
128 |                     ],
129 |                     args,
130 |                 ]
131 |                 .concat(),
132 |                 false,
133 |                 true,
134 |             )?
135 |             .lines()
136 |             .zip(bookmarks_colored.lines())
137 |             .map(|(line, line_colored)| match parse_bookmark(line) {
138 |                 Some(bookmark) => BookmarkLine::Parsed {
139 |                     text: line_colored.to_owned(),
140 |                     bookmark,
141 |                 },
142 |                 None => BookmarkLine::Unparsable(line_colored.to_owned()),
143 |             })
144 |             .collect();
145 | 
146 |         Ok(bookmarks)
147 |     }
148 | 
149 |     #[instrument(level = "trace", skip(self))]
150 |     pub fn get_bookmarks_list(&self, show_all: bool) -> Result<Vec<Bookmark>, CommandError> {
151 |         let mut args = vec![
152 |             "bookmark".to_owned(),
153 |             "list".to_owned(),
154 |             "-T".to_owned(),
155 |             format!(r#"if(present, {} ++ "\n", "")"#, BRANCH_TEMPLATE),
156 |         ];
157 |         if show_all {
158 |             args.push("--all-remotes".to_owned());
159 |         }
160 | 
161 |         let bookmarks: Vec<Bookmark> = self
162 |             .execute_jj_command(args, false, true)?
163 |             .lines()
164 |             .filter_map(parse_bookmark)
165 |             .sorted_by(|a, b| b.timestamp.cmp(&a.timestamp))
166 |             .collect();
167 | 
168 |         Ok(bookmarks)
169 |     }
170 | 
171 |     /// Get bookmark details.
172 |     /// Maps to `jj show <bookmark>`
173 |     #[instrument(level = "trace", skip(self))]
174 |     pub fn get_bookmark_show(
175 |         &self,
176 |         bookmark: &Bookmark,
177 |         diff_format: &DiffFormat,
178 |         ignore_working_copy: bool,
179 |     ) -> Result<String, CommandError> {
180 |         let bookmark_arg = &bookmark.to_string();
181 |         let mut args = vec!["show", bookmark_arg];
182 |         args.append(&mut diff_format.get_args());
183 |         if ignore_working_copy {
184 |             args.push("--ignore-working-copy");
185 |         }
186 | 
187 |         Ok(self.execute_jj_command(args, true, true)?.remove_end_line())
188 |     }
189 | }
190 | 
191 | #[cfg(test)]
192 | mod tests {
193 | 
194 |     use insta::assert_debug_snapshot;
195 | 
196 |     use crate::commander::tests::TestRepo;
197 | 
198 |     use super::*;
199 | 
200 |     #[test]
201 |     fn get_bookmarks() -> Result<()> {
202 |         let test_repo = TestRepo::new()?;
203 | 
204 |         let bookmark = test_repo.commander.create_bookmark("test")?;
205 |         let bookmarks = test_repo.commander.get_bookmarks(false)?;
206 | 
207 |         assert_eq!(bookmarks.len(), 1);
208 |         assert_eq!(
209 |             bookmarks.first().and_then(|bookmark| match bookmark {
210 |                 BookmarkLine::Parsed { bookmark, .. } => Some(Bookmark {
211 |                     name: bookmark.name.clone(),
212 |                     remote: bookmark.remote.clone(),
213 |                     present: bookmark.present,
214 |                     timestamp: 0,
215 |                 }),
216 |                 _ => None,
217 |             }),
218 |             Some(Bookmark {
219 |                 name: bookmark.name.clone(),
220 |                 remote: bookmark.remote.clone(),
221 |                 present: bookmark.present,
222 |                 timestamp: 0,
223 |             })
224 |         );
225 | 
226 |         Ok(())
227 |     }
228 | 
229 |     #[test]
230 |     fn get_bookmarks_list() -> Result<()> {
231 |         let test_repo = TestRepo::new()?;
232 | 
233 |         let bookmark = test_repo.commander.create_bookmark("test")?;
234 |         let bookmarks = test_repo.commander.get_bookmarks_list(false)?;
235 | 
236 |         assert_eq!(
237 |             bookmarks
238 |                 .iter()
239 |                 .map(|b| Bookmark {
240 |                     name: b.name.clone(),
241 |                     remote: b.remote.clone(),
242 |                     present: b.present,
243 |                     timestamp: 0,
244 |                 })
245 |                 .collect::<Vec<_>>(),
246 |             [Bookmark {
247 |                 name: bookmark.name,
248 |                 remote: bookmark.remote,
249 |                 present: bookmark.present,
250 |                 timestamp: 0,
251 |             }]
252 |         );
253 | 
254 |         Ok(())
255 |     }
256 | 
257 |     #[test]
258 |     fn get_bookmark_show() -> Result<()> {
259 |         let test_repo = TestRepo::new()?;
260 | 
261 |         let bookmark = test_repo.commander.create_bookmark("test")?;
262 |         let bookmark_show =
263 |             test_repo
264 |                 .commander
265 |                 .get_bookmark_show(&bookmark, &DiffFormat::default(), false)?;
266 | 
267 |         let mut settings = insta::Settings::clone_current();
268 |         settings.add_filter(r"Commit ID: [0-9a-fA-F]{40}", "Commit ID: [COMMIT_ID]");
269 |         settings.add_filter(r"Change ID: [k-z]{32}", "Change ID: [Change ID]");
270 |         settings.add_filter(r"(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})", "([DATE_TIME])");
271 |         let _bound = settings.bind_to_scope();
272 | 
273 |         assert_debug_snapshot!(bookmark_show);
274 | 
275 |         Ok(())
276 |     }
277 | }
278 | 


--------------------------------------------------------------------------------
/src/env.rs:
--------------------------------------------------------------------------------
  1 | use std::{path::PathBuf, process::Command};
  2 | 
  3 | use anyhow::{Context, Result, bail};
  4 | use ratatui::style::Color;
  5 | use serde::Deserialize;
  6 | 
  7 | use crate::{
  8 |     commander::{RemoveEndLine, get_output_args},
  9 |     keybinds::KeybindsConfig,
 10 | };
 11 | 
 12 | // TODO: After 0.18, remove Config and replace with JjConfig
 13 | #[derive(Deserialize, Debug, Clone, Default)]
 14 | pub struct Config {
 15 |     #[serde(rename = "lazyjj.highlight-color")]
 16 |     lazyjj_highlight_color: Option<Color>,
 17 |     #[serde(rename = "lazyjj.diff-format")]
 18 |     lazyjj_diff_format: Option<DiffFormat>,
 19 |     #[serde(rename = "lazyjj.diff-tool")]
 20 |     lazyjj_diff_tool: Option<String>,
 21 |     #[serde(rename = "lazyjj.bookmark-prefix")]
 22 |     lazyjj_bookmark_prefix: Option<String>,
 23 |     #[serde(rename = "lazyjj.layout")]
 24 |     lazyjj_layout: Option<JJLayout>,
 25 |     #[serde(rename = "lazyjj.layout-percent")]
 26 |     lazyjj_layout_percent: Option<u16>,
 27 |     #[serde(rename = "lazyjj.keybinds")]
 28 |     lazyjj_keybinds: Option<KeybindsConfig>,
 29 |     #[serde(rename = "ui.diff.format")]
 30 |     ui_diff_format: Option<DiffFormat>,
 31 |     #[serde(rename = "ui.diff.tool")]
 32 |     ui_diff_tool: Option<()>,
 33 |     #[serde(rename = "git.push-bookmark-prefix")]
 34 |     git_push_bookmark_prefix: Option<String>,
 35 | }
 36 | 
 37 | #[derive(Deserialize, Debug, Clone, Default)]
 38 | #[serde(rename_all = "kebab-case")]
 39 | pub struct JjConfig {
 40 |     lazyjj: Option<JjConfigLazyjj>,
 41 |     ui: Option<JjConfigUi>,
 42 |     git: Option<JjConfigGit>,
 43 | }
 44 | 
 45 | #[derive(Deserialize, Debug, Clone, Default)]
 46 | #[serde(rename_all = "kebab-case")]
 47 | pub struct JjConfigLazyjj {
 48 |     highlight_color: Option<Color>,
 49 |     diff_format: Option<DiffFormat>,
 50 |     diff_tool: Option<String>,
 51 |     bookmark_prefix: Option<String>,
 52 |     layout: Option<JJLayout>,
 53 |     layout_percent: Option<u16>,
 54 |     keybinds: Option<KeybindsConfig>,
 55 | }
 56 | 
 57 | #[derive(Deserialize, Debug, Clone, Default)]
 58 | #[serde(rename_all = "kebab-case")]
 59 | pub struct JjConfigUi {
 60 |     diff: Option<JjConfigUiDiff>,
 61 | }
 62 | 
 63 | #[derive(Deserialize, Debug, Clone, Default)]
 64 | #[serde(rename_all = "kebab-case")]
 65 | pub struct JjConfigUiDiff {
 66 |     format: Option<DiffFormat>,
 67 |     tool: Option<toml::Value>,
 68 | }
 69 | 
 70 | #[derive(Deserialize, Debug, Clone, Default)]
 71 | #[serde(rename_all = "kebab-case")]
 72 | pub struct JjConfigGit {
 73 |     push_bookmark_prefix: Option<String>,
 74 | }
 75 | 
 76 | impl Config {
 77 |     pub fn diff_format(&self) -> DiffFormat {
 78 |         let default = if let Some(diff_tool) = self.diff_tool() {
 79 |             DiffFormat::DiffTool(diff_tool)
 80 |         } else {
 81 |             DiffFormat::ColorWords
 82 |         };
 83 |         self.lazyjj_diff_format
 84 |             .clone()
 85 |             .unwrap_or(self.ui_diff_format.clone().unwrap_or(default))
 86 |     }
 87 | 
 88 |     pub fn diff_tool(&self) -> Option<Option<String>> {
 89 |         if let Some(diff_tool) = self.lazyjj_diff_tool.as_ref() {
 90 |             return Some(Some(diff_tool.to_owned()));
 91 |         }
 92 | 
 93 |         if self.ui_diff_tool.is_some() {
 94 |             return Some(None);
 95 |         }
 96 | 
 97 |         None
 98 |     }
 99 | 
100 |     pub fn highlight_color(&self) -> Color {
101 |         self.lazyjj_highlight_color
102 |             .unwrap_or(Color::Rgb(50, 50, 150))
103 |     }
104 | 
105 |     pub fn bookmark_prefix(&self) -> String {
106 |         self.lazyjj_bookmark_prefix.clone().unwrap_or(
107 |             self.git_push_bookmark_prefix
108 |                 .clone()
109 |                 .unwrap_or("push-".to_owned()),
110 |         )
111 |     }
112 | 
113 |     pub fn layout(&self) -> JJLayout {
114 |         self.lazyjj_layout.unwrap_or(JJLayout::Horizontal)
115 |     }
116 | 
117 |     pub fn layout_percent(&self) -> u16 {
118 |         self.lazyjj_layout_percent.unwrap_or(50)
119 |     }
120 | 
121 |     pub fn keybinds(&self) -> Option<&KeybindsConfig> {
122 |         self.lazyjj_keybinds.as_ref()
123 |     }
124 | }
125 | 
126 | #[derive(Debug, Clone)]
127 | pub struct Env {
128 |     pub config: Config,
129 |     pub root: String,
130 |     pub default_revset: Option<String>,
131 |     pub jj_bin: String,
132 | }
133 | 
134 | impl Env {
135 |     pub fn new(path: PathBuf, default_revset: Option<String>, jj_bin: String) -> Result<Env> {
136 |         // Get jj repository root
137 |         let root_output = Command::new(&jj_bin)
138 |             .arg("root")
139 |             .args(get_output_args(false, true))
140 |             .current_dir(&path)
141 |             .output()?;
142 |         if !root_output.status.success() {
143 |             bail!("No jj repository found in {}", path.to_str().unwrap_or(""))
144 |         }
145 |         let root = String::from_utf8(root_output.stdout)?.remove_end_line();
146 | 
147 |         // Read/parse jj config
148 |         let config_toml = String::from_utf8(
149 |             Command::new(&jj_bin)
150 |                 .arg("config")
151 |                 .arg("list")
152 |                 .arg("--template")
153 |                 .arg("'\"' ++ name ++ '\"' ++ '=' ++ value ++ '\n'")
154 |                 .args(get_output_args(false, true))
155 |                 .current_dir(&root)
156 |                 .output()
157 |                 .context("Failed to get jj config")?
158 |                 .stdout,
159 |         )?;
160 |         // Prior to https://github.com/martinvonz/jj/pull/3728, keys were not TOML-escaped.
161 |         let config = match toml::from_str::<Config>(&config_toml) {
162 |             Ok(config) => config,
163 |             Err(_) => {
164 |                 let config_toml = String::from_utf8(
165 |                     Command::new(&jj_bin)
166 |                         .arg("config")
167 |                         .arg("list")
168 |                         .args(get_output_args(false, true))
169 |                         .current_dir(&root)
170 |                         .output()
171 |                         .context("Failed to get jj config")?
172 |                         .stdout,
173 |                 )?;
174 |                 toml::from_str::<JjConfig>(&config_toml)
175 |                     .context("Failed to parse jj config")
176 |                     .map(|config| Config {
177 |                         lazyjj_highlight_color: config
178 |                             .lazyjj
179 |                             .as_ref()
180 |                             .and_then(|lazyjj| lazyjj.highlight_color),
181 |                         lazyjj_diff_format: config
182 |                             .lazyjj
183 |                             .as_ref()
184 |                             .and_then(|lazyjj| lazyjj.diff_format.clone()),
185 |                         lazyjj_diff_tool: config
186 |                             .lazyjj
187 |                             .as_ref()
188 |                             .and_then(|lazyjj| lazyjj.diff_tool.clone()),
189 |                         lazyjj_bookmark_prefix: config
190 |                             .lazyjj
191 |                             .as_ref()
192 |                             .and_then(|lazyjj| lazyjj.bookmark_prefix.clone()),
193 |                         lazyjj_layout: config.lazyjj.as_ref().and_then(|lazyjj| lazyjj.layout),
194 |                         lazyjj_layout_percent: config
195 |                             .lazyjj
196 |                             .as_ref()
197 |                             .and_then(|lazyjj| lazyjj.layout_percent),
198 |                         lazyjj_keybinds: config
199 |                             .lazyjj
200 |                             .as_ref()
201 |                             .and_then(|lazyjj| lazyjj.keybinds.clone()),
202 |                         ui_diff_format: config
203 |                             .ui
204 |                             .as_ref()
205 |                             .and_then(|ui| ui.diff.as_ref().and_then(|diff| diff.format.clone())),
206 |                         ui_diff_tool: config.ui.as_ref().and_then(|ui| {
207 |                             ui.diff
208 |                                 .as_ref()
209 |                                 .and_then(|diff| diff.tool.as_ref().map(|_| ()))
210 |                         }),
211 |                         git_push_bookmark_prefix: config
212 |                             .git
213 |                             .and_then(|git| git.push_bookmark_prefix),
214 |                     })?
215 |             }
216 |         };
217 | 
218 |         Ok(Env {
219 |             root,
220 |             config,
221 |             default_revset,
222 |             jj_bin,
223 |         })
224 |     }
225 | }
226 | 
227 | #[derive(Clone, Debug, Deserialize, Default, PartialEq)]
228 | #[serde(rename_all = "kebab-case")]
229 | pub enum DiffFormat {
230 |     #[default]
231 |     ColorWords,
232 |     Git,
233 |     DiffTool(Option<String>),
234 |     // Unused
235 |     Summary,
236 |     Stat,
237 | }
238 | 
239 | impl DiffFormat {
240 |     pub fn get_next(&self, diff_tool: Option<Option<String>>) -> DiffFormat {
241 |         match self {
242 |             DiffFormat::ColorWords => DiffFormat::Git,
243 |             DiffFormat::Git => {
244 |                 if let Some(diff_tool) = diff_tool {
245 |                     DiffFormat::DiffTool(diff_tool)
246 |                 } else {
247 |                     DiffFormat::ColorWords
248 |                 }
249 |             }
250 |             _ => DiffFormat::ColorWords,
251 |         }
252 |     }
253 | }
254 | 
255 | #[derive(Clone, Debug, Deserialize, Default, Copy, PartialEq)]
256 | #[serde(rename_all = "kebab-case")]
257 | pub enum JJLayout {
258 |     #[default]
259 |     Horizontal,
260 |     Vertical,
261 | }
262 | 
263 | // Impl into for JJLayout to ratatui's Direction
264 | impl From<JJLayout> for ratatui::layout::Direction {
265 |     fn from(layout: JJLayout) -> Self {
266 |         match layout {
267 |             JJLayout::Horizontal => ratatui::layout::Direction::Horizontal,
268 |             JJLayout::Vertical => ratatui::layout::Direction::Vertical,
269 |         }
270 |     }
271 | }
272 | 


--------------------------------------------------------------------------------
/src/ui/rebase_popup.rs:
--------------------------------------------------------------------------------
  1 | /*! The rebase popup allows the user to pick a rebase configuration and
  2 |  start rebase, or cancel the opreation.
  3 | 
  4 |  The UI looks like this
  5 |  ~~~
  6 |     Source   (zsztoxlv)
  7 |     ( ) -s this and descendants
  8 |     ( ) -b whole branch
  9 |     (*) -r only one change moves
 10 |     Target @ (umrpslui)
 11 |     (*) -d rebase onto @ as new branch
 12 |     ( ) -A rebase after @
 13 |     ( ) -B rebase before @
 14 | 
 15 |     Esc: Cancel    Enter: Rebase
 16 | ~~~
 17 | It has keyboard shortcuts s, b, r, d, shift+a, shift+b for selecting
 18 | a radiobutton, and shortcuts Enter, Esc, q for closing the popup.
 19 | 
 20 | 
 21 | */
 22 | 
 23 | use anyhow::Result;
 24 | use ratatui::{
 25 |     Frame,
 26 |     crossterm::event::Event,
 27 |     layout::{Alignment, Rect},
 28 |     prelude::{Buffer, Constraint, Direction, Layout, Size},
 29 |     style::{Color, Style, Stylize},
 30 |     text::{Line, Span, Text},
 31 |     widgets::{Block, BorderType, Clear, Paragraph, StatefulWidget},
 32 | };
 33 | 
 34 | use crate::{
 35 |     ComponentInputResult,
 36 |     commander::{Commander, log::Head},
 37 |     keybinds::rebase_popup::{CutOption, PasteOption, PopupAction},
 38 |     ui::Component,
 39 | };
 40 | 
 41 | type Keybinds = crate::keybinds::rebase_popup::Keybinds;
 42 | 
 43 | /// A transient popup for configuring a rebase command
 44 | pub struct RebasePopup {
 45 |     pub keybinds: Keybinds,
 46 | 
 47 |     pub source_rev: Head,
 48 |     pub target_rev: Head,
 49 | 
 50 |     pub source_mode: CutOption,
 51 |     pub target_mode: PasteOption,
 52 | }
 53 | 
 54 | impl RebasePopup {
 55 |     pub fn new(source_rev: Head, target_rev: Head) -> Self {
 56 |         Self {
 57 |             keybinds: Keybinds::default(),
 58 |             source_rev,
 59 |             target_rev,
 60 |             source_mode: CutOption::SingleRevision,
 61 |             target_mode: PasteOption::NewBranch,
 62 |         }
 63 |     }
 64 | 
 65 |     /// Collect all the rendering code that would have been in
 66 |     /// log_tab.rs/draw
 67 |     pub fn render_widget(&mut self, frame: &mut Frame) {
 68 |         let area = center_rect(
 69 |             frame.area(),
 70 |             Size {
 71 |                 width: 32,
 72 |                 height: 12,
 73 |             },
 74 |         );
 75 |         self.draw(frame, area)
 76 |             .expect("Expected drawing without failues");
 77 |     }
 78 | 
 79 |     /// Map an event to a popup action
 80 |     // TODO: This should be done by a custom keybinds object
 81 |     fn match_event(&self, event: Event) -> PopupAction {
 82 |         if let Event::Key(key) = event {
 83 |             return self.keybinds.match_event(key);
 84 |         }
 85 |         PopupAction::None
 86 |     }
 87 | 
 88 |     /// Run the command that the popup is currently configured to do
 89 |     fn run_command(&self, commander: &mut Commander) -> Result<()> {
 90 |         let src_rev = self.source_rev.commit_id.as_str();
 91 |         let tgt_rev = self.target_rev.commit_id.as_str();
 92 |         let src_mode = match self.source_mode {
 93 |             CutOption::IncludeDescendants => "-s",
 94 |             CutOption::IncludeBranch => "-b",
 95 |             CutOption::SingleRevision => "-r",
 96 |         };
 97 |         let tgt_mode = match self.target_mode {
 98 |             PasteOption::NewBranch => "-d",
 99 |             PasteOption::InsertAfter => "-A",
100 |             PasteOption::InsertBefore => "-B",
101 |         };
102 |         commander.run_rebase(src_mode, src_rev, tgt_mode, tgt_rev)?;
103 |         Ok(())
104 |     }
105 | 
106 |     /// Process the input event. If this function returns Ok(true),
107 |     /// then the popup should be closed. Either a rebase was executed
108 |     /// or the operation was cancelled.
109 |     /// If the result is Ok(false) the function did handle
110 |     /// the input, but the popup should not be closed yet.
111 |     /// Err(_) will be returned if the jj command failed.
112 |     pub fn handle_input(&mut self, commander: &mut Commander, event: Event) -> Result<bool> {
113 |         match self.match_event(event) {
114 |             PopupAction::Ok => {
115 |                 self.run_command(commander)?;
116 |                 return Ok(true);
117 |             }
118 |             PopupAction::Cancel => return Ok(true),
119 |             PopupAction::SetSourceMode(m) => self.source_mode = m,
120 |             PopupAction::SetTargetMode(m) => self.target_mode = m,
121 |             PopupAction::None => (),
122 |         }
123 |         Ok(false)
124 |     }
125 | }
126 | 
127 | impl Component for RebasePopup {
128 |     /// Render the dialog into the area.
129 |     fn draw(&mut self, frame: &mut Frame<'_>, area: Rect) -> Result<()> {
130 |         // The border of the dialog
131 |         let block = Block::bordered()
132 |             .title(Span::styled(" Rebase ", Style::new().bold().cyan()))
133 |             .title_alignment(Alignment::Center)
134 |             .border_type(BorderType::Rounded)
135 |             .border_style(Style::default().fg(Color::Green));
136 |         frame.render_widget(Clear, area);
137 |         frame.render_widget(&block, area);
138 | 
139 |         // Split area into chunks. Even though the area size is constant,
140 |         // we pretend it can change in the future.
141 |         let chunks = Layout::default()
142 |             .direction(Direction::Vertical)
143 |             .vertical_margin(1)
144 |             .horizontal_margin(2)
145 |             .constraints(
146 |                 [
147 |                     Constraint::Length(1), // title "Source"
148 |                     Constraint::Min(3),    // buttons for source mode
149 |                     Constraint::Length(1), // title "Target"
150 |                     Constraint::Min(3),    // buttons for target mode
151 |                     Constraint::Length(2), // help text
152 |                 ]
153 |                 .as_ref(),
154 |             )
155 |             .split(area);
156 | 
157 |         // Radio buttons for source
158 |         let src_change_id: String = self.source_rev.change_id.as_str().chars().take(8).collect();
159 |         let src_commit_id: String = self.source_rev.commit_id.as_str().chars().take(8).collect();
160 |         let src_options = vec![
161 |             "-s this and descendants",
162 |             "-b whole branch",
163 |             "-r only one change moves",
164 |         ];
165 |         let mut src_select: usize = match self.source_mode {
166 |             CutOption::IncludeDescendants => 0,
167 |             CutOption::IncludeBranch => 1,
168 |             CutOption::SingleRevision => 2,
169 |         };
170 |         frame.render_widget(
171 |             Paragraph::new(Span::raw(format!(
172 |                 "Source @ {src_change_id} {src_commit_id}"
173 |             ))),
174 |             chunks[0],
175 |         );
176 |         frame.render_stateful_widget(RadioButton::new(src_options), chunks[1], &mut src_select);
177 | 
178 |         // Radio buttons for target
179 |         let tgt_change_id: String = self.target_rev.change_id.as_str().chars().take(8).collect();
180 |         let tgt_commit_id: String = self.target_rev.commit_id.as_str().chars().take(8).collect();
181 |         let tgt_options = vec![
182 |             "-d rebase as new branch",
183 |             "-A rebase after",
184 |             "-B rebase before",
185 |         ];
186 |         let mut tgt_select: usize = match self.target_mode {
187 |             PasteOption::NewBranch => 0,
188 |             PasteOption::InsertAfter => 1,
189 |             PasteOption::InsertBefore => 2,
190 |         };
191 |         frame.render_widget(
192 |             Paragraph::new(Span::raw(format!("Target {tgt_change_id} {tgt_commit_id}"))),
193 |             chunks[2],
194 |         );
195 |         frame.render_stateful_widget(RadioButton::new(tgt_options), chunks[3], &mut tgt_select);
196 | 
197 |         // Help on terminating dialog
198 |         frame.render_widget(
199 |             Paragraph::new(Text::from(vec![
200 |                 Line::raw(""),
201 |                 Line::raw("Esc: Cancel    Enter: Rebase"),
202 |             ])),
203 |             chunks[4],
204 |         );
205 | 
206 |         Ok(())
207 |     }
208 | 
209 |     fn input(&mut self, _commander: &mut Commander, _event: Event) -> Result<ComponentInputResult> {
210 |         unreachable!();
211 |         //return Ok(ComponentInputResult::Handled);
212 |     }
213 | }
214 | 
215 | /****************************************************************/
216 | // TODO(@peso): Move this function to ui::utils
217 | 
218 | /// Find a rect of the given size at the center of an outside rect
219 | fn center_rect(outside: Rect, area: Size) -> Rect {
220 |     Rect {
221 |         x: outside.x + (outside.width - area.width) / 2,
222 |         y: outside.y + (outside.height - area.height) / 2,
223 |         width: area.width,
224 |         height: area.height,
225 |     }
226 | }
227 | 
228 | /****************************************************************/
229 | // TODO(@peso): Move this widget to a separate file
230 | 
231 | /** A widget for a group of radio buttons.
232 | 
233 | It is a stateful widget.
234 | The state is an usize number that indicates which label is
235 | selected.
236 | 
237 | Example:
238 | ~~~
239 | ( ) apples
240 | ( ) bananas
241 | (*) lemons
242 | ~~~
243 | */
244 | struct RadioButton {
245 |     /// Button labels
246 |     pub labels: Vec<String>,
247 |     /// Button style can be modified before drawing
248 |     pub button_style: Style,
249 |     /// Label style can be modified before drawing
250 |     pub label_style: Style,
251 | }
252 | 
253 | impl RadioButton {
254 |     pub fn new(labels: Vec<&str>) -> Self {
255 |         let button_style = Style::default().fg(Color::White);
256 |         let label_style = Style::default().fg(Color::White);
257 |         Self {
258 |             labels: labels.iter().map(|s| s.to_string()).collect(),
259 |             button_style,
260 |             label_style,
261 |         }
262 |     }
263 | }
264 | 
265 | impl StatefulWidget for RadioButton {
266 |     type State = usize;
267 | 
268 |     fn render(self, area: Rect, buf: &mut Buffer, state: &mut Self::State) {
269 |         for (row, label) in self.labels.iter().enumerate() {
270 |             let button = if row == *state { "(*)" } else { "( )" };
271 |             buf.set_string(
272 |                 area.left(),
273 |                 area.top() + row as u16,
274 |                 button,
275 |                 self.button_style,
276 |             );
277 |             buf.set_string(
278 |                 area.left() + 4_u16,
279 |                 area.top() + row as u16,
280 |                 label,
281 |                 self.label_style,
282 |             );
283 |         }
284 |     }
285 | }
286 | 


--------------------------------------------------------------------------------
/src/commander/mod.rs:
--------------------------------------------------------------------------------
  1 | /*!
  2 | This module contains all functions used to interact with jj via command
  3 | line execution.
  4 | 
  5 | 
  6 | The module has one primary struct: [`Commander`] which implements
  7 | several member functions that each call a jj command and handles the output.
  8 | Since the number of jj commands are quite high and some are quite complex,
  9 | the implementation is found in multiple source files. This is why you
 10 | will find multiple "impl Commander" sections in Commander, one for each source file.
 11 | 
 12 | This module implements the low level functions used by the
 13 | command implementation functions:
 14 | 
 15 | * [Commander::new] - Create a new instance
 16 | * [Commander::check_jj_version] - Check jj works with lazyjj
 17 | * [Commander::execute_command] - Execute any command and log the result
 18 | * [Commander::execute_jj_command] - Execute a jj command.
 19 | * [Commander::execute_void_jj_command] - Execute a jj command and discard the output.
 20 | 
 21 | */
 22 | 
 23 | pub mod bookmarks;
 24 | pub mod files;
 25 | pub mod ids;
 26 | pub mod jj;
 27 | pub mod log;
 28 | 
 29 | use crate::env::DiffFormat;
 30 | use crate::env::Env;
 31 | 
 32 | use ansi_to_tui::IntoText;
 33 | use anyhow::{Context, Result, bail};
 34 | use chrono::{DateTime, Local, TimeDelta};
 35 | use ratatui::{
 36 |     style::{Color, Stylize},
 37 |     text::{Line, Text},
 38 | };
 39 | use std::sync::Mutex;
 40 | use std::{
 41 |     ffi::OsStr,
 42 |     io,
 43 |     process::{Command, Output},
 44 |     string::FromUtf8Error,
 45 |     sync::Arc,
 46 | };
 47 | use thiserror::Error;
 48 | use tracing::{instrument, trace};
 49 | use version_compare::{Cmp, compare};
 50 | 
 51 | /// The oldest version of jj that is known to work with lazyjj.
 52 | /// 0.33.0 changed the template language for evolog/obslog
 53 | const JJ_MIN_VERSION: &str = "0.33.0";
 54 | const JJ_VERSION_IGNORE_HELP: &str = "If you want to continue anyway, use --ignore-jj-version";
 55 | 
 56 | impl DiffFormat {
 57 |     pub fn get_args(&self) -> Vec<&str> {
 58 |         match self {
 59 |             DiffFormat::ColorWords => vec!["--color-words"],
 60 |             DiffFormat::Git => vec!["--git"],
 61 |             DiffFormat::Summary => vec!["--summary"],
 62 |             DiffFormat::Stat => vec!["--stat"],
 63 |             DiffFormat::DiffTool(Some(tool)) => vec!["--tool", tool],
 64 |             DiffFormat::DiffTool(None) => vec![],
 65 |         }
 66 |     }
 67 | }
 68 | 
 69 | #[derive(Debug, Error)]
 70 | pub enum CommandError {
 71 |     #[error("Error getting output: {0}")]
 72 |     Output(#[from] io::Error),
 73 |     #[error("{0}")]
 74 |     Status(String, Option<i32>),
 75 |     #[error("Error parsing UTF-8 output: {0}")]
 76 |     FromUtf8(#[from] FromUtf8Error),
 77 | }
 78 | 
 79 | impl CommandError {
 80 |     #[expect(clippy::wrong_self_convention)]
 81 |     pub fn into_text<'a>(&self, title: &'a str) -> Result<Text<'a>, ansi_to_tui::Error> {
 82 |         let mut lines = vec![];
 83 |         if !title.is_empty() {
 84 |             lines.push(Line::raw(title).bold().fg(Color::Red));
 85 |             lines.append(&mut vec![Line::raw(""), Line::raw("")]);
 86 |         }
 87 |         lines.append(&mut self.to_string().into_text()?.lines);
 88 | 
 89 |         Ok(Text::from(lines))
 90 |     }
 91 | }
 92 | 
 93 | #[derive(Clone, Debug)]
 94 | pub struct CommandLogItem {
 95 |     pub program: String,
 96 |     pub args: Vec<String>,
 97 |     pub output: Arc<Result<Output>>,
 98 |     pub time: DateTime<Local>,
 99 |     pub duration: TimeDelta,
100 | }
101 | 
102 | /// Struct used to interact with the jj cli using commanders.
103 | ///
104 | /// Handles arguments and recording of history.
105 | #[derive(Debug)]
106 | pub struct Commander {
107 |     pub env: Env,
108 |     pub command_history: Arc<Mutex<Vec<CommandLogItem>>>,
109 | 
110 |     // Used for testing
111 |     pub jj_config_toml: Option<Vec<String>>,
112 |     pub force_no_color: bool,
113 | }
114 | 
115 | impl Commander {
116 |     pub fn new(env: &Env) -> Self {
117 |         Self {
118 |             env: env.clone(),
119 |             command_history: Arc::new(Mutex::new(Vec::new())),
120 |             jj_config_toml: None,
121 |             force_no_color: false,
122 |         }
123 |     }
124 | 
125 |     /// Execute a command and record to history.
126 |     fn execute_command(&self, command: &mut Command) -> Result<String, CommandError> {
127 |         // Set current directory to root
128 |         command.current_dir(&self.env.root);
129 | 
130 |         let program = command.get_program().to_str().unwrap_or("").to_owned();
131 |         let args: Vec<String> = command
132 |             .get_args()
133 |             .map(|arg| arg.to_str().unwrap_or("").to_owned())
134 |             .collect();
135 | 
136 |         let time = Local::now();
137 |         let output = command.output();
138 |         let duration = Local::now() - time;
139 | 
140 |         // unwrap is enough, because mutex can only poison in the case of push panic
141 |         self.command_history.lock().unwrap().push(CommandLogItem {
142 |             program,
143 |             args,
144 |             output: Arc::new(match output.as_ref() {
145 |                 Ok(value) => Ok(value.clone()),
146 |                 // Clone io::Error
147 |                 Err(err) => Err(anyhow::Error::new(io::Error::new(
148 |                     err.kind(),
149 |                     err.to_string(),
150 |                 ))),
151 |             }),
152 |             time,
153 |             duration,
154 |         });
155 | 
156 |         let output = output?;
157 | 
158 |         if !output.status.success() {
159 |             // Return JjError if non-zero status code
160 |             return Err(CommandError::Status(
161 |                 String::from_utf8_lossy(&output.stderr).to_string(),
162 |                 output.status.code(),
163 |             ));
164 |         }
165 | 
166 |         Ok(String::from_utf8(output.stdout)?)
167 |     }
168 | 
169 |     /// Execute a jj command with color/quiet arguments.
170 |     pub fn execute_jj_command<I, S>(
171 |         &self,
172 |         args: I,
173 |         color: bool,
174 |         quiet: bool,
175 |     ) -> Result<String, CommandError>
176 |     where
177 |         I: IntoIterator<Item = S>,
178 |         S: AsRef<OsStr>,
179 |     {
180 |         let mut command = Command::new(&self.env.jj_bin);
181 |         command.args(args);
182 |         command.args(get_output_args(!self.force_no_color && color, quiet));
183 | 
184 |         if let Some(jj_config_toml) = &self.jj_config_toml {
185 |             for cfg in jj_config_toml {
186 |                 command.args(["--config", cfg]);
187 |             }
188 |         }
189 | 
190 |         self.execute_command(&mut command)
191 |     }
192 | 
193 |     /// Execute a jj command without using the output.
194 |     pub fn execute_void_jj_command<I, S>(&self, args: I) -> Result<(), CommandError>
195 |     where
196 |         I: IntoIterator<Item = S>,
197 |         S: AsRef<OsStr>,
198 |     {
199 |         // Since no result is used, enable color for command log
200 |         self.execute_jj_command(args, true, true)?;
201 |         Ok(())
202 |     }
203 | 
204 |     /// Check that the version of jj is recent enough to work with lazyjj
205 |     ///
206 |     /// See also [JJ_MIN_VERSION]
207 |     #[instrument(level = "trace", skip(self))]
208 |     pub fn check_jj_version(&self) -> Result<()> {
209 |         // Ask jj about its version
210 |         let (color, quiet) = (false, false);
211 |         let found_version = self
212 |             .execute_jj_command(vec!["version"], color, quiet)
213 |             .context("Run jj version")?;
214 | 
215 |         // Extract version number
216 |         if found_version[0..3] != *"jj " {
217 |             trace!("jj version output \"{}\"", found_version);
218 |             bail!("jj version string was not recognized");
219 |         }
220 |         let found_version = &found_version[3..].trim();
221 | 
222 |         trace!(
223 |             found_version = found_version,
224 |             min_version = JJ_MIN_VERSION,
225 |             "Checking jj version",
226 |         );
227 | 
228 |         // Verify that jj is not too old
229 |         match compare(found_version, JJ_MIN_VERSION) {
230 |             Err(_) => bail!(
231 |                 "Unable to compare version '{found_version}' to '{JJ_MIN_VERSION}'\n{JJ_VERSION_IGNORE_HELP}"
232 |             ),
233 |             Ok(Cmp::Lt) => bail!(
234 |                 "jj version is too old ({found_version}). Must be at least {JJ_MIN_VERSION}\n{JJ_VERSION_IGNORE_HELP}"
235 |             ),
236 |             Ok(_) => Ok(()), // found >= min, so jj is recent enough
237 |         }
238 |     }
239 | }
240 | 
241 | pub trait RemoveEndLine {
242 |     fn remove_end_line(self) -> Self;
243 | }
244 | 
245 | impl RemoveEndLine for String {
246 |     fn remove_end_line(mut self) -> Self {
247 |         if self.ends_with('\n') {
248 |             self.pop();
249 |             if self.ends_with('\r') {
250 |                 self.pop();
251 |             }
252 |         }
253 |         self
254 |     }
255 | }
256 | 
257 | pub fn get_output_args(color: bool, quiet: bool) -> Vec<String> {
258 |     vec![
259 |         "--no-pager",
260 |         "--color",
261 |         if color { "always" } else { "never" },
262 |         if quiet { "--quiet" } else { "" },
263 |     ]
264 |     .into_iter()
265 |     .map(String::from)
266 |     .filter(|arg| !arg.is_empty())
267 |     .collect()
268 | }
269 | 
270 | #[cfg(test)]
271 | pub mod tests {
272 |     use super::*;
273 |     use crate::env::{Config, Env};
274 | 
275 |     use tempdir::TempDir;
276 | 
277 |     macro_rules! apply_common_filters {
278 |         {} => {
279 |             let mut settings = insta::Settings::clone_current();
280 |             // Change + commit IDs
281 |             settings.add_filter(r"[k-z]{8} [0-9a-fA-F]{8}", "[CHANGE_ID + COMMIT_ID]");
282 |             let _bound = settings.bind_to_scope();
283 |         }
284 |     }
285 | 
286 |     pub struct TestRepo {
287 |         pub commander: Commander,
288 |         pub directory: TempDir,
289 |     }
290 | 
291 |     impl TestRepo {
292 |         pub fn new() -> Result<Self> {
293 |             let directory = TempDir::new("lazyjj")?;
294 | 
295 |             let jj_config_toml = vec![
296 |                 r#"user.email="lazyjj@example.com""#.to_owned(),
297 |                 r#"user.name="lazyjj""#.to_owned(),
298 |                 r#"ui.color="never""#.to_owned(),
299 |             ];
300 | 
301 |             let jj_bin = "jj".to_string();
302 | 
303 |             let env = Env {
304 |                 root: directory.path().to_string_lossy().to_string(),
305 |                 config: Config::default(),
306 |                 default_revset: None,
307 |                 jj_bin,
308 |             };
309 | 
310 |             let mut commander = Commander::new(&env);
311 |             commander.jj_config_toml = Some(jj_config_toml);
312 |             commander.force_no_color = true;
313 | 
314 |             commander.execute_void_jj_command(vec!["git", "init", "--colocate"])?;
315 | 
316 |             Ok(Self {
317 |                 directory,
318 |                 commander,
319 |             })
320 |         }
321 |     }
322 | 
323 |     #[test]
324 |     fn test_repo() -> Result<()> {
325 |         apply_common_filters!();
326 | 
327 |         let test_repo = TestRepo::new()?;
328 | 
329 |         test_repo
330 |             .commander
331 |             .execute_jj_command(vec!["status"], true, true)?;
332 | 
333 |         Ok(())
334 |     }
335 | }
336 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 | 
  2 |                                  Apache License
  3 |                            Version 2.0, January 2004
  4 |                         http://www.apache.org/licenses/
  5 | 
  6 |    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
  7 | 
  8 |    1. Definitions.
  9 | 
 10 |       "License" shall mean the terms and conditions for use, reproduction,
 11 |       and distribution as defined by Sections 1 through 9 of this document.
 12 | 
 13 |       "Licensor" shall mean the copyright owner or entity authorized by
 14 |       the copyright owner that is granting the License.
 15 | 
 16 |       "Legal Entity" shall mean the union of the acting entity and all
 17 |       other entities that control, are controlled by, or are under common
 18 |       control with that entity. For the purposes of this definition,
 19 |       "control" means (i) the power, direct or indirect, to cause the
 20 |       direction or management of such entity, whether by contract or
 21 |       otherwise, or (ii) ownership of fifty percent (50%) or more of the
 22 |       outstanding shares, or (iii) beneficial ownership of such entity.
 23 | 
 24 |       "You" (or "Your") shall mean an individual or Legal Entity
 25 |       exercising permissions granted by this License.
 26 | 
 27 |       "Source" form shall mean the preferred form for making modifications,
 28 |       including but not limited to software source code, documentation
 29 |       source, and configuration files.
 30 | 
 31 |       "Object" form shall mean any form resulting from mechanical
 32 |       transformation or translation of a Source form, including but
 33 |       not limited to compiled object code, generated documentation,
 34 |       and conversions to other media types.
 35 | 
 36 |       "Work" shall mean the work of authorship, whether in Source or
 37 |       Object form, made available under the License, as indicated by a
 38 |       copyright notice that is included in or attached to the work
 39 |       (an example is provided in the Appendix below).
 40 | 
 41 |       "Derivative Works" shall mean any work, whether in Source or Object
 42 |       form, that is based on (or derived from) the Work and for which the
 43 |       editorial revisions, annotations, elaborations, or other modifications
 44 |       represent, as a whole, an original work of authorship. For the purposes
 45 |       of this License, Derivative Works shall not include works that remain
 46 |       separable from, or merely link (or bind by name) to the interfaces of,
 47 |       the Work and Derivative Works thereof.
 48 | 
 49 |       "Contribution" shall mean any work of authorship, including
 50 |       the original version of the Work and any modifications or additions
 51 |       to that Work or Derivative Works thereof, that is intentionally
 52 |       submitted to Licensor for inclusion in the Work by the copyright owner
 53 |       or by an individual or Legal Entity authorized to submit on behalf of
 54 |       the copyright owner. For the purposes of this definition, "submitted"
 55 |       means any form of electronic, verbal, or written communication sent
 56 |       to the Licensor or its representatives, including but not limited to
 57 |       communication on electronic mailing lists, source code control systems,
 58 |       and issue tracking systems that are managed by, or on behalf of, the
 59 |       Licensor for the purpose of discussing and improving the Work, but
 60 |       excluding communication that is conspicuously marked or otherwise
 61 |       designated in writing by the copyright owner as "Not a Contribution."
 62 | 
 63 |       "Contributor" shall mean Licensor and any individual or Legal Entity
 64 |       on behalf of whom a Contribution has been received by Licensor and
 65 |       subsequently incorporated within the Work.
 66 | 
 67 |    2. Grant of Copyright License. Subject to the terms and conditions of
 68 |       this License, each Contributor hereby grants to You a perpetual,
 69 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 70 |       copyright license to reproduce, prepare Derivative Works of,
 71 |       publicly display, publicly perform, sublicense, and distribute the
 72 |       Work and such Derivative Works in Source or Object form.
 73 | 
 74 |    3. Grant of Patent License. Subject to the terms and conditions of
 75 |       this License, each Contributor hereby grants to You a perpetual,
 76 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 77 |       (except as stated in this section) patent license to make, have made,
 78 |       use, offer to sell, sell, import, and otherwise transfer the Work,
 79 |       where such license applies only to those patent claims licensable
 80 |       by such Contributor that are necessarily infringed by their
 81 |       Contribution(s) alone or by combination of their Contribution(s)
 82 |       with the Work to which such Contribution(s) was submitted. If You
 83 |       institute patent litigation against any entity (including a
 84 |       cross-claim or counterclaim in a lawsuit) alleging that the Work
 85 |       or a Contribution incorporated within the Work constitutes direct
 86 |       or contributory patent infringement, then any patent licenses
 87 |       granted to You under this License for that Work shall terminate
 88 |       as of the date such litigation is filed.
 89 | 
 90 |    4. Redistribution. You may reproduce and distribute copies of the
 91 |       Work or Derivative Works thereof in any medium, with or without
 92 |       modifications, and in Source or Object form, provided that You
 93 |       meet the following conditions:
 94 | 
 95 |       (a) You must give any other recipients of the Work or
 96 |           Derivative Works a copy of this License; and
 97 | 
 98 |       (b) You must cause any modified files to carry prominent notices
 99 |           stating that You changed the files; and
100 | 
101 |       (c) You must retain, in the Source form of any Derivative Works
102 |           that You distribute, all copyright, patent, trademark, and
103 |           attribution notices from the Source form of the Work,
104 |           excluding those notices that do not pertain to any part of
105 |           the Derivative Works; and
106 | 
107 |       (d) If the Work includes a "NOTICE" text file as part of its
108 |           distribution, then any Derivative Works that You distribute must
109 |           include a readable copy of the attribution notices contained
110 |           within such NOTICE file, excluding those notices that do not
111 |           pertain to any part of the Derivative Works, in at least one
112 |           of the following places: within a NOTICE text file distributed
113 |           as part of the Derivative Works; within the Source form or
114 |           documentation, if provided along with the Derivative Works; or,
115 |           within a display generated by the Derivative Works, if and
116 |           wherever such third-party notices normally appear. The contents
117 |           of the NOTICE file are for informational purposes only and
118 |           do not modify the License. You may add Your own attribution
119 |           notices within Derivative Works that You distribute, alongside
120 |           or as an addendum to the NOTICE text from the Work, provided
121 |           that such additional attribution notices cannot be construed
122 |           as modifying the License.
123 | 
124 |       You may add Your own copyright statement to Your modifications and
125 |       may provide additional or different license terms and conditions
126 |       for use, reproduction, or distribution of Your modifications, or
127 |       for any such Derivative Works as a whole, provided Your use,
128 |       reproduction, and distribution of the Work otherwise complies with
129 |       the conditions stated in this License.
130 | 
131 |    5. Submission of Contributions. Unless You explicitly state otherwise,
132 |       any Contribution intentionally submitted for inclusion in the Work
133 |       by You to the Licensor shall be under the terms and conditions of
134 |       this License, without any additional terms or conditions.
135 |       Notwithstanding the above, nothing herein shall supersede or modify
136 |       the terms of any separate license agreement you may have executed
137 |       with Licensor regarding such Contributions.
138 | 
139 |    6. Trademarks. This License does not grant permission to use the trade
140 |       names, trademarks, service marks, or product names of the Licensor,
141 |       except as required for reasonable and customary use in describing the
142 |       origin of the Work and reproducing the content of the NOTICE file.
143 | 
144 |    7. Disclaimer of Warranty. Unless required by applicable law or
145 |       agreed to in writing, Licensor provides the Work (and each
146 |       Contributor provides its Contributions) on an "AS IS" BASIS,
147 |       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
148 |       implied, including, without limitation, any warranties or conditions
149 |       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
150 |       PARTICULAR PURPOSE. You are solely responsible for determining the
151 |       appropriateness of using or redistributing the Work and assume any
152 |       risks associated with Your exercise of permissions under this License.
153 | 
154 |    8. Limitation of Liability. In no event and under no legal theory,
155 |       whether in tort (including negligence), contract, or otherwise,
156 |       unless required by applicable law (such as deliberate and grossly
157 |       negligent acts) or agreed to in writing, shall any Contributor be
158 |       liable to You for damages, including any direct, indirect, special,
159 |       incidental, or consequential damages of any character arising as a
160 |       result of this License or out of the use or inability to use the
161 |       Work (including but not limited to damages for loss of goodwill,
162 |       work stoppage, computer failure or malfunction, or any and all
163 |       other commercial damages or losses), even if such Contributor
164 |       has been advised of the possibility of such damages.
165 | 
166 |    9. Accepting Warranty or Additional Liability. While redistributing
167 |       the Work or Derivative Works thereof, You may choose to offer,
168 |       and charge a fee for, acceptance of support, warranty, indemnity,
169 |       or other liability obligations and/or rights consistent with this
170 |       License. However, in accepting such obligations, You may act only
171 |       on Your own behalf and on Your sole responsibility, not on behalf
172 |       of any other Contributor, and only if You agree to indemnify,
173 |       defend, and hold each Contributor harmless for any liability
174 |       incurred by, or claims asserted against, such Contributor by reason
175 |       of your accepting any such warranty or additional liability.
176 | 
177 |    END OF TERMS AND CONDITIONS
178 | 
179 |    APPENDIX: How to apply the Apache License to your work.
180 | 
181 |       To apply the Apache License to your work, attach the following
182 |       boilerplate notice, with the fields enclosed by brackets "[]"
183 |       replaced with your own identifying information. (Don't include
184 |       the brackets!)  The text should be enclosed in the appropriate
185 |       comment syntax for the file format. We also recommend that a
186 |       file or class name and description of purpose be included on the
187 |       same "printed page" as the copyright notice for easier
188 |       identification within third-party archives.
189 | 
190 |    Copyright [yyyy] [name of copyright owner]
191 | 
192 |    Licensed under the Apache License, Version 2.0 (the "License");
193 |    you may not use this file except in compliance with the License.
194 |    You may obtain a copy of the License at
195 | 
196 |        http://www.apache.org/licenses/LICENSE-2.0
197 | 
198 |    Unless required by applicable law or agreed to in writing, software
199 |    distributed under the License is distributed on an "AS IS" BASIS,
200 |    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
201 |    See the License for the specific language governing permissions and
202 |    limitations under the License.
203 | 


--------------------------------------------------------------------------------
/src/app.rs:
--------------------------------------------------------------------------------
  1 | use crate::{
  2 |     ComponentInputResult,
  3 |     commander::Commander,
  4 |     env::Env,
  5 |     ui::{
  6 |         Component, ComponentAction, bookmarks_tab::BookmarksTab, command_log_tab::CommandLogTab,
  7 |         command_popup::CommandPopup, files_tab::FilesTab, log_tab::LogTab,
  8 |     },
  9 | };
 10 | use anyhow::{Result, anyhow};
 11 | use core::fmt;
 12 | use ratatui::crossterm::event::{self, Event, KeyCode, KeyModifiers};
 13 | use tracing::{info, info_span};
 14 | 
 15 | #[derive(PartialEq, Copy, Clone)]
 16 | pub enum Tab {
 17 |     Log,
 18 |     Files,
 19 |     Bookmarks,
 20 |     CommandLog,
 21 | }
 22 | 
 23 | impl fmt::Display for Tab {
 24 |     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 25 |         match self {
 26 |             Tab::Log => write!(f, "Log"),
 27 |             Tab::Files => write!(f, "Files"),
 28 |             Tab::Bookmarks => write!(f, "Bookmarks"),
 29 |             Tab::CommandLog => write!(f, "Command Log"),
 30 |         }
 31 |     }
 32 | }
 33 | 
 34 | impl Tab {
 35 |     pub const VALUES: [Self; 4] = [Tab::Log, Tab::Files, Tab::Bookmarks, Tab::CommandLog];
 36 | }
 37 | 
 38 | pub struct App<'a> {
 39 |     pub env: Env,
 40 |     pub current_tab: Tab,
 41 |     pub log: Option<LogTab<'a>>,
 42 |     pub files: Option<FilesTab>,
 43 |     pub bookmarks: Option<BookmarksTab<'a>>,
 44 |     pub command_log: Option<CommandLogTab>,
 45 |     pub popup: Option<Box<dyn Component>>,
 46 | }
 47 | 
 48 | impl<'a> App<'a> {
 49 |     pub fn new(env: Env) -> Result<App<'a>> {
 50 |         Ok(App {
 51 |             env,
 52 |             current_tab: Tab::Log,
 53 |             log: None,
 54 |             files: None,
 55 |             bookmarks: None,
 56 |             command_log: None,
 57 |             popup: None,
 58 |         })
 59 |     }
 60 | 
 61 |     pub fn get_or_init_current_tab(
 62 |         &mut self,
 63 |         commander: &mut Commander,
 64 |     ) -> Result<&mut dyn Component> {
 65 |         self.get_or_init_tab(commander, self.current_tab)
 66 |     }
 67 |     pub fn get_current_tab(&mut self) -> Option<&mut dyn Component> {
 68 |         self.get_tab(self.current_tab)
 69 |     }
 70 | 
 71 |     pub fn set_next_tab_with_offset(
 72 |         &mut self,
 73 |         commander: &mut Commander,
 74 |         offset: i64,
 75 |     ) -> Result<()> {
 76 |         let current_index = Tab::VALUES
 77 |             .iter()
 78 |             .position(|&t| t == self.current_tab)
 79 |             .unwrap();
 80 |         let new_index =
 81 |             (current_index as i64 + Tab::VALUES.len() as i64 + offset) as usize % Tab::VALUES.len();
 82 |         let new_tab: Tab = Tab::VALUES[new_index];
 83 |         self.set_tab(commander, new_tab)
 84 |     }
 85 | 
 86 |     pub fn set_tab(&mut self, commander: &mut Commander, tab: Tab) -> Result<()> {
 87 |         info!("Setting tab to {}", tab);
 88 |         self.current_tab = tab;
 89 | 
 90 |         self.get_or_init_current_tab(commander)?.focus(commander)?;
 91 |         Ok(())
 92 |     }
 93 | 
 94 |     pub fn get_log_tab(&mut self, commander: &mut Commander) -> Result<&mut LogTab<'a>> {
 95 |         if self.log.is_none() {
 96 |             let span = info_span!("Initializing log tab");
 97 |             let log_tab = span.in_scope(|| LogTab::new(commander))?;
 98 |             self.log = Some(log_tab);
 99 |         }
100 | 
101 |         self.log
102 |             .as_mut()
103 |             .ok_or_else(|| anyhow!("Failed to get mutable reference to LogTab"))
104 |     }
105 | 
106 |     pub fn get_files_tab(&mut self, commander: &mut Commander) -> Result<&mut FilesTab> {
107 |         if self.files.is_none() {
108 |             let span = info_span!("Initializing files tab");
109 |             let files_tab = span.in_scope(|| {
110 |                 let current_head = commander.get_current_head()?;
111 |                 FilesTab::new(commander, &current_head)
112 |             })?;
113 |             self.files = Some(files_tab);
114 |         }
115 | 
116 |         self.files
117 |             .as_mut()
118 |             .ok_or_else(|| anyhow!("Failed to get mutable reference to FilesTab"))
119 |     }
120 | 
121 |     pub fn get_bookmarks_tab(
122 |         &mut self,
123 |         commander: &mut Commander,
124 |     ) -> Result<&mut BookmarksTab<'a>> {
125 |         if self.bookmarks.is_none() {
126 |             let span = info_span!("Initializing bookmarks tab");
127 |             let bookmarks_tab = span.in_scope(|| BookmarksTab::new(commander))?;
128 |             self.bookmarks = Some(bookmarks_tab);
129 |         }
130 | 
131 |         self.bookmarks
132 |             .as_mut()
133 |             .ok_or_else(|| anyhow!("Failed to get mutable reference to BookmarksTab"))
134 |     }
135 | 
136 |     pub fn get_command_log_tab(&mut self, commander: &mut Commander) -> Result<&mut CommandLogTab> {
137 |         if self.command_log.is_none() {
138 |             let span = info_span!("Initializing command log tab");
139 |             let command_log_tab = span.in_scope(|| CommandLogTab::new(commander))?;
140 |             self.command_log = Some(command_log_tab);
141 |         }
142 | 
143 |         self.command_log
144 |             .as_mut()
145 |             .ok_or_else(|| anyhow!("Failed to get mutable reference to CommandLogTab"))
146 |     }
147 | 
148 |     pub fn get_or_init_tab(
149 |         &mut self,
150 |         commander: &mut Commander,
151 |         tab: Tab,
152 |     ) -> Result<&mut dyn Component> {
153 |         Ok(match tab {
154 |             Tab::Log => self.get_log_tab(commander)?,
155 |             Tab::Files => self.get_files_tab(commander)?,
156 |             Tab::Bookmarks => self.get_bookmarks_tab(commander)?,
157 |             Tab::CommandLog => self.get_command_log_tab(commander)?,
158 |         })
159 |     }
160 | 
161 |     pub fn get_tab(&mut self, tab: Tab) -> Option<&mut dyn Component> {
162 |         match tab {
163 |             Tab::Log => self
164 |                 .log
165 |                 .as_mut()
166 |                 .map(|log_tab| log_tab as &mut dyn Component),
167 |             Tab::Files => self
168 |                 .files
169 |                 .as_mut()
170 |                 .map(|files_tab| files_tab as &mut dyn Component),
171 |             Tab::Bookmarks => self
172 |                 .bookmarks
173 |                 .as_mut()
174 |                 .map(|bookmarks_tab| bookmarks_tab as &mut dyn Component),
175 |             Tab::CommandLog => self
176 |                 .command_log
177 |                 .as_mut()
178 |                 .map(|command_log_tab| command_log_tab as &mut dyn Component),
179 |         }
180 |     }
181 | 
182 |     pub fn handle_action(
183 |         &mut self,
184 |         component_action: ComponentAction,
185 |         commander: &mut Commander,
186 |     ) -> Result<()> {
187 |         match component_action {
188 |             ComponentAction::ViewFiles(head) => {
189 |                 self.set_tab(commander, Tab::Files)?;
190 |                 self.get_files_tab(commander)?.set_head(commander, &head)?;
191 |             }
192 |             ComponentAction::ViewLog(head) => {
193 |                 self.get_log_tab(commander)?.set_head(commander, head);
194 |                 self.set_tab(commander, Tab::Log)?;
195 |             }
196 |             ComponentAction::ChangeHead(head) => {
197 |                 self.get_files_tab(commander)?.set_head(commander, &head)?;
198 |             }
199 |             ComponentAction::SetPopup(popup) => {
200 |                 self.popup = popup;
201 |             }
202 |             ComponentAction::Multiple(component_actions) => {
203 |                 for component_action in component_actions.into_iter() {
204 |                     self.handle_action(component_action, commander)?;
205 |                 }
206 |             }
207 |             ComponentAction::RefreshTab() => {
208 |                 self.set_tab(commander, self.current_tab)?;
209 |                 match self.current_tab {
210 |                     Tab::Log => {
211 |                         let head = commander.get_current_head()?;
212 |                         self.get_log_tab(commander)?.set_head(commander, head);
213 |                     }
214 |                     Tab::CommandLog => {
215 |                         self.get_command_log_tab(commander)?.update(commander)?;
216 |                     }
217 |                     _ => {}
218 |                 };
219 |             }
220 |         }
221 | 
222 |         Ok(())
223 |     }
224 | 
225 |     pub fn input(&mut self, event: Event, commander: &mut Commander) -> Result<bool> {
226 |         if let Some(popup) = self.popup.as_mut() {
227 |             match popup.input(commander, event.clone())? {
228 |                 ComponentInputResult::HandledAction(component_action) => {
229 |                     self.handle_action(component_action, commander)?
230 |                 }
231 |                 ComponentInputResult::Handled => {}
232 |                 ComponentInputResult::NotHandled => {
233 |                     if let Event::Key(key) = event
234 |                         && key.kind == event::KeyEventKind::Press
235 |                     {
236 |                         // Close
237 |                         if matches!(
238 |                             key.code,
239 |                             KeyCode::Char('y')
240 |                                 | KeyCode::Char('n')
241 |                                 | KeyCode::Char('o')
242 |                                 | KeyCode::Enter
243 |                                 | KeyCode::Char('q')
244 |                                 | KeyCode::Esc
245 |                         ) {
246 |                             self.popup = None
247 |                         }
248 |                     }
249 |                 }
250 |             };
251 |         } else if event == event::Event::FocusGained {
252 |             self.get_or_init_current_tab(commander)?.focus(commander)?;
253 |         } else {
254 |             match self
255 |                 .get_or_init_current_tab(commander)?
256 |                 .input(commander, event.clone())?
257 |             {
258 |                 ComponentInputResult::HandledAction(component_action) => {
259 |                     self.handle_action(component_action, commander)?
260 |                 }
261 |                 ComponentInputResult::Handled => {}
262 |                 ComponentInputResult::NotHandled => {
263 |                     if let Event::Key(key) = event
264 |                         && key.kind == event::KeyEventKind::Press
265 |                     {
266 |                         // Close
267 |                         if key.code == KeyCode::Char('q')
268 |                             || (key.modifiers.contains(KeyModifiers::CONTROL)
269 |                                 && (key.code == KeyCode::Char('c')))
270 |                             || key.code == KeyCode::Esc
271 |                         {
272 |                             return Ok(true);
273 |                         }
274 |                         //
275 |                         // Tab switching
276 |                         else if key.code == KeyCode::Char('l') {
277 |                             self.set_next_tab_with_offset(commander, 1)?;
278 |                         } else if key.code == KeyCode::Char('h') {
279 |                             self.set_next_tab_with_offset(commander, -1)?;
280 |                         } else if let Some((_, tab)) =
281 |                             Tab::VALUES.iter().enumerate().find(|(i, _)| {
282 |                                 key.code
283 |                                     == KeyCode::Char(
284 |                                         char::from_digit((*i as u32) + 1u32, 10)
285 |                                             .expect("Tab index could not be converted to digit"),
286 |                                     )
287 |                             })
288 |                         {
289 |                             self.set_tab(commander, *tab)?;
290 |                         }
291 |                         // General jj command runner
292 |                         else if key.code == KeyCode::Char(':') {
293 |                             self.popup = Some(Box::new(CommandPopup::new()));
294 |                         }
295 |                     }
296 |                 }
297 |             };
298 |         }
299 | 
300 |         Ok(false)
301 |     }
302 | }
303 | 


--------------------------------------------------------------------------------
/src/ui/command_log_tab.rs:
--------------------------------------------------------------------------------
  1 | use std::borrow::Borrow;
  2 | 
  3 | use anyhow::Result;
  4 | 
  5 | use ansi_to_tui::IntoText;
  6 | use ratatui::{
  7 |     crossterm::event::{Event, KeyCode, KeyEventKind},
  8 |     prelude::*,
  9 |     widgets::*,
 10 | };
 11 | use tracing::instrument;
 12 | 
 13 | use crate::{
 14 |     ComponentInputResult,
 15 |     commander::{CommandLogItem, Commander},
 16 |     env::Config,
 17 |     ui::{
 18 |         Component, ComponentAction, help_popup::HelpPopup, panel::DetailsPanel,
 19 |         utils::tabs_to_spaces,
 20 |     },
 21 | };
 22 | 
 23 | /// Command log tab. Shows list of commands exectured by lazyjj in main panel and selected command
 24 | /// output in details panel
 25 | pub struct CommandLogTab {
 26 |     command_history: Vec<CommandLogItem>,
 27 |     commands_list_state: ListState,
 28 |     commands_height: u16,
 29 | 
 30 |     output_panel: DetailsPanel,
 31 | 
 32 |     config: Config,
 33 | }
 34 | 
 35 | impl CommandLogTab {
 36 |     #[instrument(level = "trace", skip(commander))]
 37 |     pub fn new(commander: &mut Commander) -> Result<Self> {
 38 |         let command_history = commander.command_history.lock().unwrap().clone();
 39 |         let selected_index = command_history.first().map(|_| 0);
 40 |         let commands_list_state = ListState::default().with_selected(selected_index);
 41 | 
 42 |         Ok(Self {
 43 |             commands_height: 0,
 44 |             commands_list_state,
 45 |             command_history,
 46 |             output_panel: DetailsPanel::new(),
 47 |             config: commander.env.config.clone(),
 48 |         })
 49 |     }
 50 | 
 51 |     pub fn get_output_lines<'a>(&self) -> Result<Vec<Line<'a>>> {
 52 |         let mut output_lines = vec![];
 53 | 
 54 |         if let Some(command) = self
 55 |             .commands_list_state
 56 |             .selected()
 57 |             .and_then(|selected_index| self.command_history.iter().rev().nth(selected_index))
 58 |         {
 59 |             match command.output.clone().borrow() {
 60 |                 Ok(output) => {
 61 |                     output_lines.push(Line::default().spans([
 62 |                         "Command: ".into(),
 63 |                         Span::raw(command.program.to_owned()).fg(Color::Blue),
 64 |                         " ".into(),
 65 |                         command.args.join(" ").fg(Color::Blue),
 66 |                     ]));
 67 |                     output_lines.push(Line::default().spans([
 68 |                         ("Status code: ").into(),
 69 |                         output.status.code().map_or("?".into(), |code| {
 70 |                             Span::raw(code.to_string()).fg(if code > 0 {
 71 |                                 Color::Red
 72 |                             } else {
 73 |                                 Color::Yellow
 74 |                             })
 75 |                         }),
 76 |                     ]));
 77 |                     output_lines.push(
 78 |                         Line::default().spans([
 79 |                             Span::raw("Time: "),
 80 |                             Span::raw(command.time.format("%Y-%m-%d %H:%M:%S").to_string())
 81 |                                 .fg(Color::Cyan),
 82 |                         ]),
 83 |                     );
 84 |                     output_lines.push(
 85 |                         Line::default().spans([
 86 |                             Span::raw("Duration: "),
 87 |                             Span::raw(format!("{}ms", command.duration.num_milliseconds()))
 88 |                                 .fg(Color::Cyan),
 89 |                         ]),
 90 |                     );
 91 |                     output_lines.push(Line::default());
 92 | 
 93 |                     let mut has_output = false;
 94 | 
 95 |                     let stdout = &mut String::from_utf8_lossy(&output.stdout);
 96 |                     if !(stdout.is_empty()) {
 97 |                         output_lines.push(
 98 |                             Line::default().spans([Span::raw("Output:").fg(Color::Green).bold()]),
 99 |                         );
100 |                         output_lines.push(Line::default());
101 |                         output_lines.append(&mut tabs_to_spaces(stdout).into_text()?.lines);
102 |                         has_output = true;
103 |                     }
104 | 
105 |                     let stderr = &mut String::from_utf8_lossy(&output.stderr);
106 |                     if !stdout.is_empty() && !stderr.is_empty() {
107 |                         output_lines.push(Line::default());
108 |                         output_lines.push(Line::default());
109 |                     }
110 | 
111 |                     if !(stderr.is_empty()) {
112 |                         output_lines.push(
113 |                             Line::default()
114 |                                 .spans([Span::raw("Error output:").fg(Color::Green).bold()]),
115 |                         );
116 |                         output_lines.push(Line::default());
117 |                         output_lines.append(&mut stderr.as_ref().into_text()?.lines);
118 |                         has_output = true;
119 |                     }
120 | 
121 |                     if !has_output {
122 |                         output_lines.push(
123 |                             Line::default()
124 |                                 .spans([Span::raw("No output").fg(Color::DarkGray).italic()]),
125 |                         );
126 |                     }
127 |                 }
128 |                 Err(err) => {
129 |                     output_lines.push(Line::default().spans(["Error: ".into(), err.to_string()]))
130 |                 }
131 |             }
132 |         }
133 | 
134 |         Ok(output_lines)
135 |     }
136 | 
137 |     fn scroll_commands(&mut self, scroll: isize) {
138 |         *self.commands_list_state.selected_mut() = Some(
139 |             (self
140 |                 .commands_list_state
141 |                 .selected()
142 |                 .map(|selected_index| selected_index.saturating_add_signed(scroll))
143 |                 .unwrap_or(0))
144 |             .min(self.command_history.len() - 1)
145 |             .max(0),
146 |         );
147 |         self.output_panel.scroll_to(0);
148 |     }
149 | }
150 | 
151 | impl Component for CommandLogTab {
152 |     fn focus(&mut self, commander: &mut Commander) -> Result<()> {
153 |         let command_history = commander.command_history.lock().unwrap().clone();
154 |         let selected_index = command_history.first().map(|_| 0);
155 |         self.commands_list_state.select(selected_index);
156 |         self.command_history = command_history;
157 |         Ok(())
158 |     }
159 | 
160 |     fn draw(
161 |         &mut self,
162 |         f: &mut ratatui::prelude::Frame<'_>,
163 |         area: ratatui::prelude::Rect,
164 |     ) -> Result<()> {
165 |         let chunks = Layout::default()
166 |             .direction(self.config.layout().into())
167 |             .constraints([
168 |                 Constraint::Percentage(self.config.layout_percent()),
169 |                 Constraint::Percentage(100 - self.config.layout_percent()),
170 |             ])
171 |             .split(area);
172 | 
173 |         // Draw commands
174 |         {
175 |             let command_lines = self
176 |                 .command_history
177 |                 .iter()
178 |                 .rev()
179 |                 .enumerate()
180 |                 .map(|(i, command)| {
181 |                     let mut line = Line::default()
182 |                         .spans([
183 |                             " ".into(),
184 |                             Span::raw(command.program.clone()),
185 |                             " ".into(),
186 |                             command.args.join(" ").into(),
187 |                         ])
188 |                         .fg(
189 |                             if command
190 |                                 .output
191 |                                 .as_ref()
192 |                                 .as_ref()
193 |                                 .is_ok_and(|output| output.status.success())
194 |                             {
195 |                                 Color::Blue
196 |                             } else {
197 |                                 Color::Red
198 |                             },
199 |                         );
200 | 
201 |                     if self.commands_list_state.selected() == Some(i) {
202 |                         line = line.bg(self.config.highlight_color());
203 |                     }
204 | 
205 |                     line
206 |                 })
207 |                 .collect::<Vec<Line>>();
208 | 
209 |             let commands = List::new(command_lines)
210 |                 .block(
211 |                     Block::bordered()
212 |                         .title(" Commands ")
213 |                         .border_type(BorderType::Rounded),
214 |                 )
215 |                 .scroll_padding(3);
216 | 
217 |             let commands_len = commands.len();
218 |             f.render_stateful_widget(commands, chunks[0], &mut self.commands_list_state);
219 |             self.commands_height = chunks[0].height.saturating_sub(2);
220 | 
221 |             if commands_len > self.commands_height as usize {
222 |                 let index = self.commands_list_state.selected().unwrap_or(0);
223 |                 let scrollbar = Scrollbar::new(ScrollbarOrientation::VerticalRight);
224 |                 let mut scrollbar_state = ScrollbarState::default()
225 |                     .content_length(commands_len)
226 |                     .position(index);
227 | 
228 |                 f.render_stateful_widget(
229 |                     scrollbar,
230 |                     chunks[0].inner(Margin {
231 |                         vertical: 1,
232 |                         horizontal: 0,
233 |                     }),
234 |                     &mut scrollbar_state,
235 |                 );
236 |             }
237 |         }
238 | 
239 |         // Draw output
240 |         {
241 |             let output_lines = self.get_output_lines()?;
242 |             self.output_panel
243 |                 .render_context()
244 |                 .title(" Output ")
245 |                 .content(output_lines)
246 |                 .draw(f, chunks[1]);
247 |         }
248 | 
249 |         Ok(())
250 |     }
251 | 
252 |     fn input(&mut self, _commander: &mut Commander, event: Event) -> Result<ComponentInputResult> {
253 |         if let Event::Key(key) = event {
254 |             if key.kind != KeyEventKind::Press {
255 |                 return Ok(ComponentInputResult::Handled);
256 |             }
257 | 
258 |             if self.output_panel.input(key) {
259 |                 return Ok(ComponentInputResult::Handled);
260 |             }
261 | 
262 |             match key.code {
263 |                 KeyCode::Char('j') | KeyCode::Down => {
264 |                     self.scroll_commands(1);
265 |                 }
266 |                 KeyCode::Char('k') | KeyCode::Up => {
267 |                     self.scroll_commands(-1);
268 |                 }
269 |                 KeyCode::Char('J') => {
270 |                     self.scroll_commands(self.commands_height as isize / 2);
271 |                 }
272 |                 KeyCode::Char('K') => {
273 |                     self.scroll_commands((self.commands_height as isize / 2).saturating_neg());
274 |                 }
275 |                 KeyCode::Char('@') => {
276 |                     self.scroll_commands(isize::MIN);
277 |                 }
278 |                 KeyCode::Char('?') => {
279 |                     return Ok(ComponentInputResult::HandledAction(
280 |                         ComponentAction::SetPopup(Some(Box::new(HelpPopup::new(
281 |                             vec![
282 |                                 ("j/k".to_owned(), "scroll down/up".to_owned()),
283 |                                 ("J/K".to_owned(), "scroll down by ½ page".to_owned()),
284 |                                 ("@".to_owned(), "latest command".to_owned()),
285 |                             ],
286 |                             vec![
287 |                                 ("Ctrl+e/Ctrl+y".to_owned(), "scroll down/up".to_owned()),
288 |                                 (
289 |                                     "Ctrl+d/Ctrl+u".to_owned(),
290 |                                     "scroll down/up by ½ page".to_owned(),
291 |                                 ),
292 |                                 (
293 |                                     "Ctrl+f/Ctrl+b".to_owned(),
294 |                                     "scroll down/up by page".to_owned(),
295 |                                 ),
296 |                                 ("W".to_owned(), "toggle wrapping".to_owned()),
297 |                             ],
298 |                         )))),
299 |                     ));
300 |                 }
301 |                 _ => return Ok(ComponentInputResult::NotHandled),
302 |             };
303 |         }
304 | 
305 |         if let Event::Mouse(mouse) = event {
306 |             if self.output_panel.input_mouse(mouse) {
307 |                 return Ok(ComponentInputResult::Handled);
308 |             }
309 |             return Ok(ComponentInputResult::NotHandled);
310 |         }
311 | 
312 |         Ok(ComponentInputResult::Handled)
313 |     }
314 | }
315 | 


--------------------------------------------------------------------------------
/src/ui/bookmark_set_popup.rs:
--------------------------------------------------------------------------------
  1 | use ansi_to_tui::IntoText;
  2 | use anyhow::Result;
  3 | use anyhow::bail;
  4 | use ratatui::{
  5 |     crossterm::event::{Event, KeyCode, KeyModifiers},
  6 |     layout::{Alignment, Constraint, Direction, Layout, Rect},
  7 |     style::{Color, Style, Stylize},
  8 |     text::{Span, Text},
  9 |     widgets::{Block, BorderType, Borders, Clear, List, ListState, Paragraph},
 10 | };
 11 | use tui_textarea::TextArea;
 12 | 
 13 | use crate::{
 14 |     ComponentInputResult,
 15 |     commander::{
 16 |         Commander,
 17 |         bookmarks::Bookmark,
 18 |         ids::{ChangeId, CommitId},
 19 |     },
 20 |     env::Config,
 21 |     ui::{
 22 |         Component, ComponentAction,
 23 |         styles::create_popup_block,
 24 |         utils::{centered_rect, centered_rect_line_height},
 25 |     },
 26 | };
 27 | 
 28 | enum BookmarkSetOption {
 29 |     CreateBookmark,
 30 |     // Name, exists
 31 |     GeneratedName(String, bool),
 32 |     Bookmark(Bookmark),
 33 |     Error(String),
 34 | }
 35 | 
 36 | pub struct BookmarkSetPopup<'a> {
 37 |     pub change_id: Option<ChangeId>,
 38 |     commit_id: CommitId,
 39 |     options: Vec<BookmarkSetOption>,
 40 |     list_state: ListState,
 41 |     list_height: u16,
 42 |     config: Config,
 43 |     creating: Option<TextArea<'a>>,
 44 |     tx: std::sync::mpsc::Sender<bool>,
 45 | }
 46 | 
 47 | fn generate_options(
 48 |     commander: &mut Commander,
 49 |     change_id: Option<&ChangeId>,
 50 | ) -> Vec<BookmarkSetOption> {
 51 |     let bookmarks = commander.get_bookmarks_list(false).map(|bookmarks| {
 52 |         bookmarks
 53 |             .into_iter()
 54 |             .filter(|bookmark| bookmark.remote.is_none())
 55 |             .collect::<Vec<Bookmark>>()
 56 |     });
 57 |     let mut options = vec![BookmarkSetOption::CreateBookmark];
 58 | 
 59 |     if let Some(change_id) = change_id {
 60 |         let generated_name = generate_name(&commander.env.config.bookmark_prefix(), change_id);
 61 |         let exists = bookmarks.as_ref().is_ok_and(|bookmarks| {
 62 |             bookmarks
 63 |                 .iter()
 64 |                 .any(|bookmark| bookmark.name == generated_name)
 65 |         });
 66 |         options.push(BookmarkSetOption::GeneratedName(generated_name, exists));
 67 |     }
 68 | 
 69 |     match bookmarks.as_ref() {
 70 |         Ok(bookmarks) => {
 71 |             for bookmark in bookmarks
 72 |                 .iter()
 73 |                 .filter(|bookmark| bookmark.remote.is_none())
 74 |             {
 75 |                 options.push(BookmarkSetOption::Bookmark(bookmark.clone()))
 76 |             }
 77 |         }
 78 |         Err(err) => options.push(BookmarkSetOption::Error(err.to_string())),
 79 |     }
 80 | 
 81 |     options
 82 | }
 83 | 
 84 | fn generate_name(git_push_bookmark_prefix: &str, change_id: &ChangeId) -> String {
 85 |     let mut change_id = change_id.to_string();
 86 |     change_id.truncate(12);
 87 |     format!("{git_push_bookmark_prefix}{change_id}",)
 88 | }
 89 | 
 90 | impl BookmarkSetPopup<'_> {
 91 |     pub fn new(
 92 |         config: Config,
 93 |         commander: &mut Commander,
 94 |         change_id: Option<ChangeId>,
 95 |         commit_id: CommitId,
 96 |         tx: std::sync::mpsc::Sender<bool>,
 97 |     ) -> Self {
 98 |         Self {
 99 |             options: generate_options(commander, change_id.as_ref()),
100 |             change_id,
101 |             list_state: ListState::default().with_selected(Some(0)),
102 |             list_height: 0,
103 |             config,
104 |             commit_id,
105 |             creating: None,
106 |             tx,
107 |         }
108 |     }
109 | 
110 |     fn scroll(&mut self, scroll: isize) {
111 |         self.list_state.select(Some(
112 |             self.list_state
113 |                 .selected()
114 |                 .map(|selected| selected.saturating_add_signed(scroll))
115 |                 .unwrap_or(0)
116 |                 .min(self.options.len().saturating_sub(1)),
117 |         ));
118 |     }
119 | 
120 |     fn on_creating(&mut self) {
121 |         self.creating = Some(TextArea::default());
122 |     }
123 | 
124 |     fn create_bookmark(&self, commander: &mut Commander, name: &str) -> Result<()> {
125 |         if commander
126 |             .get_bookmarks_list(false)?
127 |             .iter()
128 |             .any(|bookmark| bookmark.name == name)
129 |         {
130 |             commander.set_bookmark_commit(name, &self.commit_id)?;
131 |         } else {
132 |             commander.create_bookmark_commit(name, &self.commit_id)?;
133 |         }
134 |         Ok(())
135 |     }
136 |     fn generate_bookmark(&self, commander: &mut Commander) -> Result<()> {
137 |         if let Some(change_id) = self.change_id.as_ref() {
138 |             let generated_name = generate_name(&commander.env.config.bookmark_prefix(), change_id);
139 |             if commander
140 |                 .get_bookmarks_list(false)?
141 |                 .iter()
142 |                 .any(|bookmark| bookmark.name == generated_name)
143 |             {
144 |                 commander.set_bookmark_commit(&generated_name, &self.commit_id)?;
145 |             } else {
146 |                 commander.create_bookmark_commit(&generated_name, &self.commit_id)?;
147 |             }
148 |             Ok(())
149 |         } else {
150 |             bail!("No change ID");
151 |         }
152 |     }
153 | }
154 | 
155 | impl Component for BookmarkSetPopup<'_> {
156 |     fn draw(&mut self, f: &mut ratatui::prelude::Frame<'_>, area: Rect) -> Result<()> {
157 |         if let Some(creating) = self.creating.as_ref() {
158 |             let block = create_popup_block("Create bookmark");
159 |             let area = centered_rect_line_height(area, 30, 5);
160 |             f.render_widget(Clear, area);
161 |             f.render_widget(&block, area);
162 | 
163 |             let popup_chunks = Layout::default()
164 |                 .direction(Direction::Vertical)
165 |                 .constraints([Constraint::Fill(1), Constraint::Length(2)])
166 |                 .split(block.inner(area));
167 | 
168 |             f.render_widget(creating, popup_chunks[0]);
169 | 
170 |             let help = Paragraph::new(vec!["Ctrl+s: save | Escape: cancel".into()])
171 |                 .fg(Color::DarkGray)
172 |                 .alignment(Alignment::Center)
173 |                 .block(
174 |                     Block::default()
175 |                         .borders(Borders::TOP)
176 |                         .border_type(BorderType::Rounded)
177 |                         .border_style(Style::default().fg(Color::DarkGray)),
178 |                 );
179 | 
180 |             f.render_widget(help, popup_chunks[1]);
181 |         } else {
182 |             let block = Block::bordered()
183 |                 .title(Span::styled(
184 |                     " Select bookmark ",
185 |                     Style::new().bold().cyan(),
186 |                 ))
187 |                 .title_alignment(Alignment::Center)
188 |                 .border_type(BorderType::Rounded)
189 |                 .border_style(Style::default().fg(Color::Green));
190 |             let area = centered_rect(area, 40, 60);
191 |             f.render_widget(Clear, area);
192 |             f.render_widget(&block, area);
193 | 
194 |             let popup_chunks = Layout::default()
195 |                 .direction(Direction::Vertical)
196 |                 .constraints([Constraint::Fill(1), Constraint::Length(2)])
197 |                 .split(block.inner(area));
198 | 
199 |             let list_items = self.options.iter().map(|option| match option {
200 |                 BookmarkSetOption::CreateBookmark => {
201 |                     Text::raw("(C)reate bookmark").fg(Color::Yellow)
202 |                 }
203 |                 BookmarkSetOption::GeneratedName(generated_name, exists) => {
204 |                     let mut text = format!("(G)enerate bookmark: {generated_name}");
205 |                     if *exists {
206 |                         text.push_str(" (exists)");
207 |                     }
208 |                     Text::raw(text).fg(Color::Yellow)
209 |                 }
210 |                 BookmarkSetOption::Bookmark(bookmark) => {
211 |                     Text::raw(bookmark.to_string()).fg(Color::Magenta)
212 |                 }
213 |                 BookmarkSetOption::Error(err) => err.into_text().unwrap(),
214 |             });
215 | 
216 |             let list = List::new(list_items)
217 |                 .scroll_padding(3)
218 |                 .highlight_style(Style::default().bg(self.config.highlight_color()));
219 | 
220 |             f.render_stateful_widget(list, popup_chunks[0], &mut self.list_state);
221 |             self.list_height = popup_chunks[0].height;
222 | 
223 |             let help = Paragraph::new(vec!["j/k: scroll down/up | Escape: cancel".into()])
224 |                 .fg(Color::DarkGray)
225 |                 .alignment(Alignment::Center)
226 |                 .block(
227 |                     Block::default()
228 |                         .borders(Borders::TOP)
229 |                         .border_type(BorderType::Rounded)
230 |                         .border_style(Style::default().fg(Color::DarkGray)),
231 |                 );
232 | 
233 |             f.render_widget(help, popup_chunks[1]);
234 |         }
235 | 
236 |         Ok(())
237 |     }
238 | 
239 |     /// Handle input. Returns bool of if to close
240 |     fn input(
241 |         &mut self,
242 |         commander: &mut Commander,
243 |         event: Event,
244 |     ) -> anyhow::Result<crate::ComponentInputResult> {
245 |         if let Some(creating) = self.creating.as_mut() {
246 |             if let Event::Key(key) = event {
247 |                 match key.code {
248 |                     _ if (key.code == KeyCode::Char('s')
249 |                         && key.modifiers.contains(KeyModifiers::CONTROL))
250 |                         || (key.code == KeyCode::Enter) =>
251 |                     {
252 |                         let name = &creating.lines().join("\n");
253 |                         if name.trim().is_empty() {
254 |                             return Ok(ComponentInputResult::Handled);
255 |                         }
256 | 
257 |                         self.create_bookmark(commander, name)?;
258 |                         self.tx.send(true)?;
259 |                         return Ok(ComponentInputResult::HandledAction(
260 |                             ComponentAction::SetPopup(None),
261 |                         ));
262 |                     }
263 |                     KeyCode::Esc => {
264 |                         return Ok(ComponentInputResult::HandledAction(
265 |                             ComponentAction::SetPopup(None),
266 |                         ));
267 |                     }
268 |                     _ => {}
269 |                 }
270 |             }
271 | 
272 |             creating.input(event);
273 |             return Ok(ComponentInputResult::Handled);
274 |         }
275 | 
276 |         if let Event::Key(key) = event {
277 |             match key.code {
278 |                 KeyCode::Char('j') | KeyCode::Down => {
279 |                     self.scroll(1);
280 |                 }
281 |                 KeyCode::Char('k') | KeyCode::Up => {
282 |                     self.scroll(-1);
283 |                 }
284 |                 KeyCode::Char('J') => {
285 |                     self.scroll(self.list_height as isize / 2);
286 |                 }
287 |                 KeyCode::Char('K') => {
288 |                     self.scroll((self.list_height as isize / 2).saturating_neg());
289 |                 }
290 |                 KeyCode::Char('g') => {
291 |                     self.generate_bookmark(commander)?;
292 |                     self.tx.send(true)?;
293 |                     return Ok(ComponentInputResult::HandledAction(
294 |                         ComponentAction::SetPopup(None),
295 |                     ));
296 |                 }
297 |                 KeyCode::Char('c') => {
298 |                     self.on_creating();
299 |                 }
300 |                 KeyCode::Enter => {
301 |                     if let Some(action) = self
302 |                         .list_state
303 |                         .selected()
304 |                         .and_then(|index| self.options.get(index))
305 |                     {
306 |                         match action {
307 |                             BookmarkSetOption::CreateBookmark => {
308 |                                 self.on_creating();
309 |                             }
310 |                             BookmarkSetOption::GeneratedName(_, _) => {
311 |                                 self.generate_bookmark(commander)?;
312 |                                 self.tx.send(true)?;
313 |                                 return Ok(ComponentInputResult::HandledAction(
314 |                                     ComponentAction::SetPopup(None),
315 |                                 ));
316 |                             }
317 |                             BookmarkSetOption::Bookmark(bookmark) => {
318 |                                 commander.set_bookmark_commit(&bookmark.name, &self.commit_id)?;
319 |                                 self.tx.send(true)?;
320 |                                 return Ok(ComponentInputResult::HandledAction(
321 |                                     ComponentAction::SetPopup(None),
322 |                                 ));
323 |                             }
324 |                             BookmarkSetOption::Error(_) => {
325 |                                 self.options = generate_options(commander, self.change_id.as_ref());
326 |                             }
327 |                         }
328 |                     }
329 |                 }
330 |                 KeyCode::Char('q') | KeyCode::Esc => {
331 |                     self.tx.send(false)?;
332 |                     return Ok(ComponentInputResult::HandledAction(
333 |                         ComponentAction::SetPopup(None),
334 |                     ));
335 |                 }
336 |                 _ => return Ok(ComponentInputResult::NotHandled),
337 |             }
338 | 
339 |             return Ok(ComponentInputResult::Handled);
340 |         }
341 | 
342 |         Ok(ComponentInputResult::NotHandled)
343 |     }
344 | }
345 | 


--------------------------------------------------------------------------------
/src/ui/panel/log_panel.rs:
--------------------------------------------------------------------------------
  1 | /*! The log panel shows the list of changes on the left side of the
  2 | log tab. */
  3 | 
  4 | use ansi_to_tui::IntoText;
  5 | use anyhow::Result;
  6 | use ratatui::{
  7 |     crossterm::event::{Event, MouseEvent, MouseEventKind},
  8 |     layout::Rect,
  9 |     prelude::*,
 10 |     text::ToText,
 11 |     widgets::*,
 12 | };
 13 | 
 14 | use crate::{
 15 |     commander::{
 16 |         CommandError, Commander,
 17 |         log::{Head, LogOutput},
 18 |     },
 19 |     env::Config,
 20 |     keybinds::{LogTabEvent, LogTabKeybinds},
 21 |     ui::Component,
 22 |     ui::ComponentAction,
 23 |     ui::ComponentInputResult,
 24 | };
 25 | 
 26 | /**
 27 |     A panel that displays the output of jj log.
 28 |     This panel is used on the left side of the log tab.
 29 |     It shows a selected change, which is expanded
 30 |     on the right side of the log tab.
 31 | 
 32 |     The log operates with two index:
 33 |     - line index (into self.log_output.text)
 34 |     - head index (into self.log_output.heads)
 35 | 
 36 |     The line index is used for scrolling at the display leve.
 37 | 
 38 |     The head index is used for scrolling at the user level
 39 |     as well as for selecting which lines to highlight.
 40 | */
 41 | pub struct LogPanel<'a> {
 42 |     log_output: Result<LogOutput, CommandError>,
 43 |     log_output_text: Text<'a>,
 44 |     log_list_state: ListState,
 45 |     pub log_rect: Rect,
 46 | 
 47 |     /// The revision set to show in the log
 48 |     pub log_revset: Option<String>,
 49 | 
 50 |     /// Currently selected change
 51 |     pub head: Head,
 52 | 
 53 |     /// Rect used last time draw was called. Can be used to check if mouse clicks
 54 |     panel_rect: Rect,
 55 | 
 56 |     config: Config,
 57 | }
 58 | 
 59 | /*
 60 | pub enum LogPanelEvent {
 61 |     /* Commands to LogPanel */
 62 | 
 63 |     /// Refresh current state
 64 |     Refresh,
 65 |     /// Move selection down the given number of changes
 66 |     MoveRelative(isize),
 67 | 
 68 |     /* Notifications from LogPanel */
 69 | 
 70 |     /// Emitted when selection was changed
 71 |     SetHead(Head),
 72 | }
 73 | */
 74 | 
 75 | fn get_head_index(head: &Head, log_output: &Result<LogOutput, CommandError>) -> Option<usize> {
 76 |     match log_output {
 77 |         Ok(log_output) => log_output
 78 |             .heads
 79 |             .iter()
 80 |             .position(|heads| heads == head)
 81 |             .or_else(|| {
 82 |                 log_output
 83 |                     .heads
 84 |                     .iter()
 85 |                     .position(|commit| commit.change_id == head.change_id)
 86 |             }),
 87 |         Err(_) => None,
 88 |     }
 89 | }
 90 | 
 91 | impl<'a> LogPanel<'a> {
 92 |     pub fn new(commander: &mut Commander) -> Result<Self> {
 93 |         let log_revset = commander.env.default_revset.clone();
 94 |         let log_output = commander.get_log(&log_revset);
 95 |         let head = commander.get_current_head()?;
 96 | 
 97 |         let log_list_state = ListState::default().with_selected(get_head_index(&head, &log_output));
 98 | 
 99 |         let mut keybinds = LogTabKeybinds::default();
100 |         if let Some(new_keybinds) = commander
101 |             .env
102 |             .config
103 |             .keybinds()
104 |             .and_then(|k| k.log_tab.clone())
105 |         {
106 |             keybinds.extend_from_config(&new_keybinds);
107 |         }
108 | 
109 |         let log_output_text = match log_output.as_ref() {
110 |             Ok(log_output) => log_output
111 |                 .graph
112 |                 .into_text()
113 |                 .unwrap_or(Text::from("Could not turn text into TUI text (coloring)")),
114 |             Err(_) => Text::default(),
115 |         };
116 | 
117 |         Ok(Self {
118 |             log_output_text,
119 |             log_output,
120 |             log_list_state,
121 |             log_rect: Rect::ZERO,
122 | 
123 |             log_revset,
124 | 
125 |             head,
126 | 
127 |             panel_rect: Rect::ZERO,
128 | 
129 |             config: commander.env.config.clone(),
130 |         })
131 |     }
132 | 
133 |     //
134 |     //  Handle jj log output
135 |     //
136 | 
137 |     /// Run jj log and store output for display
138 |     pub fn refresh_log_output(&mut self, commander: &mut Commander) {
139 |         self.log_output = commander.get_log(&self.log_revset);
140 |         self.log_output_text = match self.log_output.as_ref() {
141 |             Ok(log_output) => log_output
142 |                 .graph
143 |                 .into_text()
144 |                 .unwrap_or(Text::from("Could not turn text into TUI text (coloring)")),
145 |             Err(_) => Text::default(),
146 |         };
147 |     }
148 | 
149 |     /// Convert log output to a list of formatted lines
150 |     fn output_to_lines(&self, log_output: &LogOutput) -> Vec<Line<'a>> {
151 |         // Set the background color of the line
152 |         fn set_bg(line: &mut Line, bg_color: Color) {
153 |             // Set background to use when no Span is present
154 |             // This makes the highlight continue beyond the last Span
155 |             line.style = line.style.patch(Style::default().bg(bg_color));
156 | 
157 |             for span in line.spans.iter_mut() {
158 |                 span.style = span.style.bg(bg_color)
159 |             }
160 |         }
161 | 
162 |         self.log_output_text
163 |             .iter()
164 |             .enumerate()
165 |             .map(|(i, line)| {
166 |                 let mut line = line.to_owned();
167 | 
168 |                 // Add padding at start
169 |                 line.spans.insert(0, Span::from(" "));
170 | 
171 |                 // Highlight lines that correspond to self.head
172 |                 let line_head = log_output.graph_heads.get(i).unwrap_or(&None);
173 |                 if let Some(line_change) = line_head
174 |                     && line_change == &self.head
175 |                 {
176 |                     set_bg(&mut line, self.config.highlight_color());
177 |                 };
178 | 
179 |                 line
180 |             })
181 |             .collect()
182 |     }
183 | 
184 |     /// Get lines to show in log list
185 |     fn log_lines(&self) -> Vec<Line<'a>> {
186 |         match self.log_output.as_ref() {
187 |             Ok(log_output) => self.output_to_lines(log_output),
188 |             Err(err) => err.into_text("Error getting log").unwrap().lines,
189 |         }
190 |     }
191 | 
192 |     //
193 |     //  Selected head and the special head index
194 |     //
195 | 
196 |     /// Find the line in self.log_output that match self.head
197 |     fn selected_log_line(&self) -> Option<usize> {
198 |         let log_output = self.log_output.as_ref().ok()?;
199 | 
200 |         log_output
201 |             .graph_heads
202 |             .iter()
203 |             .position(|opt_h| opt_h.as_ref().is_some_and(|h| h == &self.head))
204 |     }
205 | 
206 |     /// Find head of the provided log_output line
207 |     fn head_at_log_line(&mut self, log_line: usize) -> Option<Head> {
208 |         let log_output = self.log_output.as_ref().ok()?;
209 | 
210 |         let graph_head = log_output.graph_heads.get(log_line)?;
211 | 
212 |         graph_head.clone()
213 |     }
214 | 
215 |     // Return the head-index for the selection
216 |     fn get_current_head_index(&self) -> Option<usize> {
217 |         get_head_index(&self.head, &self.log_output)
218 |     }
219 | 
220 |     /// Number of log list items that fit on screen. Think of this as
221 |     /// in unit head-index. Moving the head-index this much causes a
222 |     /// full page scroll.
223 |     fn visible_heads(&self) -> u16 {
224 |         // Every item in the log list is 2 lines high, so divide screen rows
225 |         // by 2 to get the number of log items that fit in it.
226 |         self.log_rect.height / 2
227 |     }
228 | 
229 |     /// Move selection to a specific head. This may cause the next draw to
230 |     /// scroll to a different line.
231 |     pub fn set_head(&mut self, head: Head) {
232 |         head.clone_into(&mut self.head);
233 |     }
234 | 
235 |     /// Move selection relative to the current position.
236 |     /// The scroll is relative to head-index, not line-index.
237 |     /// This will update self.head
238 |     fn scroll_relative(&mut self, _commander: &mut Commander, scroll: isize) {
239 |         let log_output = match self.log_output.as_ref() {
240 |             Ok(log_output) => log_output,
241 |             Err(_) => return,
242 |         };
243 | 
244 |         let heads: &Vec<Head> = log_output.heads.as_ref();
245 | 
246 |         let current_head_index = self.get_current_head_index();
247 |         let next_head = match current_head_index {
248 |             Some(current_head_index) => heads.get(
249 |                 current_head_index
250 |                     .saturating_add_signed(scroll)
251 |                     .min(heads.len() - 1),
252 |             ),
253 |             None => heads.first(),
254 |         };
255 |         if let Some(next_head) = next_head {
256 |             self.set_head(next_head.clone());
257 |         }
258 |         // TODO Notify about change of head
259 |     }
260 | 
261 |     //
262 |     //  Event handling
263 |     //
264 | 
265 |     pub fn handle_event(
266 |         &mut self,
267 |         commander: &mut Commander,
268 |         log_tab_event: LogTabEvent,
269 |     ) -> Result<ComponentInputResult> {
270 |         match log_tab_event {
271 |             LogTabEvent::ScrollDown => {
272 |                 self.scroll_relative(commander, 1);
273 |             }
274 |             LogTabEvent::ScrollUp => {
275 |                 self.scroll_relative(commander, -1);
276 |             }
277 |             LogTabEvent::ScrollDownHalf => {
278 |                 self.scroll_relative(commander, self.visible_heads() as isize / 2);
279 |             }
280 |             LogTabEvent::ScrollUpHalf => {
281 |                 self.scroll_relative(
282 |                     commander,
283 |                     (self.visible_heads() as isize / 2).saturating_neg(),
284 |                 );
285 |             }
286 |             _ => {
287 |                 return Ok(ComponentInputResult::NotHandled);
288 |             }
289 |         }
290 |         Ok(ComponentInputResult::Handled)
291 |     }
292 | }
293 | 
294 | impl Component for LogPanel<'_> {
295 |     // Called when switching to tab
296 |     fn focus(&mut self, _commander: &mut Commander) -> Result<()> {
297 |         Ok(())
298 |     }
299 | 
300 |     fn update(&mut self, _commander: &mut Commander) -> Result<Option<ComponentAction>> {
301 |         Ok(None)
302 |     }
303 | 
304 |     fn draw(&mut self, f: &mut Frame<'_>, area: Rect) -> Result<()> {
305 |         self.panel_rect = area;
306 | 
307 |         let title = match &self.log_revset {
308 |             Some(log_revset) => &format!(" Log for: {log_revset} "),
309 |             None => " Log ",
310 |         };
311 | 
312 |         let log_lines = self.log_lines();
313 |         let log_length: usize = log_lines.len();
314 |         let log_block = Block::bordered()
315 |             .title(title)
316 |             .border_type(BorderType::Rounded);
317 |         self.log_rect = log_block.inner(area);
318 |         self.log_list_state.select(self.selected_log_line());
319 |         let log = List::new(log_lines).block(log_block).scroll_padding(7);
320 |         f.render_stateful_widget(log, area, &mut self.log_list_state);
321 | 
322 |         // Show scrollbar if lines don't fit the screen height
323 |         if log_length > self.log_rect.height.into() {
324 |             let index = self.log_list_state.selected().unwrap_or(0);
325 |             let scrollbar = Scrollbar::new(ScrollbarOrientation::VerticalRight);
326 |             let mut scrollbar_state = ScrollbarState::default()
327 |                 .content_length(log_length)
328 |                 .position(index);
329 | 
330 |             f.render_stateful_widget(
331 |                 scrollbar,
332 |                 area.inner(Margin {
333 |                     vertical: 1,
334 |                     horizontal: 0,
335 |                 }),
336 |                 &mut scrollbar_state,
337 |             );
338 |         }
339 | 
340 |         Ok(())
341 |     }
342 | 
343 |     fn input(&mut self, commander: &mut Commander, event: Event) -> Result<ComponentInputResult> {
344 |         if let Event::Mouse(mouse_event) = event {
345 |             // Determine if mouse event is inside log-view
346 |             let mouse_pos = Position::new(mouse_event.column, mouse_event.row);
347 |             if !self.panel_rect.contains(mouse_pos) {
348 |                 return Ok(ComponentInputResult::NotHandled);
349 |             }
350 | 
351 |             // Execute command dependent on panel and event kind
352 |             match mouse_event.kind {
353 |                 MouseEventKind::ScrollUp => {
354 |                     self.handle_event(commander, LogTabEvent::ScrollUp)?;
355 |                     return Ok(ComponentInputResult::Handled);
356 |                 }
357 |                 MouseEventKind::ScrollDown => {
358 |                     self.handle_event(commander, LogTabEvent::ScrollDown)?;
359 |                     return Ok(ComponentInputResult::Handled);
360 |                 }
361 |                 MouseEventKind::Up(_) => {
362 |                     // Check all items in list
363 | 
364 |                     // TODO make a function that constructs the log list
365 |                     let log_lines = self.log_lines();
366 |                     let log_items: Vec<ListItem> = log_lines
367 |                         .iter()
368 |                         .map(|line| ListItem::from(line.to_text()))
369 |                         .collect();
370 | 
371 |                     // Select the clicked change
372 |                     if let Some(inx) = list_item_from_mouse_event(
373 |                         &log_items,
374 |                         self.log_rect,
375 |                         &self.log_list_state,
376 |                         &mouse_event,
377 |                     ) && let Some(head) = self.head_at_log_line(inx)
378 |                     {
379 |                         self.set_head(head);
380 |                     }
381 |                 }
382 |                 _ => {} // Handle other mouse events if necessary
383 |             }
384 |         }
385 | 
386 |         Ok(ComponentInputResult::NotHandled)
387 |     }
388 | }
389 | 
390 | // Determine which list item a mouse event is related to
391 | fn list_item_from_mouse_event(
392 |     list: &[ListItem],
393 |     list_rect: Rect,
394 |     list_state: &ListState,
395 |     mouse_event: &MouseEvent,
396 | ) -> Option<usize> {
397 |     let mouse_pos = Position::new(mouse_event.column, mouse_event.row);
398 |     if !list_rect.contains(mouse_pos) {
399 |         return None;
400 |     }
401 | 
402 |     // Assume that each item is exactly one line.
403 |     // This is not true in the general case, but it is in this module.
404 |     let mouse_offset = mouse_pos.y - list_rect.y;
405 |     let item_index = list_state.offset() + mouse_offset as usize;
406 |     if item_index >= list.len() {
407 |         return None;
408 |     }
409 |     Some(item_index)
410 | }
411 | 


--------------------------------------------------------------------------------
/src/commander/files.rs:
--------------------------------------------------------------------------------
  1 | /*!
  2 | [Commander] member functions related to jj diff.
  3 | 
  4 | This module has features to parse the diff output.
  5 | It is mostly used in the [files_tab][crate::ui::files_tab] module.
  6 | */
  7 | use std::sync::LazyLock;
  8 | 
  9 | use crate::{
 10 |     commander::{CommandError, Commander, ids::CommitId, log::Head},
 11 |     env::DiffFormat,
 12 | };
 13 | 
 14 | use anyhow::{Context, Result};
 15 | use ratatui::style::Color;
 16 | use regex::Regex;
 17 | use tracing::instrument;
 18 | 
 19 | #[derive(Clone, Debug, PartialEq)]
 20 | pub struct File {
 21 |     pub line: String,
 22 |     pub path: Option<String>,
 23 |     pub diff_type: Option<DiffType>,
 24 | }
 25 | 
 26 | #[derive(Clone, Debug, PartialEq)]
 27 | pub enum DiffType {
 28 |     Added,
 29 |     Modified,
 30 |     Deleted,
 31 |     Renamed,
 32 | }
 33 | 
 34 | #[derive(Clone, Debug, PartialEq)]
 35 | pub struct Conflict {
 36 |     pub path: String,
 37 | }
 38 | 
 39 | impl DiffType {
 40 |     pub fn parse(value: &str) -> Option<Self> {
 41 |         match value {
 42 |             "A" => Some(DiffType::Added),
 43 |             "M" => Some(DiffType::Modified),
 44 |             "D" => Some(DiffType::Deleted),
 45 |             "R" => Some(DiffType::Renamed),
 46 |             _ => None,
 47 |         }
 48 |     }
 49 | 
 50 |     pub fn color(&self) -> Color {
 51 |         match self {
 52 |             DiffType::Added => Color::Green,
 53 |             DiffType::Modified => Color::Cyan,
 54 |             DiffType::Renamed => Color::Cyan,
 55 |             DiffType::Deleted => Color::Red,
 56 |         }
 57 |     }
 58 | }
 59 | 
 60 | // Example line: `A README.md`, `M src/main.rs`, `D Hello World`
 61 | static FILES_REGEX: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(.) (.*)").unwrap());
 62 | static RENAME_REGEX: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"\{(.*?) => (.*?)\}").unwrap());
 63 | static CONFLICTS_REGEX: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(.*)    .*").unwrap());
 64 | 
 65 | impl Commander {
 66 |     /// Get list of changes files in a change. Parses the output.
 67 |     /// Maps to `jj diff --summary -r <revision>`
 68 |     #[instrument(level = "trace", skip(self))]
 69 |     pub fn get_files(&self, head: &Head) -> Result<Vec<File>, CommandError> {
 70 |         Ok(self
 71 |             .execute_jj_command(
 72 |                 vec!["diff", "-r", head.commit_id.as_str(), "--summary"],
 73 |                 false,
 74 |                 true,
 75 |             )?
 76 |             .lines()
 77 |             .map(|line| {
 78 |                 let captured = FILES_REGEX.captures(line);
 79 |                 let diff_type = captured
 80 |                     .as_ref()
 81 |                     .and_then(|captured| captured.get(1))
 82 |                     .and_then(|inner_text| DiffType::parse(inner_text.as_str()));
 83 |                 let path = captured
 84 |                     .as_ref()
 85 |                     .and_then(|captured| captured.get(2))
 86 |                     .map(|inner_text| inner_text.as_str().to_owned());
 87 | 
 88 |                 File {
 89 |                     line: line.to_string(),
 90 |                     path,
 91 |                     diff_type,
 92 |                 }
 93 |             })
 94 |             .collect())
 95 |     }
 96 | 
 97 |     /// Get list of changes files in a change. Parses the output.
 98 |     /// Maps to `jj diff --summary -r <revision>`
 99 |     #[instrument(level = "trace", skip(self))]
100 |     pub fn get_conflicts(&self, commit_id: &CommitId) -> Result<Vec<Conflict>> {
101 |         let output = self.execute_jj_command(
102 |             vec!["resolve", "--list", "-r", commit_id.as_str()],
103 |             false,
104 |             true,
105 |         );
106 | 
107 |         match output {
108 |             Ok(output) => Ok(output
109 |                 .lines()
110 |                 .filter_map(|line| {
111 |                     let captured = CONFLICTS_REGEX.captures(line);
112 |                     captured
113 |                         .as_ref()
114 |                         .and_then(|captured| captured.get(1))
115 |                         .map(|inner_text| Conflict {
116 |                             path: inner_text.as_str().to_owned(),
117 |                         })
118 |                 })
119 |                 .collect()),
120 |             Err(CommandError::Status(_, Some(2))) => {
121 |                 // No conflicts
122 |                 Ok(vec![])
123 |             }
124 |             Err(err) => Err(err).context("Failed getting conflicts"),
125 |         }
126 |     }
127 | 
128 |     /// Get diff for file change in a change.
129 |     /// Maps to `jj diff -r <revision> <path>`
130 |     #[instrument(level = "trace", skip(self))]
131 |     pub fn get_file_diff(
132 |         &self,
133 |         head: &Head,
134 |         current_file: &File,
135 |         diff_format: &DiffFormat,
136 |         ignore_working_copy: bool,
137 |     ) -> Result<Option<String>, CommandError> {
138 |         let Some(path) = current_file.path.as_ref() else {
139 |             return Ok(None);
140 |         };
141 | 
142 |         let path = if let (true, Some(captures)) = (
143 |             current_file.diff_type == Some(DiffType::Renamed),
144 |             RENAME_REGEX.captures(path),
145 |         ) {
146 |             match captures.get(2) {
147 |                 Some(path) => path.as_str(),
148 |                 None => return Ok(None),
149 |             }
150 |         } else {
151 |             path
152 |         };
153 | 
154 |         let fileset = format!("file:\"{}\"", path.replace('"', "\\\""));
155 |         let mut args = vec!["diff", "-r", head.commit_id.as_str(), &fileset];
156 |         args.append(&mut diff_format.get_args());
157 |         if ignore_working_copy {
158 |             args.push("--ignore-working-copy");
159 |         }
160 | 
161 |         self.execute_jj_command(args, true, true).map(Some)
162 |     }
163 | 
164 |     #[instrument(level = "trace", skip(self))]
165 |     pub fn untrack_file(&self, current_file: &File) -> Result<Option<String>, CommandError> {
166 |         let Some(path) = current_file.path.as_ref() else {
167 |             return Ok(None);
168 |         };
169 | 
170 |         let path = if let Some(DiffType::Renamed) = current_file.diff_type
171 |             && let Some(captures) = RENAME_REGEX.captures(path)
172 |         {
173 |             match captures.get(2) {
174 |                 Some(path) => path.as_str(),
175 |                 None => return Ok(None),
176 |             }
177 |         } else {
178 |             path
179 |         };
180 | 
181 |         let fileset = format!("file:\"{}\"", path.replace('"', "\\\""));
182 |         Ok(Some(self.execute_jj_command(
183 |             vec!["file", "untrack", &fileset],
184 |             false,
185 |             true,
186 |         )?))
187 |     }
188 | 
189 |     #[instrument(level = "trace", skip(self))]
190 |     pub fn restore_file(&self, current_file: &File) -> Result<Option<String>, CommandError> {
191 |         let Some(path) = current_file.path.as_ref() else {
192 |             return Ok(None);
193 |         };
194 | 
195 |         let path = if let Some(DiffType::Renamed) = current_file.diff_type
196 |             && let Some(captures) = RENAME_REGEX.captures(path)
197 |         {
198 |             match captures.get(2) {
199 |                 Some(path) => path.as_str(),
200 |                 None => return Ok(None),
201 |             }
202 |         } else {
203 |             path
204 |         };
205 | 
206 |         let fileset = format!("file:\"{}\"", path.replace('"', "\\\""));
207 |         Ok(Some(self.execute_jj_command(
208 |             vec!["restore", &fileset],
209 |             false,
210 |             true,
211 |         )?))
212 |     }
213 | }
214 | 
215 | #[cfg(test)]
216 | mod tests {
217 |     use super::*;
218 |     use crate::commander::tests::TestRepo;
219 |     use insta::assert_debug_snapshot;
220 |     use std::fs;
221 | 
222 |     #[test]
223 |     fn get_files() -> Result<()> {
224 |         let test_repo = TestRepo::new()?;
225 |         let file_path = test_repo.directory.path().join("README");
226 | 
227 |         // Initial state
228 |         {
229 |             let head = test_repo.commander.get_current_head()?;
230 |             let files = test_repo.commander.get_files(&head)?;
231 |             assert_eq!(files, vec![]);
232 |         }
233 | 
234 |         // Add file
235 |         {
236 |             fs::write(&file_path, b"AAA")?;
237 | 
238 |             let head = test_repo.commander.get_current_head()?;
239 |             let files = test_repo.commander.get_files(&head)?;
240 |             assert_eq!(
241 |                 files,
242 |                 vec![File {
243 |                     line: "A README".to_owned(),
244 |                     path: Some("README".to_owned(),),
245 |                     diff_type: Some(DiffType::Added,),
246 |                 },]
247 |             );
248 |         }
249 | 
250 |         // Commit
251 |         test_repo.commander.execute_void_jj_command(vec!["new"])?;
252 | 
253 |         // Modify file
254 |         {
255 |             fs::write(&file_path, b"BBB")?;
256 | 
257 |             let head = test_repo.commander.get_current_head()?;
258 |             let files = test_repo.commander.get_files(&head)?;
259 |             assert_eq!(
260 |                 files,
261 |                 vec![File {
262 |                     line: "M README".to_owned(),
263 |                     path: Some("README".to_owned()),
264 |                     diff_type: Some(DiffType::Modified)
265 |                 },]
266 |             );
267 |         }
268 | 
269 |         // Delete file
270 |         {
271 |             fs::remove_file(&file_path)?;
272 | 
273 |             let head = test_repo.commander.get_current_head()?;
274 |             let files = test_repo.commander.get_files(&head)?;
275 |             assert_eq!(
276 |                 files,
277 |                 vec![File {
278 |                     line: "D README".to_owned(),
279 |                     path: Some("README".to_owned()),
280 |                     diff_type: Some(DiffType::Deleted)
281 |                 },]
282 |             );
283 |         }
284 | 
285 |         Ok(())
286 |     }
287 | 
288 |     #[test]
289 |     fn get_file_diff() -> Result<()> {
290 |         let test_repo = TestRepo::new()?;
291 | 
292 |         let mut file_path = test_repo.directory.path().join("README");
293 | 
294 |         // Add file
295 |         {
296 |             fs::write(&file_path, b"AAA")?;
297 |             let file = File {
298 |                 path: Some("README".to_string()),
299 |                 diff_type: Some(DiffType::Added),
300 |                 line: "A README".to_string(),
301 |             };
302 | 
303 |             let head = test_repo.commander.get_current_head()?;
304 |             assert_debug_snapshot!(test_repo.commander.get_file_diff(
305 |                 &head,
306 |                 &file,
307 |                 &DiffFormat::ColorWords,
308 |                 false
309 |             )?);
310 |             assert_debug_snapshot!(test_repo.commander.get_file_diff(
311 |                 &head,
312 |                 &file,
313 |                 &DiffFormat::Git,
314 |                 false
315 |             )?);
316 |         }
317 | 
318 |         // Commit
319 |         test_repo.commander.execute_void_jj_command(vec!["new"])?;
320 | 
321 |         // Modify file
322 |         {
323 |             fs::write(&file_path, b"BBB")?;
324 |             let file = File {
325 |                 path: Some("README".to_string()),
326 |                 diff_type: Some(DiffType::Modified),
327 |                 line: "M README".to_string(),
328 |             };
329 | 
330 |             let head = test_repo.commander.get_current_head()?;
331 |             assert_debug_snapshot!(test_repo.commander.get_file_diff(
332 |                 &head,
333 |                 &file,
334 |                 &DiffFormat::ColorWords,
335 |                 true
336 |             )?);
337 |             assert_debug_snapshot!(test_repo.commander.get_file_diff(
338 |                 &head,
339 |                 &file,
340 |                 &DiffFormat::Git,
341 |                 true
342 |             )?);
343 |         }
344 | 
345 |         // Commit
346 |         test_repo.commander.execute_void_jj_command(vec!["new"])?;
347 | 
348 |         // Rename file
349 |         {
350 |             let file_path_new = test_repo.directory.path().join("README2");
351 |             fs::rename(file_path, &file_path_new)?;
352 |             file_path = file_path_new;
353 | 
354 |             let file = File {
355 |                 path: Some("{README => README2}".to_string()),
356 |                 diff_type: Some(DiffType::Renamed),
357 |                 line: "R {README => README2}".to_string(),
358 |             };
359 | 
360 |             let head = test_repo.commander.get_current_head()?;
361 |             assert_debug_snapshot!(test_repo.commander.get_file_diff(
362 |                 &head,
363 |                 &file,
364 |                 &DiffFormat::ColorWords,
365 |                 true
366 |             )?);
367 |             assert_debug_snapshot!(test_repo.commander.get_file_diff(
368 |                 &head,
369 |                 &file,
370 |                 &DiffFormat::Git,
371 |                 true
372 |             )?);
373 |         }
374 | 
375 |         // Commit
376 |         test_repo.commander.execute_void_jj_command(vec!["new"])?;
377 | 
378 |         // Delete file
379 |         {
380 |             fs::remove_file(&file_path)?;
381 |             let file = File {
382 |                 path: Some("README2".to_string()),
383 |                 diff_type: Some(DiffType::Deleted),
384 |                 line: "D README2".to_string(),
385 |             };
386 | 
387 |             let head = test_repo.commander.get_current_head()?;
388 |             assert_debug_snapshot!(test_repo.commander.get_file_diff(
389 |                 &head,
390 |                 &file,
391 |                 &DiffFormat::ColorWords,
392 |                 true
393 |             )?);
394 |             assert_debug_snapshot!(test_repo.commander.get_file_diff(
395 |                 &head,
396 |                 &file,
397 |                 &DiffFormat::Git,
398 |                 true
399 |             )?);
400 |         }
401 | 
402 |         Ok(())
403 |     }
404 | 
405 |     #[test]
406 |     fn get_conflicts() -> Result<()> {
407 |         let test_repo = TestRepo::new()?;
408 | 
409 |         let file_path = test_repo.directory.path().join("README");
410 | 
411 |         let head0 = test_repo.commander.get_current_head()?;
412 | 
413 |         // First change
414 |         test_repo.commander.run_new(head0.commit_id.as_str())?;
415 |         let head1 = test_repo.commander.get_current_head()?;
416 |         fs::write(&file_path, b"AAA")?;
417 | 
418 |         test_repo.commander.run_new(head0.commit_id.as_str())?;
419 |         let head2 = test_repo.commander.get_current_head()?;
420 |         fs::write(&file_path, b"BBB")?;
421 | 
422 |         test_repo.commander.execute_void_jj_command([
423 |             "rebase",
424 |             "-s",
425 |             head2.change_id.as_str(),
426 |             "-d",
427 |             head1.change_id.as_str(),
428 |         ])?;
429 | 
430 |         let head = test_repo.commander.get_current_head()?;
431 | 
432 |         let conflicts = test_repo.commander.get_conflicts(&head.commit_id)?;
433 | 
434 |         assert_eq!(
435 |             conflicts,
436 |             [Conflict {
437 |                 path: "README".to_owned()
438 |             }]
439 |         );
440 | 
441 |         Ok(())
442 |     }
443 | }
444 | 


--------------------------------------------------------------------------------
/src/commander/log.rs:
--------------------------------------------------------------------------------
  1 | /*!
  2 | [Commander] member functions related to jj log.
  3 | 
  4 | This module has features to parse the log output to extract change id and commit id.
  5 | It is mostly used in the [log_tab][crate::ui::log_tab] module.
  6 | */
  7 | 
  8 | use crate::{
  9 |     commander::{
 10 |         CommandError, Commander, RemoveEndLine,
 11 |         bookmarks::Bookmark,
 12 |         ids::{ChangeId, CommitId},
 13 |     },
 14 |     env::DiffFormat,
 15 | };
 16 | 
 17 | use anyhow::{Context, Result, anyhow, bail};
 18 | use itertools::Itertools;
 19 | use regex::Regex;
 20 | use std::{fmt::Display, sync::LazyLock};
 21 | use thiserror::Error;
 22 | use tracing::instrument;
 23 | 
 24 | #[derive(Clone, PartialEq, Eq, Hash, Debug)]
 25 | pub struct Head {
 26 |     pub change_id: ChangeId,
 27 |     pub commit_id: CommitId,
 28 |     pub divergent: bool,
 29 |     pub immutable: bool,
 30 | }
 31 | 
 32 | #[derive(Clone, Debug)]
 33 | pub struct LogOutput {
 34 |     pub graph: String,
 35 |     // Maps graph line -> heads
 36 |     pub graph_heads: Vec<Option<Head>>,
 37 |     pub heads: Vec<Head>,
 38 | }
 39 | 
 40 | #[derive(Error, Debug)]
 41 | pub struct HeadParseError(String);
 42 | 
 43 | impl Display for HeadParseError {
 44 |     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 45 |         write!(f, "Head parse error: {}", self.0)
 46 |     }
 47 | }
 48 | 
 49 | // Template which outputs `[change_id|commit_id|divergent]`. Used to parse data from log and other
 50 | // commands which supports templating.
 51 | const HEAD_TEMPLATE: &str =
 52 |     r#""[" ++ change_id ++ "|" ++ commit_id ++ "|" ++ divergent ++ "|" ++ immutable ++ "]""#;
 53 | // Regex to parse HEAD_TEMPLATE
 54 | static HEAD_TEMPLATE_REGEX: LazyLock<Regex> =
 55 |     LazyLock::new(|| Regex::new(r"\[(.*)\|(.*)\|(.*)\|(.*)\]").unwrap());
 56 | 
 57 | // Parse a head with HEAD_TEMPLATE.
 58 | fn parse_head(text: &str) -> Result<Head> {
 59 |     let captured = HEAD_TEMPLATE_REGEX.captures(text);
 60 |     captured
 61 |         .as_ref()
 62 |         .map_or(Err(anyhow!(HeadParseError(text.to_owned()))), |captured| {
 63 |             if let (Some(change_id), Some(commit_id), Some(divergent), Some(immutable)) = (
 64 |                 captured.get(1),
 65 |                 captured.get(2),
 66 |                 captured.get(3),
 67 |                 captured.get(4),
 68 |             ) {
 69 |                 Ok(Head {
 70 |                     change_id: ChangeId(change_id.as_str().to_string()),
 71 |                     commit_id: CommitId(commit_id.as_str().to_string()),
 72 |                     divergent: divergent.as_str() == "true",
 73 |                     immutable: immutable.as_str() == "true",
 74 |                 })
 75 |             } else {
 76 |                 bail!(HeadParseError(text.to_owned()))
 77 |             }
 78 |         })
 79 | }
 80 | 
 81 | impl Commander {
 82 |     /// Get log. Returns human readable log and mapping to log line to head.
 83 |     /// Maps to `jj log`
 84 |     #[instrument(level = "trace", skip(self))]
 85 |     pub fn get_log(&self, revset: &Option<String>) -> Result<LogOutput, CommandError> {
 86 |         let mut args = vec![];
 87 | 
 88 |         if let Some(revset) = revset {
 89 |             args.push("-r");
 90 |             args.push(revset);
 91 |         }
 92 | 
 93 |         // Force builtin_log_compact which uses 2 lines per change
 94 |         let graph = self.execute_jj_command(
 95 |             [
 96 |                 vec!["log", "--template", "builtin_log_compact"],
 97 |                 args.clone(),
 98 |             ]
 99 |             .concat(),
100 |             true,
101 |             true,
102 |         )?;
103 | 
104 |         // Extract the log one more time, but this time use a template
105 |         // where each line begins with Head information. Since jj has
106 |         // 2 lines per change, there will also be two lines with head info.
107 |         // The number of lines in graph and the number of items in graph_heads
108 |         // should be identical.
109 |         let graph_heads: Vec<Option<Head>> = self
110 |             .execute_jj_command(
111 |                 [
112 |                     vec![
113 |                         "log",
114 |                         "--template",
115 |                         // Match builtin_log_compact with 2 lines per change
116 |                         &format!(
117 |                             r#"{HEAD_TEMPLATE} ++ " " ++ bookmarks ++"\n" ++ {HEAD_TEMPLATE}"#
118 |                         ),
119 |                     ],
120 |                     args,
121 |                 ]
122 |                 .concat(),
123 |                 false,
124 |                 true,
125 |             )?
126 |             .lines()
127 |             .map(|line| parse_head(line).ok())
128 |             .collect();
129 | 
130 |         let heads = graph_heads.clone().into_iter().flatten().unique().collect();
131 | 
132 |         Ok(LogOutput {
133 |             graph,
134 |             graph_heads,
135 |             heads,
136 |         })
137 |     }
138 | 
139 |     /// Get commit details.
140 |     /// Maps to `jj show <commit>`
141 |     #[instrument(level = "trace", skip(self))]
142 |     pub fn get_commit_show(
143 |         &self,
144 |         commit_id: &CommitId,
145 |         diff_format: &DiffFormat,
146 |         ignore_working_copy: bool,
147 |     ) -> Result<String, CommandError> {
148 |         let mut args = vec!["show", commit_id.as_str()];
149 |         args.append(&mut diff_format.get_args());
150 |         if ignore_working_copy {
151 |             args.push("--ignore-working-copy");
152 |         }
153 | 
154 |         Ok(self.execute_jj_command(args, true, true)?.remove_end_line())
155 |     }
156 | 
157 |     /// Get the current head.
158 |     /// Maps to `jj log -r @`
159 |     #[instrument(level = "trace", skip(self))]
160 |     pub fn get_current_head(&self) -> Result<Head> {
161 |         parse_head(
162 |             &self
163 |                 .execute_jj_command(
164 |                     vec![
165 |                         "log",
166 |                         "--no-graph",
167 |                         "--template",
168 |                         &format!(r#"{HEAD_TEMPLATE} ++ "\n""#),
169 |                         "-r",
170 |                         "@",
171 |                         "--limit",
172 |                         "1",
173 |                     ],
174 |                     false,
175 |                     true,
176 |                 )
177 |                 .context("Failed getting current head")?
178 |                 .remove_end_line(),
179 |         )
180 |     }
181 | 
182 |     /// Get the latest version of a head. Can detect evolution of divergent head.
183 |     #[instrument(level = "trace", skip(self))]
184 |     pub fn get_head_latest(&self, head: &Head) -> Result<Head> {
185 |         // Get all heads which point to the same change ID
186 |         let latest_heads_res = self.execute_jj_command(
187 |             vec![
188 |                 "log",
189 |                 "--no-graph",
190 |                 "-r",
191 |                 &format!(r#"change_id({})"#, head.change_id.as_str()),
192 |                 "--template",
193 |                 &format!(r#"{HEAD_TEMPLATE} ++ "\n""#),
194 |             ],
195 |             false,
196 |             true,
197 |         );
198 |         let Ok(latest_heads_res) = latest_heads_res else {
199 |             return self.get_head_latest(&self.get_current_head()?);
200 |         };
201 |         if latest_heads_res.is_empty() {
202 |             return self.get_head_latest(&self.get_current_head()?);
203 |         }
204 |         let latest_heads: Vec<Head> = latest_heads_res
205 |             .lines()
206 |             .map(parse_head)
207 |             .collect::<Result<Vec<Head>>>()?;
208 | 
209 |         // If the current head exist, that means it wasn't updated
210 |         if let Some(head) = latest_heads.iter().find(|latest_head| latest_head == &head) {
211 |             return Ok(head.to_owned());
212 |         }
213 | 
214 |         // Check obslog for each head. If the obslog contains the head's commit, it means
215 |         // there's a new commit for the head
216 |         for latest_head in latest_heads.iter() {
217 |             let parent_commits: Vec<ChangeId> = self
218 |                 .execute_jj_command(
219 |                     vec![
220 |                         "obslog",
221 |                         "--no-graph",
222 |                         "--template",
223 |                         r#"commit.change_id() ++ "\n""#,
224 |                         "-r",
225 |                         latest_head.commit_id.as_str(),
226 |                     ],
227 |                     false,
228 |                     true,
229 |                 )
230 |                 .context("Failed getting latest head parent commits")?
231 |                 .lines()
232 |                 .map(|line| ChangeId(line.to_owned()))
233 |                 .collect();
234 | 
235 |             if parent_commits
236 |                 .iter()
237 |                 .any(|parent_commit| parent_commit == &head.change_id)
238 |             {
239 |                 return Ok(latest_head.to_owned());
240 |             }
241 |         }
242 | 
243 |         bail!(
244 |             "Could not find head latest: {} {} {:?}",
245 |             head.change_id,
246 |             head.commit_id,
247 |             latest_heads
248 |         );
249 |     }
250 | 
251 |     /// Get a commit's parent.
252 |     /// Maps to `jj log -r <revision>-`
253 |     #[instrument(level = "trace", skip(self))]
254 |     pub fn get_commit_parent(&self, commit_id: &CommitId) -> Result<Head> {
255 |         parse_head(
256 |             &self
257 |                 .execute_jj_command(
258 |                     vec![
259 |                         "log",
260 |                         "--no-graph",
261 |                         "--template",
262 |                         &format!(r#"{HEAD_TEMPLATE} ++ "\n""#),
263 |                         "-r",
264 |                         &format!("{commit_id}-"),
265 |                         "--limit",
266 |                         "1",
267 |                     ],
268 |                     false,
269 |                     true,
270 |                 )
271 |                 .with_context(|| format!("Failed getting commit parent: {commit_id}"))?
272 |                 .remove_end_line(),
273 |         )
274 |     }
275 | 
276 |     /// Get commit's description.
277 |     /// Maps to `jj log -r <revision> -T description`
278 |     #[instrument(level = "trace", skip(self))]
279 |     pub fn get_commit_description(&self, commit_id: &CommitId) -> Result<String> {
280 |         Ok(self
281 |             .execute_jj_command(
282 |                 vec![
283 |                     "log",
284 |                     "--no-graph",
285 |                     "--template",
286 |                     "description",
287 |                     "-r",
288 |                     commit_id.as_str(),
289 |                     "--limit",
290 |                     "1",
291 |                 ],
292 |                 false,
293 |                 true,
294 |             )
295 |             .with_context(|| format!("Failed getting commit description: {commit_id}"))?
296 |             .remove_end_line())
297 |     }
298 | 
299 |     /// Check if a revision is immutable
300 |     /// Maps to `jj log -r <revision> -T immutable`
301 |     #[instrument(level = "trace", skip(self))]
302 |     pub fn check_revision_immutable(&self, revision: &str) -> Result<bool> {
303 |         Ok(self
304 |             .execute_jj_command(
305 |                 vec![
306 |                     "log",
307 |                     "--no-graph",
308 |                     "--template",
309 |                     "immutable",
310 |                     "-r",
311 |                     revision,
312 |                     "--limit",
313 |                     "1",
314 |                 ],
315 |                 false,
316 |                 true,
317 |             )
318 |             .with_context(|| format!("Failed checking if revision is immutable: {revision}"))?
319 |             .remove_end_line()
320 |             == "true")
321 |     }
322 | 
323 |     /// Get bookmark head
324 |     /// Maps to `jj log -r <bookmark>[@<remote>]`
325 |     #[instrument(level = "trace", skip(self))]
326 |     pub fn get_bookmark_head(&self, bookmark: &Bookmark) -> Result<Head> {
327 |         parse_head(
328 |             &self
329 |                 .execute_jj_command(
330 |                     vec![
331 |                         "log",
332 |                         "--no-graph",
333 |                         "--template",
334 |                         &format!(r#"{HEAD_TEMPLATE} ++ "\n""#),
335 |                         "-r",
336 |                         &bookmark.to_string(),
337 |                         "--limit",
338 |                         "1",
339 |                     ],
340 |                     false,
341 |                     true,
342 |                 )
343 |                 .context("Failed getting bookmark head")?
344 |                 .remove_end_line(),
345 |         )
346 |     }
347 | }
348 | 
349 | #[cfg(test)]
350 | mod tests {
351 |     use std::fs;
352 | 
353 |     use super::*;
354 |     use crate::commander::tests::TestRepo;
355 |     use insta::assert_debug_snapshot;
356 | 
357 |     #[test]
358 |     fn get_log() -> Result<()> {
359 |         let test_repo = TestRepo::new()?;
360 | 
361 |         let log = test_repo.commander.get_log(&None)?;
362 | 
363 |         let mut settings = insta::Settings::clone_current();
364 |         settings.add_filter(r"[k-z]{8} .*? [0-9a-fA-F]{8}", "[LINE]");
365 |         let _bound = settings.bind_to_scope();
366 | 
367 |         assert_debug_snapshot!(log.graph);
368 | 
369 |         assert!(log.graph_heads.iter().all(|graph_head| {
370 |             graph_head
371 |                 .as_ref()
372 |                 .is_none_or(|graph_head| log.heads.contains(graph_head))
373 |         }));
374 | 
375 |         Ok(())
376 |     }
377 | 
378 |     #[test]
379 |     fn get_commit_show() -> Result<()> {
380 |         let test_repo = TestRepo::new()?;
381 | 
382 |         fs::write(test_repo.directory.path().join("README"), b"AAA")?;
383 | 
384 |         let head = test_repo.commander.get_current_head()?;
385 |         let show =
386 |             test_repo
387 |                 .commander
388 |                 .get_commit_show(&head.commit_id, &DiffFormat::ColorWords, false)?;
389 | 
390 |         let mut settings = insta::Settings::clone_current();
391 |         settings.add_filter(r"Commit ID: [0-9a-fA-F]{40}", "Commit ID: [COMMIT_ID]");
392 |         settings.add_filter(r"Change ID: [k-z]{32}", "Change ID: [Change ID]");
393 |         settings.add_filter(r"(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})", "([DATE_TIME])");
394 |         let _bound = settings.bind_to_scope();
395 | 
396 |         assert_debug_snapshot!(show);
397 | 
398 |         Ok(())
399 |     }
400 | 
401 |     #[test]
402 |     fn get_commit_parent() -> Result<()> {
403 |         let test_repo = TestRepo::new()?;
404 | 
405 |         let head = test_repo.commander.get_current_head()?;
406 | 
407 |         assert_eq!(
408 |             test_repo.commander.get_commit_parent(&head.commit_id)?,
409 |             Head {
410 |                 commit_id: CommitId("0000000000000000000000000000000000000000".to_owned()),
411 |                 change_id: ChangeId("zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz".to_owned()),
412 |                 divergent: false,
413 |                 immutable: true,
414 |             }
415 |         );
416 | 
417 |         Ok(())
418 |     }
419 | 
420 |     #[test]
421 |     fn get_head_latest() -> Result<()> {
422 |         let test_repo = TestRepo::new()?;
423 | 
424 |         let old_head = test_repo.commander.get_current_head()?;
425 | 
426 |         fs::write(test_repo.directory.path().join("README"), b"AAA")?;
427 | 
428 |         let new_head = test_repo.commander.get_current_head()?;
429 | 
430 |         assert_ne!(old_head, new_head);
431 | 
432 |         assert_eq!(new_head, test_repo.commander.get_head_latest(&old_head)?);
433 | 
434 |         Ok(())
435 |     }
436 | 
437 |     #[test]
438 |     fn check_revision_immutable() -> Result<()> {
439 |         let test_repo = TestRepo::new()?;
440 | 
441 |         assert!(!(test_repo.commander.check_revision_immutable("@")?));
442 | 
443 |         Ok(())
444 |     }
445 | 
446 |     #[test]
447 |     fn get_bookmark_head() -> Result<()> {
448 |         let test_repo = TestRepo::new()?;
449 | 
450 |         let head = test_repo.commander.get_current_head()?;
451 |         // Git doesn't support bookmark pointing to root commit, so it will advance
452 |         let bookmark = test_repo.commander.create_bookmark("main")?;
453 | 
454 |         assert_eq!(test_repo.commander.get_bookmark_head(&bookmark)?, head);
455 | 
456 |         Ok(())
457 |     }
458 | }
459 | 


--------------------------------------------------------------------------------