knope 0.23.0

A command line tool for automating common development tasks
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
135
136
137
138

use std::fmt::Debug;

use knope_versioning::{Action, VersionedFile};

use crate::{
    app_config,
    app_config::{get_github_token, get_or_prompt_for_github_token},
    config,
    integrations::http::{Client, http_client},
    step::{issues, releases},
};

/// The current state of the workflow. Every [`crate::Step`] has a chance to transform the state.
#[derive(Clone, Debug)]
pub(crate) struct State {
    pub(crate) jira_config: Option<config::Jira>,
    pub(crate) github: GitHub,
    pub(crate) gitea: Gitea,
    pub(crate) gitea_config: Option<config::Gitea>,
    pub(crate) github_config: Option<config::GitHub>,
    pub(crate) issue: Issue,
    pub(crate) packages: Vec<releases::Package>,
    pub(crate) all_versioned_files: Vec<VersionedFile>,
    pub(crate) pending_actions: Vec<Action>,
    pub(crate) all_git_tags: Vec<String>,
    /// If set to true, conventional commits are ignored across all workflows
    pub(crate) ignore_conventional_commits: bool,
}

impl State {
    #[must_use]
    pub(crate) fn new(
        jira_config: Option<config::Jira>,
        github_config: Option<config::GitHub>,
        gitea_config: Option<config::Gitea>,
        packages: Vec<releases::Package>,
        all_versioned_files: Vec<VersionedFile>,
        all_git_tags: Vec<String>,
        ignore_conventional_commits: bool,
    ) -> Self {
        State {
            jira_config,
            gitea: Gitea::New,
            gitea_config,
            github: GitHub::New,
            github_config,
            issue: Issue::Initial,
            packages,
            all_versioned_files,
            all_git_tags,
            pending_actions: Vec::new(),
            ignore_conventional_commits,
        }
    }
}

/// The type of state—an outer enum to make sure that dry-runs are handled appropriately.
#[derive(Clone, Copy, Debug)]
pub(crate) enum RunType<T> {
    /// Signifies that this is a dry run of a workflow. No I/O should happen—just pretend to run the
    /// workflow and output the results.
    DryRun(T),
    /// This is a real run of a workflow, actually do the thing.
    Real(T),
}

impl<T> RunType<T> {
    #[must_use]
    pub(crate) fn of<R>(&self, new_value: R) -> RunType<R> {
        match self {
            RunType::DryRun(_) => RunType::DryRun(new_value),
            RunType::Real(_) => RunType::Real(new_value),
        }
    }

    pub(crate) fn take(self) -> (RunType<()>, T) {
        match self {
            RunType::DryRun(inner) => (RunType::DryRun(()), inner),
            RunType::Real(inner) => (RunType::Real(()), inner),
        }
    }

    pub(crate) fn is_dry_run(&self) -> bool {
        matches!(self, RunType::DryRun(_))
    }
}

/// Tracks what's been done with respect to issues in this workflow.
#[derive(Clone, Debug)]
pub(crate) enum Issue {
    /// All workflows start here—no issue has been selected yet.
    Initial,
    /// Triggered by [`crate::Step::SelectJiraIssue`] or [`crate::Step::SelectGitHubIssue`],
    /// contains details of the issue you're working against to use for things like transitioning
    /// or creating branches.
    Selected(issues::Issue),
}

#[derive(Clone, Debug)]
pub(crate) enum GitHub {
    New,
    Authenticated { token: String, client: Client },
    Unauthenticated { client: Client },
}

impl GitHub {
    pub(crate) fn require_authentication(self) -> Result<(String, Client), app_config::Error> {
        Ok(match self {
            Self::Authenticated { token, client } => (token, client),
            Self::Unauthenticated { .. } | Self::New => {
                let token = get_or_prompt_for_github_token()?;
                (token, http_client(None)?)
            }
        })
    }

    pub(crate) fn maybe_authenticated(self) -> Result<(Option<String>, Client), app_config::Error> {
        Ok(match self {
            Self::Authenticated { token, client } => (Some(token), client),
            Self::Unauthenticated { client } => (None, client),
            Self::New => {
                let token = get_github_token()?;
                let missing_token_env_var = if token.is_none() {
                    Some("GITHUB_TOKEN")
                } else {
                    None
                };
                (token, http_client(missing_token_env_var)?)
            }
        })
    }
}

#[derive(Clone, Debug)]
pub(crate) enum Gitea {
    New,
    Initialized { token: String, client: Client },
}