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
131
132
133
134

use bon::Builder;
use futures::{StreamExt, stream::FuturesUnordered};
use owo_colors::OwoColorize;

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

/// Sync dependent merge requests for a bookmark (after all MRs created)
#[derive(Debug, Clone, PartialEq, Eq, Builder)]
pub struct SyncDependentMergeRequestsAction {
    pub bookmark: String,
    pub dependencies: Option<Vec<String>>,
}

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

    fn group_text(&self) -> String {
        "Syncing dependent merge requests".to_string()
    }
    fn text(&self) -> String {
        format!(
            "Syncing dependent merge requests for {}",
            self.bookmark.magenta()
        )
    }
    fn substep_text(&self) -> String {
        self.bookmark.magenta().to_string()
    }

    fn plan_text(&self) -> String {
        format!(
            "Sync dependent merge requests for {}",
            self.bookmark.magenta()
        )
    }

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

impl ExecuteAction for SyncDependentMergeRequestsAction {
    async fn execute(&self, ctx: ExecuteActionContext<'_>) -> Result<ActionResultData> {
        if ctx.execute.dry_run {
            return Ok(ActionResultData::DryRun);
        }

        let bookmark = ctx
            .execute
            .bookmark_graph
            .find_bookmark_in_components(&self.bookmark)
            .ok_or_else::<Error, _>(|| make_whatever!("Bookmark not found: {}", self.bookmark))?;

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

        let mr = ctx
            .execute
            .forge
            .find_merge_request_by_source_branch_base_branch(
                &self.bookmark,
                &bookmark.parent_name(default_branch),
            )
            .await?
            .ok_or_else::<Error, _>(|| {
                make_whatever!("No merge request found for {}", self.bookmark)
            })?;

        let dependent_merge_request_iids: Vec<_> = bookmark
            .parents
            .iter()
            .filter_map(|p| match p {
                BookmarkRef::Bookmark(b) => Some(b),
                BookmarkRef::Trunk => None,
            })
            .map(|parent_bookmark| async move {
                let mr = ctx
                    .execute
                    .forge
                    .find_merge_request_by_source_branch_base_branch(
                        parent_bookmark.name(),
                        &parent_bookmark.parent_name(default_branch),
                    )
                    .await?
                    .ok_or_else::<Error, _>(|| {
                        make_whatever!("No merge request found for {}", parent_bookmark.name())
                    })?;
                Ok(mr.iid().to_string())
            })
            .collect::<FuturesUnordered<_>>()
            .collect::<Vec<Result<String>>>()
            .await
            .into_iter()
            .collect::<Result<Vec<_>>>()?;

        let changed = ctx
            .execute
            .forge
            .sync_dependent_merge_requests(
                mr.iid(),
                dependent_merge_request_iids
                    .iter()
                    .map(|s| s.into())
                    .collect::<Vec<_>>()
                    .as_slice(),
            )
            .await?;

        Ok(ActionResultData::MRUpdated(MRUpdate {
            mr,
            bookmark: self.bookmark.clone(),
            update_type: if changed {
                MRUpdateType::new_updated()
                    .synced_dependent_merge_requests(true)
                    .call()
            } else {
                MRUpdateType::Unchanged
            },
        }))
    }
}