// Copyright 2020 The Jujutsu Authors//// Licensed under the Apache License, Version 2.0 (the "License");// you may not use this file except in compliance with the License.// You may obtain a copy of the License at//// https://www.apache.org/licenses/LICENSE-2.0//// Unless required by applicable law or agreed to in writing, software// distributed under the License is distributed on an "AS IS" BASIS,// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.// See the License for the specific language governing permissions and// limitations under the License. use std::collections::HashSet;use std::io::Write as _; use bstr::ByteVec as _;use clap_complete::ArgValueCompleter;use futures::future::try_join_all;use indexmap::IndexSet;use itertools::Itertools as _;use jj_lib::backend::CommitId;use jj_lib::repo::Repo as _;use jj_lib::rewrite::merge_commit_trees;use jj_lib::rewrite::rebase_commit;use tracing::instrument; use crate::cli_util::CommandHelper;use crate::cli_util::RevisionArg;use crate::cli_util::compute_commit_location;use crate::cli_util::merge_args_with;use crate::command_error::CommandError;use crate::complete;use crate::description_util::add_trailers;use crate::description_util::join_message_paragraphs;use crate::text_util;use crate::ui::Ui; /// Create a new, empty change and (by default) edit it in the working copy////// By default, `jj` will edit the new change, making the [working copy]/// represent the new commit. This can be avoided with `--no-edit`.////// Note that you can create a merge commit by specifying multiple revisions as/// argument. For example, `jj new @ main` will create a new commit with the/// working copy and the `main` bookmark as parents.////// [working copy]:///     https://docs.jj-vcs.dev/latest/working-copy/#[derive(clap::Args, Clone, Debug)]#[command(group(clap::ArgGroup::new("revisions").multiple(true)))]pub(crate) struct NewArgs {    /// Parent(s) of the new change [default: @] [aliases: -o, -r]    #[arg(group = "revisions", value_name = "REVSETS")]    #[arg(add = ArgValueCompleter::new(complete::revset_expression_all))]    revisions_pos: Option<Vec<RevisionArg>>,     #[arg(        short = 'o',        group = "revisions",        hide = true,        short_aliases = ['d', 'r'],        value_name = "REVSETS",     )]    #[arg(add = ArgValueCompleter::new(complete::revset_expression_all))]    revisions_opt: Option<Vec<RevisionArg>>,     /// The change description to use    #[arg(long = "message", short, value_name = "MESSAGE")]    message_paragraphs: Vec<String>,     /// Do not edit the newly created change    #[arg(long, conflicts_with = "_edit")]    no_edit: bool,     /// No-op flag to pair with --no-edit    #[arg(long, hide = true)]    _edit: bool,     /// Insert the new change after the given commit(s)    ///    /// Example: `jj new --insert-after A` creates a new change between `A` and    /// its children:    ///    /// ```text    ///                 B   C    ///                  \ /    ///     B   C   =>    @    ///      \ /          |    ///       A           A    /// ```    ///    /// Specifying `--insert-after` multiple times will relocate all children of    /// the given commits.    ///    /// Example: `jj new --insert-after A --insert-after X` creates a change    /// with `A` and `X` as parents, and rebases all children on top of the new    /// change:    ///    /// ```text    ///                 B   Y    ///                  \ /    ///     B  Y    =>    @    ///     |  |         / \    ///     A  X        A   X    /// ```    #[arg(        long,        short = 'A',        visible_alias = "after",        conflicts_with = "revisions",        value_name = "REVSETS",        verbatim_doc_comment    )]    #[arg(add = ArgValueCompleter::new(complete::revset_expression_all))]    insert_after: Option<Vec<RevisionArg>>,     /// Insert the new change before the given commit(s)    ///    /// Example: `jj new --insert-before C` creates a new change between `C` and    /// its parents:    ///    /// ```text    ///                    C    ///                    |    ///       C     =>     @    ///      / \          / \    ///     A   B        A   B    /// ```    ///    /// `--insert-after` and `--insert-before` can be combined.    ///    /// Example: `jj new --insert-after A --insert-before D`:    ///    /// ```text    ///     D            D    ///     |           / \    ///     C          |   C    ///     |    =>    @   |    ///     B          |   B    ///     |           \ /    ///     A            A    /// ```    ///    /// Similar to `--insert-after`, you can specify `--insert-before` multiple    /// times.    #[arg(        long,        short = 'B',        visible_alias = "before",        conflicts_with = "revisions",        value_name = "REVSETS",        verbatim_doc_comment    )]    #[arg(add = ArgValueCompleter::new(complete::revset_expression_mutable))]    insert_before: Option<Vec<RevisionArg>>,} #[instrument(skip_all)]pub(crate) async fn cmd_new(    ui: &mut Ui,    command: &CommandHelper,    args: &NewArgs,) -> Result<(), CommandError> {    let mut workspace_command = command.workspace_helper(ui).await?;     let revision_args = match (&args.revisions_pos, &args.revisions_opt) {        (None, None) => (args.insert_before.is_none() && args.insert_after.is_none())            .then(|| vec![RevisionArg::AT]),        (None, Some(args)) | (Some(args), None) => Some(args.clone()),        (Some(pos), Some(opt)) => Some(merge_args_with(            command.matches().subcommand_matches("new").unwrap(),            &[("revisions_pos", pos), ("revisions_opt", opt)],            |_id, value| value.clone(),        )),    };    let (parent_commit_ids, child_commit_ids) = compute_commit_location(        ui,        &workspace_command,        revision_args.as_deref(),        args.insert_after.as_deref(),        args.insert_before.as_deref(),        "new commit",    )    .await?;    let parent_commits = try_join_all(        parent_commit_ids            .iter()            .map(|commit_id| workspace_command.repo().store().get_commit_async(commit_id)),    )    .await?;    let mut advance_bookmarks_target = None;    let mut advanceable_bookmarks = vec![];     if args.insert_before.is_none() && args.insert_after.is_none() {        let should_advance_bookmarks = parent_commits.len() == 1;        if should_advance_bookmarks {            advance_bookmarks_target = Some(parent_commit_ids[0].clone());            advanceable_bookmarks =                workspace_command.get_advanceable_bookmarks(ui, parent_commits[0].parent_ids())?;        }    }     let parent_commit_ids_set: HashSet<CommitId> = parent_commit_ids.iter().cloned().collect();     let mut tx = workspace_command.start_transaction();    let merged_tree = merge_commit_trees(tx.repo(), &parent_commits).await?;    let mut commit_builder = tx        .repo_mut()        .new_commit(parent_commit_ids, merged_tree)        .detach();    let description = if !args.message_paragraphs.is_empty() {        join_message_paragraphs(&args.message_paragraphs)    } else {        let template_text = tx.settings().get_string("templates.new_description")?;        if template_text.is_empty() {            String::new()        } else {            let template = tx.parse_commit_template(ui, &template_text)?;            let temp_commit = commit_builder.write_hidden().await?;            text_util::complete_newline(                template.format_plain_text(&temp_commit).into_string_lossy(),            )        }    };    if !description.is_empty() {        // The first trailer would become the first line of the description.        // Also, a commit with no description is treated in a special way in jujutsu: it        // can be discarded as soon as it's no longer the working copy. Adding a        // trailer to an empty description would break that logic.        commit_builder.set_description(&description);        let description = add_trailers(ui, &tx, &commit_builder).await?;        commit_builder.set_description(&description);    }    let new_commit = commit_builder.write(tx.repo_mut()).await?;     let child_commits = try_join_all(        child_commit_ids            .iter()            .map(|commit_id| tx.repo().store().get_commit_async(commit_id)),    )    .await?;    let mut num_rebased = 0;    for child_commit in child_commits {        let mut new_parent_ids = IndexSet::new();        // If the original parents of the children commits are the parents of the new        // commit, replace them with the new commit since we are "inserting" the new        // commit in between the parents and the children.        for old_parent_id in child_commit.parent_ids() {            if parent_commit_ids_set.contains(old_parent_id) {                new_parent_ids.insert(new_commit.id().clone());            } else {                new_parent_ids.insert(old_parent_id.clone());            }        }        new_parent_ids.insert(new_commit.id().clone());        let new_parent_ids = new_parent_ids.into_iter().collect_vec();        rebase_commit(tx.repo_mut(), child_commit, new_parent_ids).await?;        num_rebased += 1;    }    num_rebased += tx.repo_mut().rebase_descendants().await?;     if args.no_edit {        if let Some(mut formatter) = ui.status_formatter() {            write!(formatter, "Created new commit ")?;            tx.write_commit_summary(formatter.as_mut(), &new_commit)?;            writeln!(formatter)?;        }    } else {        tx.edit(&new_commit)?;        // The description of the new commit will be printed by tx.finish()    }    if num_rebased > 0 {        writeln!(ui.status(), "Rebased {num_rebased} descendant commits.")?;    }     // Does nothing if there's no bookmarks to advance.    if let Some(target) = advance_bookmarks_target {        tx.advance_bookmarks(advanceable_bookmarks, &target).await?;    }     tx.finish(ui, "new empty commit").await?;    Ok(())}