jj-vine 0.4.0

Stacked pull requests for jj (jujutsu). Supports GitLab and bookmark-based flow.
Documentation 
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

use bon::Builder;
use owo_colors::OwoColorize;
use tracing::{debug, error};

use crate::{
    error::{Error, Result},
    submit::execute::{ActionInfo, ActionResultData, ExecuteAction, ExecuteActionContext},
};

/// Push a bookmark to a remote
#[derive(Debug, Clone, PartialEq, Eq, Builder)]
pub struct PushAction {
    pub bookmark: String,
    pub remote: String,
}

impl ActionInfo for PushAction {
    fn id(&self) -> String {
        format!("push:{}", self.bookmark)
    }

    fn group_text(&self) -> String {
        "Pushing bookmarks".to_string()
    }

    fn text(&self) -> String {
        format!("Pushing {}", self.bookmark.magenta())
    }

    fn substep_text(&self) -> String {
        self.bookmark.magenta().to_string()
    }

    fn plan_text(&self) -> String {
        format!(
            "Push bookmark {} to remote {}",
            self.bookmark.magenta(),
            self.remote.cyan()
        )
    }
}

impl ExecuteAction for PushAction {
    async fn execute(&self, ctx: ExecuteActionContext<'_>) -> Result<ActionResultData> {
        if ctx.execute.dry_run {
            ctx.execute.output.log_message(&format!(
                "Would push {} to {}",
                self.bookmark.magenta(),
                self.remote
            ));
            Ok(ActionResultData::Pushed {
                bookmark: self.bookmark.clone(),
                pushed: true,
            })
        } else {
            match ctx
                .execute
                .jj
                .push_bookmark(&self.bookmark, Some(&self.remote))
            {
                Ok(pushed) => {
                    if pushed {
                        ctx.execute
                            .output
                            .log_completed(&format!("Pushed {}", self.bookmark.magenta()));
                    } else {
                        debug!("Nothing needed to be pushed for {}", self.bookmark);
                    }
                    Ok(ActionResultData::Pushed {
                        bookmark: self.bookmark.clone(),
                        pushed,
                    })
                }
                Err(e) => {
                    let error_msg = format!("Failed to push {}: {}", self.bookmark, e);
                    ctx.execute.output.log_message(&error_msg);
                    error!("{}", error_msg);
                    Err(Error::new(error_msg))
                }
            }
        }
    }
}