git-quickfix 0.0.3

use std::process;

use git2::{self, Repository, ResetType};
use process::Command;

use color_eyre::{eyre::Report, eyre::Result, Section};
use eyre::eyre;
use structopt::StructOpt;

extern crate log;

fn main() -> Result<()> {
    color_eyre::install()?;
    //  Big and bloats the code.
    env_logger::init();

    run()?;
    Ok(())
}

/// This cherry-picks a commit onto a new branch crated from default branch.
/// A typical use case is when one wants to quickly create a fix without leaving
/// the current branch. The quickfix-commit will then be cherry-picked onto a new
/// branch based-off origin/main. The benefit of this tool is that slow, expensive
/// and disruptive switching of branches is avoided. Everything is done in-memory
/// with no checkout of files on the file system.
///
/// Usage:
///
/// 1. Commit the changes
/// 2. git quickfix <new-branch>. This will create a new branch from the default branch.
///     `--push` will directly push this to the `origin` remote.
///     `--keep` will keep the quickfix commit on the current branch.
/// 3. The changes will be removed from the current branch, unless `--keep` was given to quickfix.
///
/// Benefits: Quickly provide unrelated fixes without having to abandon the current branch and switching branches.

#[derive(Debug, StructOpt)]
#[structopt(
    name = "git-quickfix",
    about = "Apply patches directly to the main branch.",
    verbatim_doc_comment
)]
struct Opt {
    branch: String,
    #[structopt(short = "m", long = "message", help = "Commit message")]
    message: Option<String>,
    #[structopt(
        long = "push",
        short = "u",
        help = "Push the newly crated branch to origin."
    )]
    push: bool,
    #[structopt(
        long = "keep",
        short = "k",
        help = "Keep the new quickfix commit on the current branch."
    )]
    keep: bool,
    #[structopt(
        help = "The branch to apply the patch onto. Defaults to the default branch on origin (e.g. origin/main).",
        long = "onto",
        short = "o"
    )]
    onto: Option<String>,
}

fn run() -> Result<(), Report> {
    let opts = Opt::from_args();
    let repo = Repository::open_from_env()?;

    let onto_branch = match opts.onto {
        Some(b) => b,
        None => {
            get_default_branch(&repo).suggestion("Manually set the target branch with `--onto`.")?
        }
    };

    // Cherry-pick the HEAD onto the main branch but in memory.
    // Then create a new branch with that cherry-picked commit.
    let fix_commit = repo.head()?.peel_to_commit()?;

    let main_commit = repo
        .revparse(&onto_branch)?
        .from()
        .unwrap()
        .peel_to_commit()?;

    // Cherry-pick (in memory)
    let mut index = repo.cherrypick_commit(&fix_commit, &main_commit, 0, None)?;
    let tree_oid = index.write_tree_to(&repo)?;
    let tree = repo.find_tree(tree_oid)?;

    // The author is copied from the original commit. But the committer is set to the current user and timestamp.
    let signature = repo.signature()?;
    let message = fix_commit
        .message_raw()
        .ok_or_else(|| eyre!("Could not read the commit message."))
        .suggestion("Make sure the commit message contains only UTF-8 characters or try to manually cherry-pick the commit.")?;

    let commit_oid = repo
        .commit(
            Some(&format!("refs/heads/{}", opts.branch)),
            &fix_commit.author(),
            &signature,
            message,
            &tree,
            &[&main_commit],
        )
        .suggestion(
            "You cannot provide an existing branch name. Choose a new branch name or run with.",
        )?; // TODO: How do I make sure this suggestion only gets shown if ErrorClass==Object and ErrorCode==-15?
    log::debug!(
        "Wrote quickfixed changes to new commit {} and new branch {}",
        commit_oid,
        opts.branch
    );

    // TODO: What to do if the index or working dir is dirty?
    if !opts.keep {
        // Equivalent to git reset --hard HEAD~1
        if fix_commit.parent_count() != 1 {
            return Err(eyre!("Only works with non-merge commits"))
                .suggestion("Quickfixing a merge commit is not supported. If you meant to do this please file a ticket with your usecase.");
        };
        let head_1 = fix_commit.parent(0)?;
        repo.reset(&head_1.as_object(), ResetType::Hard, None)?;
    }

    // TODO: Use git2 instead of Command.
    if opts.push {
        log::info!("Pushing new branch to origin.");
        let status = Command::new("git")
            .args(&["push", "--set-upstream", "origin", &opts.branch])
            .status()?;
        if !status.success() {
            eyre!("Failed to run git push. {}", status);
        } else {
            log::info!("Git push succeeded");
        }
    }

    Ok(())
}

fn get_default_branch(repo: &Repository) -> Result<String, Report> {
    // NOTE: Unfortunately, I cannot use repo.find_remote().default_branch() because it requires a connect() before.
    // Furthermore, a lot is to be said about returning a Reference or a Revspec instead of a String.
    for name in ["origin/main", "origin/master", "origin/devel"].iter() {
        match repo.resolve_reference_from_short_name(name) {
            Ok(_) => {
                log::debug!("Found {} as the default remote branch. A bit hacky -- wrong results certainly possible.", name);
                return Ok(name.to_string());
            }
            Err(_) => continue,
        }
    }
    Err(eyre!("Could not find remote default branch."))
}