git_branchless_record/

lib.rs

//! Commit changes in the working copy.

#![warn(missing_docs)]
#![warn(
    clippy::all,
    clippy::as_conversions,
    clippy::clone_on_ref_ptr,
    clippy::dbg_macro
)]
#![allow(clippy::too_many_arguments, clippy::blocks_in_conditions)]

use std::collections::HashSet;
use std::ffi::OsString;
use std::fmt::Write;
use std::time::SystemTime;

use git_branchless_invoke::CommandContext;
use git_branchless_opts::{MessageArgs, RecordArgs, ResolveRevsetOptions, Revset};
use git_branchless_reword::{ResolveFixupCommitError, edit_message, resolve_commit_to_fixup};
use itertools::Itertools;
use lib::core::check_out::{CheckOutCommitOptions, CheckoutTarget, check_out_commit};
use lib::core::config::{get_commit_template, get_restack_preserve_timestamps};
use lib::core::dag::{CommitSet, Dag};
use lib::core::effects::{Effects, OperationType};
use lib::core::eventlog::{EventLogDb, EventReplayer, EventTransactionId};
use lib::core::formatting::Pluralize;
use lib::core::repo_ext::RepoExt;
use lib::core::rewrite::{
    BuildRebasePlanError, BuildRebasePlanOptions, ExecuteRebasePlanOptions,
    ExecuteRebasePlanResult, MergeConflictRemediation, RebasePlanBuilder, RebasePlanPermissions,
    RepoResource, execute_rebase_plan,
};
use lib::core::untracked_file_cache::{UntrackedFileStrategy, process_untracked_files};
use lib::git::{
    CategorizedReferenceName, FileMode, GitRunInfo, MaybeZeroOid, NonZeroOid, Repo,
    ResolvedReferenceInfo, Stage, UpdateIndexCommand, WorkingCopyChangesType, WorkingCopySnapshot,
    process_diff_for_record, summarize_diff_for_temporary_commit, update_index,
};
use lib::try_exit_code;
use lib::util::{ExitCode, EyreExitOr};
use rayon::ThreadPoolBuilder;
use scm_record::helpers::CrosstermInput;
use scm_record::{
    Commit, Event, RecordError, RecordInput, RecordState, Recorder, SelectedContents, TerminalKind,
};
use tracing::{instrument, warn};

/// Commit changes in the working copy.
#[instrument]
pub fn command_main(ctx: CommandContext, args: RecordArgs) -> EyreExitOr<()> {
    let CommandContext {
        effects,
        git_run_info,
    } = ctx;
    let RecordArgs {
        message_args: MessageArgs {
            messages,
            commit_to_fixup,
        },
        interactive,
        create,
        detach,
        insert,
        stash,
        untracked_file_strategy,
    } = args;
    record(
        &effects,
        &git_run_info,
        messages,
        commit_to_fixup,
        interactive,
        create,
        detach,
        insert,
        stash,
        untracked_file_strategy,
    )
}

#[instrument]
fn record(
    effects: &Effects,
    git_run_info: &GitRunInfo,
    messages: Vec<String>,
    commit_to_fixup: Option<Revset>,
    interactive: bool,
    branch_name: Option<String>,
    detach: bool,
    insert: bool,
    stash: bool,
    untracked_file_strategy: Option<UntrackedFileStrategy>,
) -> EyreExitOr<()> {
    let now = SystemTime::now();
    let repo = Repo::from_dir(&git_run_info.working_directory)?;
    let conn = repo.get_db_conn()?;
    let event_log_db = EventLogDb::new(&conn)?;
    let event_tx_id = event_log_db.make_transaction_id(now, "record")?;

    let (snapshot, working_copy_changes_type, files_to_add) = {
        let head_info = repo.get_head_info()?;
        let index = repo.get_index()?;
        let (snapshot, _status) =
            repo.get_status(effects, git_run_info, &index, &head_info, Some(event_tx_id))?;

        let working_copy_changes_type = snapshot.get_working_copy_changes_type()?;
        let files_to_add = match working_copy_changes_type {
            WorkingCopyChangesType::None => {
                let files_to_add = if interactive {
                    Vec::new()
                } else {
                    try_exit_code!(process_untracked_files(
                        effects,
                        git_run_info,
                        &repo,
                        event_tx_id,
                        untracked_file_strategy,
                    )?)
                };

                if files_to_add.is_empty() {
                    writeln!(
                        effects.get_output_stream(),
                        "There are no changes to tracked files in the working copy to commit."
                    )?;
                    return Ok(Ok(()));
                } else {
                    files_to_add
                }
            }
            WorkingCopyChangesType::Unstaged | WorkingCopyChangesType::Staged if interactive => {
                Vec::new()
            }
            WorkingCopyChangesType::Staged => Vec::new(),
            WorkingCopyChangesType::Unstaged => {
                try_exit_code!(process_untracked_files(
                    effects,
                    git_run_info,
                    &repo,
                    event_tx_id,
                    untracked_file_strategy,
                )?)
            }
            WorkingCopyChangesType::Conflicts => {
                writeln!(
                    effects.get_output_stream(),
                    "Cannot commit changes while there are unresolved merge conflicts."
                )?;
                writeln!(
                    effects.get_output_stream(),
                    "Resolve them and try again. Aborting."
                )?;
                return Ok(Err(ExitCode(1)));
            }
        };

        (snapshot, working_copy_changes_type, files_to_add)
    };

    if let Some(branch_name) = branch_name {
        try_exit_code!(check_out_commit(
            effects,
            git_run_info,
            &repo,
            &event_log_db,
            event_tx_id,
            None,
            &CheckOutCommitOptions {
                additional_args: vec![OsString::from("-b"), OsString::from(branch_name)],
                force_detach: false,
                reset: false,
                render_smartlog: false,
            },
        )?);
    }

    if interactive {
        if working_copy_changes_type == WorkingCopyChangesType::Staged {
            writeln!(
                effects.get_output_stream(),
                "Cannot select changes interactively while there are already staged changes."
            )?;
            writeln!(
                effects.get_output_stream(),
                "Either commit or unstage your changes and try again. Aborting."
            )?;
            return Ok(Err(ExitCode(1)));
        } else {
            try_exit_code!(record_interactive(
                effects,
                git_run_info,
                &repo,
                &snapshot,
                event_tx_id,
                messages,
            )?);
        }
    } else {
        if !files_to_add.is_empty() {
            // call `git add` for the new untracked files to be commited
            //
            // Note that `git commit` has some functionality for this, by
            // listing files as arguments to the commit command. However, the
            // docs for that state "the commit will ignore changes staged in the
            // index, and instead record the current content of the listed files
            // (which must already be known to Git);" (See
            // https://git-scm.com/docs/git-commit#_description, item 3)
            //
            // The implication is that new working copy files would cause the
            // commit to ignore any changes in the index, which is not what we
            // want. Looking into this can be future scope; it could avoid this
            // extra call to `git add`. On the other hand, this extra call is
            // not very onerous.

            let args = {
                let mut args = vec!["add".to_string()];
                // use repo-canonical paths even if adding in a repo subdir
                args.extend(files_to_add.iter().map(|p| format!(":/{p}")));
                args
            };
            let _ = git_run_info.run_direct_no_wrapping(Some(event_tx_id), &args)?;
        }

        let messages = if messages.is_empty() && stash {
            get_default_stash_message(&repo, effects, &snapshot, &working_copy_changes_type)
                .map(|message| vec![message])?
        } else {
            messages
        };
        let args = {
            let mut args = vec!["commit".to_string()];
            args.extend(
                messages
                    .iter()
                    .flat_map(|message| ["--message".to_string(), message.to_string()]),
            );
            if working_copy_changes_type == WorkingCopyChangesType::Unstaged {
                args.push("--all".to_string());
            }
            if let Some(revset) = commit_to_fixup {
                let event_replayer =
                    EventReplayer::from_event_log_db(effects, &repo, &event_log_db)?;
                let event_cursor = event_replayer.make_default_cursor();
                let references_snapshot = repo.get_references_snapshot()?;
                let mut dag = Dag::open_and_sync(
                    effects,
                    &repo,
                    &event_replayer,
                    event_cursor,
                    &references_snapshot,
                )?;
                let head: Option<&[lib::git::Commit<'_>]> =
                    snapshot.head_commit.as_ref().map(std::slice::from_ref);
                let commit = match resolve_commit_to_fixup(
                    &repo,
                    &mut dag,
                    effects,
                    &revset,
                    &ResolveRevsetOptions::default(),
                    head,
                )? {
                    Ok(commit) => commit,
                    Err(ResolveFixupCommitError::NotAnAncestor) => {
                        writeln!(
                            effects.get_error_stream(),
                            "The commit supplied to --fixup must be an ancestor of the commit being created.\nAborting.",
                        )?;
                        return Ok(Err(ExitCode(1)));
                    }
                    Err(ResolveFixupCommitError::MoreThanOneCommit {
                        revset_to_fixup,
                        commit_count,
                    }) => {
                        writeln!(
                            effects.get_error_stream(),
                            "--fixup expects exactly 1 commit, but '{revset_to_fixup}' evaluated to {commit_count}.\nAborting.",
                        )?;
                        return Ok(Err(ExitCode(1)));
                    }
                };
                let commit = commit.get_oid().to_string();
                args.extend(["--fixup".to_string(), commit]);
            };
            args
        };
        try_exit_code!(git_run_info.run_direct_no_wrapping(Some(event_tx_id), &args)?);
    }

    if detach || stash {
        let head_info = repo.get_head_info()?;
        let checkout_target = match &head_info {
            ResolvedReferenceInfo {
                oid: None,
                reference_name: Some(reference_name),
            } => {
                // FIXME: unborn HEAD, what to do?
                Some(CheckoutTarget::Reference(reference_name.clone()))
            }

            ResolvedReferenceInfo {
                oid: Some(oid),
                reference_name: Some(reference_name),
            } => {
                let head_commit = repo.find_commit_or_fail(*oid)?;
                match head_commit.get_parents().as_slice() {
                    [] => try_exit_code!(git_run_info.run(
                        effects,
                        Some(event_tx_id),
                        &[
                            "update-ref",
                            "-d",
                            reference_name.as_str(),
                            &oid.to_string(),
                        ],
                    )?),
                    [parent_commit] => {
                        let branch_name =
                            CategorizedReferenceName::new(reference_name).render_suffix();
                        repo.detach_head(&head_info)?;
                        try_exit_code!(git_run_info.run(
                            effects,
                            Some(event_tx_id),
                            &[
                                "branch",
                                "-f",
                                &branch_name,
                                &parent_commit.get_oid().to_string(),
                            ],
                        )?);
                    }
                    parent_commits => {
                        eyre::bail!(
                            "git-branchless record --detach called on a merge commit, but it should only be capable of creating zero- or one-parent commits. Parents: {parent_commits:?}"
                        );
                    }
                }

                Some(CheckoutTarget::Reference(reference_name.clone()))
            }

            ResolvedReferenceInfo {
                oid: Some(oid),
                reference_name: None,
            } => {
                let head_commit = repo.find_commit_or_fail(*oid)?;
                match head_commit.get_parents().as_slice() {
                    [] => {
                        eyre::bail!(
                            "git-branchless record --stash seems to have created a root commit (commit without parents), but this should be impossible."
                        );
                    }
                    [parent_commit] => Some(CheckoutTarget::Oid(parent_commit.get_oid())),
                    parent_commits => {
                        eyre::bail!(
                            "git-branchless record --stash seems to have created a merge commit, but this should be impossible. Parents: {parent_commits:?}"
                        );
                    }
                }
            }

            ResolvedReferenceInfo {
                oid: None,
                reference_name: None,
            } => None,
        };

        if stash && checkout_target.is_some() {
            try_exit_code!(check_out_commit(
                effects,
                git_run_info,
                &repo,
                &event_log_db,
                event_tx_id,
                checkout_target,
                &CheckOutCommitOptions {
                    additional_args: vec![],
                    force_detach: false,
                    reset: false,
                    render_smartlog: false,
                },
            )?);
        }
    }

    if insert {
        try_exit_code!(insert_before_siblings(
            effects,
            git_run_info,
            now,
            event_tx_id
        )?);
    }

    Ok(Ok(()))
}

#[instrument]
fn record_interactive(
    effects: &Effects,
    git_run_info: &GitRunInfo,
    repo: &Repo,
    snapshot: &WorkingCopySnapshot,
    event_tx_id: EventTransactionId,
    messages: Vec<String>,
) -> EyreExitOr<()> {
    let old_tree = snapshot.commit_stage0.get_tree()?;
    let new_tree = snapshot.commit_unstaged.get_tree()?;
    let files = {
        let (effects, _progress) = effects.start_operation(OperationType::CalculateDiff);
        let diff = repo.get_diff_between_trees(
            &effects,
            Some(&old_tree),
            &new_tree,
            // We manually add context to the git-record output, so suppress the context lines here.
            0,
        )?;
        process_diff_for_record(repo, &diff)?
    };
    let record_state = RecordState {
        is_read_only: false,
        commits: vec![
            Commit {
                message: Some(messages.iter().join("\n\n")),
            },
            Commit { message: None },
        ],
        files,
    };

    struct Input<'a> {
        git_run_info: &'a GitRunInfo,
        repo: &'a Repo,
    }
    impl RecordInput for Input<'_> {
        fn terminal_kind(&self) -> TerminalKind {
            TerminalKind::Crossterm
        }

        fn next_events(&mut self) -> Result<Vec<Event>, RecordError> {
            CrosstermInput.next_events()
        }

        fn edit_commit_message(&mut self, message: &str) -> Result<String, RecordError> {
            let Self { git_run_info, repo } = self;
            let commit_template = get_commit_template(repo).map_err(|err| {
                RecordError::Other(format!("Could not read commit message template: {err}",))
            })?;
            let message = if message.is_empty() {
                commit_template.as_deref().unwrap_or("")
            } else {
                message
            };
            edit_message(git_run_info, repo, message)
                .map_err(|err| RecordError::Other(err.to_string()))
        }
    }
    let mut input = Input { git_run_info, repo };
    let recorder = Recorder::new(record_state, &mut input);
    let result = recorder.run();
    let RecordState {
        is_read_only: _,
        commits,
        files: result,
    } = match result {
        Ok(result) => result,
        Err(RecordError::Cancelled) => {
            println!("Aborted.");
            return Ok(Err(ExitCode(1)));
        }
        Err(RecordError::Bug(message)) => {
            println!("BUG: {message}");
            println!("This is a bug. Please report it.");
            return Ok(Err(ExitCode(1)));
        }
        Err(
            err @ (RecordError::SetUpTerminal(_)
            | RecordError::CleanUpTerminal(_)
            | RecordError::ReadInput(_)
            | RecordError::RenderFrame(_)
            | RecordError::SerializeJson(_)
            | RecordError::WriteFile(_)
            | RecordError::Other(_)),
        ) => {
            println!("Error: {err}");
            return Ok(Err(ExitCode(1)));
        }
    };
    let message = commits[0].message.clone().unwrap_or_default();

    let update_index_script: Vec<UpdateIndexCommand> = result
        .into_iter()
        .map(|file| -> eyre::Result<UpdateIndexCommand> {
            let (selected, _unselected) = file.get_selected_contents();

            let mode = {
                let default_mode = FileMode::Blob;
                match selected.file_mode {
                    scm_record::FileMode::Absent => {
                        warn!(
                            ?file,
                            ?default_mode,
                            "No file mode was set for file, using default"
                        );
                        default_mode
                    }
                    scm_record::FileMode::Unix(mode) => match i32::try_from(mode) {
                        Ok(mode) => FileMode::from(mode),
                        Err(err) => {
                            warn!(
                                ?mode,
                                ?default_mode,
                                ?err,
                                "File mode did not fit into i32, using default"
                            );
                            default_mode
                        }
                    },
                }
            };

            let oid = match selected.file_mode {
                scm_record::FileMode::Absent => MaybeZeroOid::Zero,
                scm_record::FileMode::Unix(_) => match selected.contents {
                    SelectedContents::Unchanged => {
                        old_tree.get_oid_for_path(&file.path)?.unwrap_or_default()
                    }
                    SelectedContents::Binary {
                        old_description: _,
                        new_description: _,
                    } => new_tree.get_oid_for_path(&file.path)?.unwrap(),
                    SelectedContents::Text { contents } => {
                        MaybeZeroOid::NonZero(repo.create_blob_from_contents(contents.as_bytes())?)
                    }
                },
            };
            let command = match oid {
                MaybeZeroOid::Zero => UpdateIndexCommand::Delete {
                    path: file.path.clone().into_owned(),
                },
                MaybeZeroOid::NonZero(oid) => UpdateIndexCommand::Update {
                    path: file.path.clone().into_owned(),
                    stage: Stage::Stage0,
                    mode,
                    oid,
                },
            };
            Ok(command)
        })
        .try_collect()?;
    let index = repo.get_index()?;
    update_index(
        git_run_info,
        repo,
        &index,
        event_tx_id,
        &update_index_script,
    )?;

    let args = {
        let mut args = vec!["commit"];
        if !message.is_empty() {
            args.extend(["--message", &message]);
        }
        args
    };
    git_run_info.run_direct_no_wrapping(Some(event_tx_id), &args)
}

#[instrument]
fn insert_before_siblings(
    effects: &Effects,
    git_run_info: &GitRunInfo,
    now: SystemTime,
    event_tx_id: EventTransactionId,
) -> EyreExitOr<()> {
    // Reopen the repository since references may have changed.
    let repo = Repo::from_dir(&git_run_info.working_directory)?;
    let conn = repo.get_db_conn()?;
    let event_log_db = EventLogDb::new(&conn)?;
    let references_snapshot = repo.get_references_snapshot()?;
    let event_replayer = EventReplayer::from_event_log_db(effects, &repo, &event_log_db)?;
    let event_cursor = event_replayer.make_default_cursor();
    let head_info = repo.get_head_info()?;
    let head_oid = match head_info {
        ResolvedReferenceInfo {
            oid: Some(head_oid),
            reference_name: _,
        } => head_oid,
        ResolvedReferenceInfo {
            oid: None,
            reference_name: _,
        } => {
            return Ok(Ok(()));
        }
    };

    let dag = Dag::open_and_sync(
        effects,
        &repo,
        &event_replayer,
        event_cursor,
        &references_snapshot,
    )?;
    let head_commit = repo.find_commit_or_fail(head_oid)?;
    let head_commit_set = CommitSet::from(head_oid);
    let parents = dag.query_parents(head_commit_set.clone())?;
    let children = dag.query_children(parents)?;
    let siblings = children.difference(&head_commit_set);
    let siblings = dag.filter_visible_commits(siblings)?;
    let build_options = BuildRebasePlanOptions {
        force_rewrite_public_commits: false,
        dump_rebase_constraints: false,
        dump_rebase_plan: false,
        detect_duplicate_commits_via_patch_id: true,
    };

    let rebase_plan_result =
        match RebasePlanPermissions::verify_rewrite_set(&dag, build_options, &siblings)? {
            Err(err) => Err(err),
            Ok(permissions) => {
                let head_commit_parents: HashSet<_> =
                    head_commit.get_parent_oids().into_iter().collect();
                let mut builder = RebasePlanBuilder::new(&dag, permissions);
                for sibling_oid in dag.commit_set_to_vec(&siblings)? {
                    let sibling_commit = repo.find_commit_or_fail(sibling_oid)?;
                    let parent_oids = sibling_commit.get_parent_oids();
                    let new_parent_oids = parent_oids
                        .into_iter()
                        .map(|parent_oid| {
                            if head_commit_parents.contains(&parent_oid) {
                                head_oid
                            } else {
                                parent_oid
                            }
                        })
                        .collect_vec();
                    builder.move_subtree(sibling_oid, new_parent_oids)?;
                }
                let thread_pool = ThreadPoolBuilder::new().build()?;
                let repo_pool = RepoResource::new_pool(&repo)?;
                builder.build(effects, &thread_pool, &repo_pool)?
            }
        };

    let rebase_plan = match rebase_plan_result {
        Ok(Some(rebase_plan)) => rebase_plan,

        Ok(None) => {
            // Nothing to do, since there were no siblings to move.
            return Ok(Ok(()));
        }

        Err(BuildRebasePlanError::ConstraintCycle { .. }) => {
            writeln!(
                effects.get_output_stream(),
                "BUG: constraint cycle detected when moving siblings, which shouldn't be possible."
            )?;
            return Ok(Err(ExitCode(1)));
        }

        Err(err @ BuildRebasePlanError::MoveIllegalCommits { .. }) => {
            err.describe(effects, &repo, &dag)?;
            return Ok(Err(ExitCode(1)));
        }

        Err(BuildRebasePlanError::MovePublicCommits {
            public_commits_to_move,
        }) => {
            let example_bad_commit_oid = dag
                .set_first(&public_commits_to_move)?
                .ok_or_else(|| eyre::eyre!("BUG: could not get OID of a public commit to move"))?;
            let example_bad_commit_oid = NonZeroOid::try_from(example_bad_commit_oid)?;
            let example_bad_commit = repo.find_commit_or_fail(example_bad_commit_oid)?;
            writeln!(
                effects.get_output_stream(),
                "\
You are trying to rewrite {}, such as: {}
It is generally not advised to rewrite public commits, because your
collaborators will have difficulty merging your changes.
To proceed anyways, run: git move -f -s 'siblings(.)",
                Pluralize {
                    determiner: None,
                    amount: dag.set_count(&public_commits_to_move)?,
                    unit: ("public commit", "public commits")
                },
                effects
                    .get_glyphs()
                    .render(example_bad_commit.friendly_describe(effects.get_glyphs())?)?,
            )?;
            return Ok(Ok(()));
        }
    };

    let execute_options = ExecuteRebasePlanOptions {
        now,
        event_tx_id,
        preserve_timestamps: get_restack_preserve_timestamps(&repo)?,
        force_in_memory: true,
        force_on_disk: false,
        dry_run: false,
        resolve_merge_conflicts: false,
        check_out_commit_options: Default::default(),
    };
    let result = execute_rebase_plan(
        effects,
        git_run_info,
        &repo,
        &event_log_db,
        &rebase_plan,
        &execute_options,
    )?;
    match result {
        ExecuteRebasePlanResult::Succeeded { rewritten_oids: _ }
        | ExecuteRebasePlanResult::WouldSucceed => Ok(Ok(())),
        ExecuteRebasePlanResult::DeclinedToMerge { failed_merge_info } => {
            failed_merge_info.describe(effects, &repo, MergeConflictRemediation::Insert)?;
            Ok(Ok(()))
        }
        ExecuteRebasePlanResult::Failed { exit_code } => Ok(Err(exit_code)),
    }
}

#[instrument]
fn get_default_stash_message(
    repo: &Repo,
    effects: &Effects,
    snapshot: &WorkingCopySnapshot,
    working_copy_changes_type: &WorkingCopyChangesType,
) -> eyre::Result<String> {
    let (old_tree, new_tree) = match working_copy_changes_type {
        WorkingCopyChangesType::Unstaged => {
            let old_tree = snapshot.commit_stage0.get_tree()?;
            let new_tree = snapshot.commit_unstaged.get_tree()?;
            (Some(old_tree), new_tree)
        }
        WorkingCopyChangesType::Staged => {
            let old_tree = match snapshot.head_commit {
                None => None,
                Some(ref commit) => Some(commit.get_tree()?),
            };
            let new_tree = snapshot.commit_stage0.get_tree()?;
            (old_tree, new_tree)
        }
        WorkingCopyChangesType::None | WorkingCopyChangesType::Conflicts => {
            unreachable!("already handled via early exit")
        }
    };

    let diff = repo.get_diff_between_trees(
        effects,
        old_tree.as_ref(),
        &new_tree,
        0, // we don't care about the context here
    )?;

    Ok(format!(
        "stash: {}",
        summarize_diff_for_temporary_commit(&diff)?
    ))
}