jj-vine 0.3.4

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

use futures::{StreamExt, stream::FuturesUnordered};

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

pub struct SyncDependentMergeRequestsAction<'a> {
    pub bookmark: String,
    pub bookmark_graph: BookmarkGraph<'a>,
}

impl<'a> SyncDependentMergeRequestsAction<'a> {
    pub fn new(bookmark: String, bookmark_graph: BookmarkGraph<'a>) -> Self {
        Self {
            bookmark,
            bookmark_graph,
        }
    }
}

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

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

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

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

        Ok(ActionResultData::MRUpdated(Box::new(MRUpdate {
            mr,
            bookmark: self.bookmark.clone(),
            update_type: if changed {
                MRUpdateType::SyncedDependentMergeRequests
            } else {
                MRUpdateType::Unchanged
            },
        })))
    }
}