auraline 0.6.5

utility that renders information into a string suitable to be embedded in the shell prompt.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

use crate::cmd::CMD;
use crate::providers::vcs::{merge_icons, StatusIcon, VcsTrait};
use crate::{chunk::Chunk, options::Options};
use smallvec::SmallVec;
use smol_str::{format_smolstr, SmolStr};
use std::path::Path;
use std::str::FromStr;

macro_rules! jj {
    ( $( $x:expr ),* ) => {
        CMD.exec("jj", [$( $x ),*])
    };
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Jj;

impl VcsTrait for Jj {
    async fn branch(&self, _opts: &Options, _path: &Path) -> Option<Chunk<SmolStr>> {
        jj!("log", "--color", "never", "--no-pager")
            .await
            .and_then(|status| {
                let branch = status
                    .lines()
                    .next()?
                    .split_whitespace()
                    .rev()
                    .nth(1)?
                    .trim();

                let s = &branch[..branch.len() - 1];
                Some(Chunk::new("jj ⎇", SmolStr::new(s)))
            })
    }

    async fn commit(&self, _opts: &Options, _path: &Path) -> Option<Chunk<SmolStr>> {
        let status = jj!("status", "--color", "never", "--no-pager").await?;
        let working_copy = status
            .lines()
            .filter(|l| l.starts_with("Working copy") && l.contains("(@)"))
            .collect::<SmallVec<[_; 8]>>()
            .into_iter()
            .next()?;
        let tokens = working_copy
            .split_whitespace()
            .collect::<SmallVec<[_; 8]>>();
        if tokens.len() >= 6 {
            let change_id = tokens[4];
            let commit_id = tokens[5];
            Some(Chunk::new(
                "⭑",
                format_smolstr!("{} {}", change_id, commit_id),
            ))
        } else {
            None
        }
    }

    async fn status(&self, _opts: &Options, _path: &Path) -> Option<Chunk<SmolStr>> {
        jj!("status", "--color", "never", "--no-pager")
            .await
            .and_then(|status| {
                let icons = merge_icons(
                    status
                        .lines()
                        .filter(|l| &l[1..2] == " ")
                        .map(|line| line.parse::<StatusIcon<Jj>>().unwrap())
                        .collect::<SmallVec<[_; 8]>>(),
                );
                if icons.is_empty() {
                    return None;
                }
                Some(Chunk::info(icons))
            })
    }

    async fn worktree(&self, _opts: &Options, _path: &Path) -> Option<Chunk<SmolStr>> {
        jj!("log", "--color", "never", "--no-pager")
            .await
            .and_then(|status| {
                let mut tokens = status.lines().next()?.split_whitespace();

                if tokens.clone().count() == 8 {
                    tokens.nth(5).map(|t| Chunk::new("", SmolStr::new(t)))
                } else {
                    None
                }
            })
    }

    async fn stash(&self, _opts: &Options, _path: &Path) -> Option<Chunk<SmolStr>> {
        None
    }

    async fn divergence(&self, _opts: &Options, _path: &Path) -> Option<Chunk<SmolStr>> {
        None
    }
}

impl FromStr for StatusIcon<Jj> {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let chars = s.split_whitespace().next();
        match chars {
            Some("A") => Ok(StatusIcon::new("✚")),
            Some("R") => Ok(StatusIcon::new("→")),
            Some("M") => Ok(StatusIcon::new("●")),
            Some("C") => Ok(StatusIcon::new("⊂")),
            Some("D") => Ok(StatusIcon::new("−")),
            _ => Ok(StatusIcon::new("")), // Unknown state
        }
    }
}