1use gh_workflow::*;
  2use indoc::indoc;
  3
  4use crate::tasks::workflows::{
  5    extension_release::extension_workflow_secrets,
  6    extension_tests::{self},
  7    runners,
  8    steps::{
  9        self, CommonJobConditions, DEFAULT_REPOSITORY_OWNER_GUARD, FluentBuilder, NamedJob, named,
 10    },
 11    vars::{
 12        JobOutput, StepOutput, WorkflowInput, WorkflowSecret, one_workflow_per_non_main_branch,
 13    },
 14};
 15
 16const VERSION_CHECK: &str = r#"sed -n 's/version = \"\(.*\)\"/\1/p' < extension.toml"#;
 17
 18// This is used by various extensions repos in the zed-extensions org to bump extension versions.
 19pub(crate) fn extension_bump() -> Workflow {
 20    let bump_type = WorkflowInput::string("bump-type", Some("patch".to_owned()));
 21    // TODO: Ideally, this would have a default of `false`, but this is currently not
 22    // supported in gh-workflows
 23    let force_bump = WorkflowInput::bool("force-bump", None);
 24
 25    let (app_id, app_secret) = extension_workflow_secrets();
 26    let (check_bump_needed, needs_bump, current_version) = check_bump_needed();
 27
 28    let needs_bump = needs_bump.as_job_output(&check_bump_needed);
 29    let current_version = current_version.as_job_output(&check_bump_needed);
 30
 31    let dependencies = [&check_bump_needed];
 32    let bump_version = bump_extension_version(
 33        &dependencies,
 34        &current_version,
 35        &bump_type,
 36        &needs_bump,
 37        &force_bump,
 38        &app_id,
 39        &app_secret,
 40    );
 41    let create_label = create_version_label(
 42        &dependencies,
 43        &needs_bump,
 44        &current_version,
 45        &app_id,
 46        &app_secret,
 47    );
 48
 49    named::workflow()
 50        .add_event(
 51            Event::default().workflow_call(
 52                WorkflowCall::default()
 53                    .add_input(bump_type.name, bump_type.call_input())
 54                    .add_input(force_bump.name, force_bump.call_input())
 55                    .secrets([
 56                        (app_id.name.to_owned(), app_id.secret_configuration()),
 57                        (
 58                            app_secret.name.to_owned(),
 59                            app_secret.secret_configuration(),
 60                        ),
 61                    ]),
 62            ),
 63        )
 64        .concurrency(one_workflow_per_non_main_branch())
 65        .add_env(("CARGO_TERM_COLOR", "always"))
 66        .add_env(("RUST_BACKTRACE", 1))
 67        .add_env(("CARGO_INCREMENTAL", 0))
 68        .add_env((
 69            "ZED_EXTENSION_CLI_SHA",
 70            extension_tests::ZED_EXTENSION_CLI_SHA,
 71        ))
 72        .add_job(check_bump_needed.name, check_bump_needed.job)
 73        .add_job(bump_version.name, bump_version.job)
 74        .add_job(create_label.name, create_label.job)
 75}
 76
 77fn check_bump_needed() -> (NamedJob, StepOutput, StepOutput) {
 78    let (compare_versions, version_changed, current_version) = compare_versions();
 79
 80    let job = Job::default()
 81        .with_repository_owner_guard()
 82        .outputs([
 83            (version_changed.name.to_owned(), version_changed.to_string()),
 84            (
 85                current_version.name.to_string(),
 86                current_version.to_string(),
 87            ),
 88        ])
 89        .runs_on(runners::LINUX_SMALL)
 90        .timeout_minutes(1u32)
 91        .add_step(steps::checkout_repo().add_with(("fetch-depth", 0)))
 92        .add_step(compare_versions);
 93
 94    (named::job(job), version_changed, current_version)
 95}
 96
 97fn create_version_label(
 98    dependencies: &[&NamedJob],
 99    needs_bump: &JobOutput,
100    current_version: &JobOutput,
101    app_id: &WorkflowSecret,
102    app_secret: &WorkflowSecret,
103) -> NamedJob {
104    let (generate_token, generated_token) = generate_token(app_id, app_secret, None);
105    let job = steps::dependant_job(dependencies)
106        .cond(Expression::new(format!(
107            "{DEFAULT_REPOSITORY_OWNER_GUARD} && github.event_name == 'push' && github.ref == 'refs/heads/main' && {} == 'false'",
108            needs_bump.expr(),
109        )))
110        .runs_on(runners::LINUX_LARGE)
111        .timeout_minutes(1u32)
112        .add_step(generate_token)
113        .add_step(steps::checkout_repo())
114        .add_step(create_version_tag(current_version, generated_token));
115
116    named::job(job)
117}
118
119fn create_version_tag(current_version: &JobOutput, generated_token: StepOutput) -> Step<Use> {
120    named::uses("actions", "github-script", "v7").with(
121        Input::default()
122            .add(
123                "script",
124                format!(
125                    indoc! {r#"
126                        github.rest.git.createRef({{
127                            owner: context.repo.owner,
128                            repo: context.repo.repo,
129                            ref: 'refs/tags/v{}',
130                            sha: context.sha
131                        }})"#
132                    },
133                    current_version
134                ),
135            )
136            .add("github-token", generated_token.to_string()),
137    )
138}
139
140/// Compares the current and previous commit and checks whether versions changed inbetween.
141fn compare_versions() -> (Step<Run>, StepOutput, StepOutput) {
142    let check_needs_bump = named::bash(format!(
143        indoc! {
144        r#"
145        CURRENT_VERSION="$({})"
146        PR_PARENT_SHA="${{{{ github.event.pull_request.head.sha }}}}"
147
148        if [[ -n "$PR_PARENT_SHA" ]]; then
149            git checkout "$PR_PARENT_SHA"
150        elif BRANCH_PARENT_SHA="$(git merge-base origin/main origin/zed-zippy-autobump)"; then
151            git checkout "$BRANCH_PARENT_SHA"
152        else
153            git checkout "$(git log -1 --format=%H)"~1
154        fi
155
156        PARENT_COMMIT_VERSION="$({})"
157
158        [[ "$CURRENT_VERSION" == "$PARENT_COMMIT_VERSION" ]] && \
159          echo "needs_bump=true" >> "$GITHUB_OUTPUT" || \
160          echo "needs_bump=false" >> "$GITHUB_OUTPUT"
161
162        echo "current_version=${{CURRENT_VERSION}}" >> "$GITHUB_OUTPUT"
163        "#
164        },
165        VERSION_CHECK, VERSION_CHECK
166    ))
167    .id("compare-versions-check");
168
169    let needs_bump = StepOutput::new(&check_needs_bump, "needs_bump");
170    let current_version = StepOutput::new(&check_needs_bump, "current_version");
171
172    (check_needs_bump, needs_bump, current_version)
173}
174
175fn bump_extension_version(
176    dependencies: &[&NamedJob],
177    current_version: &JobOutput,
178    bump_type: &WorkflowInput,
179    needs_bump: &JobOutput,
180    force_bump: &WorkflowInput,
181    app_id: &WorkflowSecret,
182    app_secret: &WorkflowSecret,
183) -> NamedJob {
184    let (generate_token, generated_token) = generate_token(app_id, app_secret, None);
185    let (bump_version, new_version) = bump_version(current_version, bump_type);
186
187    let job = steps::dependant_job(dependencies)
188        .cond(Expression::new(format!(
189            "{DEFAULT_REPOSITORY_OWNER_GUARD} &&\n({} == 'true' || {} == 'true')",
190            force_bump.expr(),
191            needs_bump.expr(),
192        )))
193        .runs_on(runners::LINUX_LARGE)
194        .timeout_minutes(1u32)
195        .add_step(generate_token)
196        .add_step(steps::checkout_repo())
197        .add_step(install_bump_2_version())
198        .add_step(bump_version)
199        .add_step(create_pull_request(new_version, generated_token));
200
201    named::job(job)
202}
203
204pub(crate) fn generate_token(
205    app_id: &WorkflowSecret,
206    app_secret: &WorkflowSecret,
207    repository_target: Option<RepositoryTarget>,
208) -> (Step<Use>, StepOutput) {
209    let step = named::uses("actions", "create-github-app-token", "v2")
210        .id("generate-token")
211        .add_with(
212            Input::default()
213                .add("app-id", app_id.to_string())
214                .add("private-key", app_secret.to_string())
215                .when_some(
216                    repository_target,
217                    |input,
218                     RepositoryTarget {
219                         owner,
220                         repositories,
221                     }| {
222                        input.add("owner", owner).add("repositories", repositories)
223                    },
224                ),
225        );
226
227    let generated_token = StepOutput::new(&step, "token");
228
229    (step, generated_token)
230}
231
232fn install_bump_2_version() -> Step<Run> {
233    named::run(runners::Platform::Linux, "pip install bump2version")
234}
235
236fn bump_version(current_version: &JobOutput, bump_type: &WorkflowInput) -> (Step<Run>, StepOutput) {
237    let step = named::bash(format!(
238        indoc! {r#"
239            OLD_VERSION="{}"
240
241            BUMP_FILES=("extension.toml")
242            if [[ -f "Cargo.toml" ]]; then
243                BUMP_FILES+=("Cargo.toml")
244            fi
245
246            bump2version --verbose --current-version "$OLD_VERSION" --no-configured-files {} "${{BUMP_FILES[@]}}"
247
248            if [[ -f "Cargo.toml" ]]; then
249                cargo update --workspace
250            fi
251
252            NEW_VERSION="$({})"
253
254            echo "new_version=${{NEW_VERSION}}" >> "$GITHUB_OUTPUT"
255            "#
256        },
257        current_version, bump_type, VERSION_CHECK
258    ))
259    .id("bump-version");
260
261    let new_version = StepOutput::new(&step, "new_version");
262    (step, new_version)
263}
264
265fn create_pull_request(new_version: StepOutput, generated_token: StepOutput) -> Step<Use> {
266    let formatted_version = format!("v{}", new_version);
267
268    named::uses("peter-evans", "create-pull-request", "v7").with(
269        Input::default()
270            .add("title", format!("Bump version to {}", new_version))
271            .add(
272                "body",
273                format!(
274                    "This PR bumps the version of this extension to {}",
275                    formatted_version
276                ),
277            )
278            .add(
279                "commit-message",
280                format!("Bump version to {}", formatted_version),
281            )
282            .add("branch", "zed-zippy-autobump")
283            .add(
284                "committer",
285                "zed-zippy[bot] <234243425+zed-zippy[bot]@users.noreply.github.com>",
286            )
287            .add("base", "main")
288            .add("delete-branch", true)
289            .add("token", generated_token.to_string())
290            .add("sign-commits", true),
291    )
292}
293
294pub(crate) struct RepositoryTarget {
295    owner: String,
296    repositories: String,
297}
298
299impl RepositoryTarget {
300    pub fn new<T: ToString>(owner: T, repositories: &[&str]) -> Self {
301        Self {
302            owner: owner.to_string(),
303            repositories: repositories.join("\n"),
304        }
305    }
306}