codeberg_cli/actions/pull_request/

create.rs

use crate::actions::GlobalArgs;
use crate::actions::text_manipulation::{input_prompt_for, select_prompt_for};
use crate::render::json::JsonToStdout;
use crate::render::option::option_display;
use crate::render::ui::{
    fuzzy_select_with_key, fuzzy_select_with_key_with_default, multi_fuzzy_select_with_key,
};
use crate::types::context::BergContext;
use crate::types::git::OwnerRepo;
use crate::types::output::OutputMode;
use clap::Parser;
use forgejo_api::structs::{
    CreatePullRequestOption, IssueGetMilestonesListQuery, IssueListLabelsQuery,
};
use miette::{Context, IntoDiagnostic};
use strum::{Display, VariantArray};

/// Create a pull request
#[derive(Parser, Debug)]
pub struct CreatePullRequestArgs {
    /// Comma-delimited list of assignee names
    #[arg(short, long, value_name = "ASSIGNEE,...", value_delimiter = ',')]
    pub assignees: Option<Vec<String>>,

    /// Target branch for the pull request
    #[arg(short, long)]
    pub target_branch: Option<String>,

    /// Main description of the pull request
    #[arg(id = "description", short, long)]
    pub body: Option<String>,

    /// Source branch of the pull request
    #[arg(short, long)]
    pub source_branch: Option<String>,

    /// Comma-delimited list of labels
    #[arg(short, long, value_name = "LABEL,...", value_delimiter = ',')]
    pub labels: Option<Vec<String>>,

    /// Title or summary
    #[arg(long)]
    pub title: Option<String>,

    /// Name of the milestone the pull request is related to
    #[arg(short, long)]
    pub milestone: Option<String>,

    /// Interactive mode which guides the user through optional argument options
    #[arg(short, long)]
    pub interactive: bool,
}

#[derive(Display, PartialEq, Eq, VariantArray)]
enum CreatableFields {
    Assignees,
    Labels,
    Milestone,
}

impl CreatePullRequestArgs {
    pub async fn run(self, global_args: GlobalArgs) -> miette::Result<()> {
        let ctx = BergContext::new(self, global_args).await?;

        let OwnerRepo { repo, owner } = ctx.owner_repo()?;
        let options = create_options(&ctx).await?;
        let pull_request = ctx
            .client
            .repo_create_pull_request(owner.as_str(), repo.as_str(), options)
            .await
            .into_diagnostic()?;

        match ctx.global_args.output_mode {
            OutputMode::Pretty => {
                println!(
                    "Successfully created pull request!{opt_url}",
                    opt_url = pull_request
                        .url
                        .map(|url| format!("\n\n\tSee: {url}"))
                        .unwrap_or_default()
                );
            }
            OutputMode::Json => pull_request.print_json()?,
        }

        Ok(())
    }
}

async fn create_options(
    ctx: &BergContext<CreatePullRequestArgs>,
) -> miette::Result<CreatePullRequestOption> {
    let OwnerRepo { owner, repo } = ctx.owner_repo()?;
    let title = match ctx.args.title.as_ref() {
        Some(title) => title.clone(),
        None => {
            if ctx.global_args.non_interactive {
                miette::bail!(
                    "You have to specify the pull request title in non-interactive mode!"
                );
            }
            inquire::Text::new(input_prompt_for("Pull Request Title").as_str())
                .prompt()
                .into_diagnostic()?
        }
    };

    let target_branch = match ctx.args.target_branch.as_ref() {
        Some(branch) => branch.clone(),
        None => {
            if ctx.global_args.non_interactive {
                miette::bail!(
                    "You have to specify the pull request target branch in non-interactive mode!"
                );
            }
            select_branch(
                ctx,
                "target branch into which changes are merged",
                vec!["main", "master"],
                None,
            )
            .await?
        }
    };

    let source_branch = match ctx.args.source_branch.as_ref() {
        Some(branch) => branch.clone(),
        None => {
            let current_checkout = get_current_checkout()?;
            if ctx.global_args.non_interactive {
                current_checkout
            } else {
                select_branch(
                    ctx,
                    "source branch containing the changes",
                    vec![current_checkout.as_str()],
                    Some(target_branch.as_str()),
                )
                .await?
            }
        }
    };

    let labels = if let Some(requested_labels) = ctx.args.labels.as_ref() {
        let (_, issue_labels) = ctx
            .client
            .issue_list_labels(owner.as_str(), repo.as_str(), Default::default())
            .await
            .into_diagnostic()?;
        let labels = requested_labels
            .iter()
            .map(|label_name| {
                issue_labels
                    .iter()
                    .find(|label| label.name.as_ref().is_some_and(|name| name == label_name))
                    .with_context(|| format!("Label with name {label_name} doesn't exist yet"))
                    .context("Please create all labels before using them")?
                    .id
                    .context("Selected label is missing an ID")
            })
            .collect::<Result<Vec<_>, _>>()?;
        Some(labels)
    } else {
        None
    };

    let milestone = if let Some(milestone_title) = ctx.args.milestone.as_ref() {
        let (_, milestones) = ctx
            .client
            .issue_get_milestones_list(owner.as_str(), repo.as_str(), Default::default())
            .await
            .into_diagnostic()?;
        let selected_milestone = milestones
            .into_iter()
            .find(|milestone| {
                milestone
                    .title
                    .as_ref()
                    .is_some_and(|title| title == milestone_title)
            })
            .with_context(|| format!("Couldn't find milestone with title: {milestone_title}"))?;
        Some(
            selected_milestone
                .id
                .context("Milestone is expected to have a milestone ID!")?,
        )
    } else {
        None
    };

    let mut options = CreatePullRequestOption {
        title: Some(title),
        base: Some(target_branch),
        head: Some(source_branch),
        assignee: None,
        assignees: ctx.args.assignees.clone(),
        body: ctx.args.body.clone(),
        due_date: None,
        labels,
        milestone,
    };

    if !ctx.global_args.non_interactive {
        let optional_data = {
            use CreatableFields::*;
            [
                (Labels, ctx.args.labels.is_none()),
                (Assignees, ctx.args.assignees.is_none()),
                (Milestone, ctx.args.milestone.is_none()),
            ]
            .into_iter()
            .filter_map(|(name, missing)| missing.then_some(name))
            .collect::<Vec<_>>()
        };

        let chosen_optionals = multi_fuzzy_select_with_key(
            &optional_data,
            "Choose optional properties",
            |_| false,
            |o| o.to_string(),
        )?;

        options.body.replace(pr_body(ctx)?);
        {
            use CreatableFields::*;
            options.labels = pr_labels(ctx, chosen_optionals.contains(&&Labels)).await?;
            options.assignees = pr_assignees(ctx, chosen_optionals.contains(&&Assignees)).await?;
            options.milestone = pr_milestone(ctx, chosen_optionals.contains(&&Milestone)).await?;
        }
    }

    Ok(options)
}

fn pr_body(ctx: &BergContext<CreatePullRequestArgs>) -> miette::Result<String> {
    let body = match ctx.args.body.as_ref() {
        Some(body) => body.clone(),
        None => ctx.editor_for("a description", "Enter a pull request description")?,
    };
    Ok(body)
}

async fn pr_labels(
    ctx: &BergContext<CreatePullRequestArgs>,
    interactive: bool,
) -> miette::Result<Option<Vec<i64>>> {
    let OwnerRepo { repo, owner } = ctx.owner_repo()?;

    let (_, all_labels) = ctx
        .client
        .issue_list_labels(
            owner.as_str(),
            repo.as_str(),
            IssueListLabelsQuery::default(),
        )
        .await
        .into_diagnostic()?;

    let labels = match &ctx.args.labels {
        Some(label_names) => {
            let label_ids = all_labels
                .iter()
                .filter(|l| {
                    l.name
                        .as_ref()
                        .is_some_and(|name| label_names.contains(name))
                })
                .filter_map(|l| l.id)
                .collect::<Vec<_>>();
            Some(label_ids)
        }
        None => {
            if !interactive {
                return Ok(None);
            }

            let selected_labels = multi_fuzzy_select_with_key(
                &all_labels,
                select_prompt_for("labels"),
                |_| false,
                |l| {
                    l.name
                        .as_ref()
                        .cloned()
                        .unwrap_or_else(|| String::from("???"))
                },
            )?;

            let label_ids = selected_labels
                .iter()
                .filter_map(|l| l.id)
                .collect::<Vec<_>>();

            Some(label_ids)
        }
    };
    Ok(labels)
}

async fn pr_assignees(
    ctx: &BergContext<CreatePullRequestArgs>,
    interactive: bool,
) -> miette::Result<Option<Vec<String>>> {
    let OwnerRepo { repo, owner } = ctx.owner_repo()?;

    let (_, all_assignees) = ctx
        .client
        .repo_get_assignees(owner.as_str(), repo.as_str())
        .await
        .into_diagnostic()?;
    let assignees = match &ctx.args.assignees {
        Some(assignees_names) => Some(assignees_names.clone()),
        None => {
            if !interactive {
                return Ok(None);
            }

            let selected_assignees = multi_fuzzy_select_with_key(
                &all_assignees,
                select_prompt_for("assignees"),
                |_| false,
                |u| {
                    u.login
                        .as_ref()
                        .cloned()
                        .unwrap_or_else(|| String::from("???"))
                },
            )?;

            Some(
                selected_assignees
                    .into_iter()
                    .filter_map(|u| u.login.as_ref().cloned())
                    .collect::<Vec<_>>(),
            )
        }
    };

    Ok(assignees)
}

async fn pr_milestone(
    ctx: &BergContext<CreatePullRequestArgs>,
    interactive: bool,
) -> miette::Result<Option<i64>> {
    let OwnerRepo { repo, owner } = ctx.owner_repo()?;

    let (_, all_milestones) = ctx
        .client
        .issue_get_milestones_list(
            owner.as_str(),
            repo.as_str(),
            IssueGetMilestonesListQuery::default(),
        )
        .await
        .into_diagnostic()?;

    let milestone = match &ctx.args.milestone {
        Some(milestone_name) => Some(
            all_milestones
                .iter()
                .find(|m| m.title.as_ref().is_some_and(|name| name == milestone_name))
                .and_then(|milestone| milestone.id)
                .context(format!(
                    "Milestone with name {milestone_name} wasn't found. Check the spelling"
                ))?,
        ),
        None => {
            if !interactive {
                return Ok(None);
            }
            let selected_milestone =
                fuzzy_select_with_key(&all_milestones, select_prompt_for("milestones"), |m| {
                    m.title
                        .as_ref()
                        .cloned()
                        .unwrap_or_else(|| String::from("???"))
                })?;

            Some(
                selected_milestone
                    .id
                    .context("Selected milestone's id is missing")?,
            )
        }
    };

    Ok(milestone)
}

async fn select_branch(
    ctx: &BergContext<CreatePullRequestArgs>,
    prompt_text: &str,
    default_branch_names: Vec<&str>,
    filter_branch: Option<&str>,
) -> miette::Result<String> {
    let OwnerRepo { repo, owner } = ctx.owner_repo()?;
    let (_, branches_list) = ctx
        .client
        .repo_list_branches(owner.as_str(), repo.as_str())
        .await
        .into_diagnostic()?;
    let branches = branches_list
        .into_iter()
        .filter(|branch| {
            branch
                .name
                .as_ref()
                .is_some_and(|name| filter_branch.is_none_or(|filter| name != filter))
        })
        .collect::<Vec<_>>();

    if branches.is_empty() {
        if filter_branch.is_some() {
            miette::bail!(
                "No remote branches except {filter_branch:?} found. Maybe the branch you want to merge doesn't exist on remote yet?"
            );
        } else {
            miette::bail!("No remote branches found.");
        }
    }

    let default_index = default_branch_names.iter().find_map(|&default_name| {
        branches.iter().position(|branch| {
            branch
                .name
                .as_ref()
                .is_some_and(|name| name.as_str() == default_name)
        })
    });

    fuzzy_select_with_key_with_default(
        &branches,
        select_prompt_for(prompt_text),
        |b| option_display(&b.name),
        default_index,
    )
    .map(|branch| option_display(&branch.name))
}

fn get_current_checkout() -> miette::Result<String> {
    let output = std::process::Command::new("git")
        .arg("branch")
        .arg("--show-current")
        .output()
        .into_diagnostic()?;
    String::from_utf8(output.stdout)
        .map(|base| base.trim().to_owned())
        .into_diagnostic()
}