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
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use bon::Builder;
use owo_colors::OwoColorize;
use snafu::whatever;
use tracing::error;

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

/// Update the target branch (base) of an existing MR
#[derive(Debug, Clone, PartialEq, Eq, Builder)]
pub struct UpdateMRBaseAction {
    pub bookmark: String,
    pub mr_iid: String,
    pub new_target_branch: String,
    pub dependencies: Option<Vec<String>>,
}

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

    fn group_text(&self) -> String {
        "Updating MR bases".to_string()
    }

    fn text(&self) -> String {
        format!(
            "Updating MR {} base for {} to {}",
            self.mr_iid.cyan(),
            self.bookmark.magenta(),
            self.new_target_branch.magenta()
        )
    }

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

    fn plan_text(&self) -> String {
        format!(
            "Update base of MR {} for {} from existing target to {}",
            self.mr_iid.cyan(),
            self.bookmark.magenta(),
            self.new_target_branch.magenta()
        )
    }

    fn dependencies(&self) -> Vec<String> {
        self.dependencies.as_ref().cloned().unwrap_or_default()
    }
}

impl ExecuteAction for UpdateMRBaseAction {
    async fn execute(&self, ctx: ExecuteActionContext<'_>) -> Result<ActionResultData> {
        if ctx.execute.dry_run {
            let msg = format!(
                "Would {} MR {} base for {} to {}",
                "update".yellow(),
                format!("!{}", self.mr_iid).cyan(),
                self.bookmark.magenta(),
                self.new_target_branch.magenta()
            );
            ctx.execute.output.log_message(&msg);
            return Ok(ActionResultData::DryRun);
        }

        let Some(bookmark) = ctx
            .execute
            .bookmark_graph
            .find_bookmark_in_components(&self.bookmark)
        else {
            whatever!("Bookmark not found: {}", self.bookmark);
        };

        let default_branch = ctx.execute.jj.default_branch()?;

        // Get old target before update
        let Ok(Some(existing_mr)) = ctx
            .execute
            .forge
            .find_merge_request_by_source_branch_base_branch(
                bookmark.name(),
                &bookmark.parent_name(default_branch),
            )
            .await
        else {
            whatever!("Failed to find existing MR");
        };

        let old_target = existing_mr.target_branch().to_string();

        match ctx
            .execute
            .forge
            .update_merge_request_base((&self.mr_iid).into(), &self.new_target_branch)
            .await
        {
            Ok(mr) => {
                ctx.execute
                    .output
                    .log_completed(&format!("Updated MR {}", format!("!{}", mr.iid()).cyan()));
                Ok(ActionResultData::MRUpdated(MRUpdate {
                    mr,
                    bookmark: self.bookmark.clone(),
                    update_type: MRUpdateType::new_updated()
                        .old_target(old_target)
                        .new_target(self.new_target_branch.clone())
                        .call(),
                }))
            }
            Err(e) => {
                let error_msg = format!("Failed to update MR base for {}: {}", self.bookmark, e);
                ctx.execute.output.log_message(&error_msg);
                error!("{}", error_msg);
                Err(Error::new(error_msg))
            }
        }
    }
}