duplicate: add --destination, --insert-after, and `--insert-befor…

…e` options

CHANGELOG.md

@@ -69,6 +69,10 @@ to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 * New template functions `pad_start()`, `pad_end()`, `truncate_start()`, and
  `truncate_end()` are added.
 
+* `jj duplicate` now accepts `--destination`, `--insert-after` and
+ `--insert-before` options to customize the location of the duplicated
+ revisions.
+
 ### Fixed bugs
 
 * Error on `trunk()` revset resolution is now handled gracefully.

cli/src/commands/duplicate.rs

@@ -13,12 +13,18 @@
 // limitations under the License.
 
 use std::io::Write;
+use std::rc::Rc;
 
-use indexmap::IndexMap;
+use clap::ArgGroup;
 use itertools::Itertools;
 use jj_lib::backend::CommitId;
-use jj_lib::commit::Commit;
+use jj_lib::commit::CommitIteratorExt;
+use jj_lib::repo::ReadonlyRepo;
 use jj_lib::repo::Repo;
+use jj_lib::revset::RevsetExpression;
+use jj_lib::rewrite::duplicate_commits;
+use jj_lib::rewrite::DuplicateCommitsDestination;
+use jj_lib::rewrite::DuplicateCommitsResult;
 use tracing::instrument;
 
 use crate::cli_util::short_commit_hash;
@@ -30,13 +36,36 @@ use crate::ui::Ui;
 
 /// Create a new change with the same content as an existing one
 #[derive(clap::Args, Clone, Debug)]
+#[command(group(ArgGroup::new("target").args(&["destination", "insert_after", "insert_before"]).multiple(true)))]
 pub(crate) struct DuplicateArgs {
  /// The revision(s) to duplicate
  #[arg(default_value = "@")]
  revisions: Vec<RevisionArg>,
  /// Ignored (but lets you pass `-r` for consistency with other commands)
  #[arg(short = 'r', hide = true, action = clap::ArgAction::Count)]
  unused_revision: u8,
+ /// The revision(s) to duplicate onto (can be repeated to create a merge
+ /// commit)
+ #[arg(long, short)]
+ destination: Vec<RevisionArg>,
+ /// The revision(s) to insert after (can be repeated to create a merge
+ /// commit)
+ #[arg(
+ long,
+ short = 'A',
+ visible_alias = "after",
+ conflicts_with = "destination"
+ )]
+ insert_after: Vec<RevisionArg>,
+ /// The revision(s) to insert before (can be repeated to create a merge
+ /// commit)
+ #[arg(
+ long,
+ short = 'B',
+ visible_alias = "before",
+ conflicts_with = "destination"
+ )]
+ insert_before: Vec<RevisionArg>,
 }
 
 #[instrument(skip_all)]
@@ -57,37 +86,166 @@ pub(crate) fn cmd_duplicate(
  if to_duplicate.last() == Some(workspace_command.repo().store().root_commit_id()) {
  return Err(user_error("Cannot duplicate the root commit"));
  }
- let mut duplicated_old_to_new: IndexMap<&CommitId, Commit> = IndexMap::new();
 
- let mut tx = workspace_command.start_transaction();
- let base_repo = tx.base_repo().clone();
- let store = base_repo.store();
- let mut_repo = tx.repo_mut();
+ let parent_commit_ids: Vec<CommitId>;
+ let children_commit_ids: Vec<CommitId>;
 
- for original_commit_id in to_duplicate.iter().rev() {
- // Topological order ensures that any parents of `original_commit` are
- // either not in `to_duplicate` or were already duplicated.
- let original_commit = store.get_commit(original_commit_id)?;
- let new_parents = original_commit
- .parent_ids()
+ if !args.insert_before.is_empty() && !args.insert_after.is_empty() {
+ let parent_commits = workspace_command
+ .resolve_some_revsets_default_single(ui, &args.insert_after)?
+ .into_iter()
+ .collect_vec();
+ parent_commit_ids = parent_commits.iter().ids().cloned().collect();
+ let children_commits = workspace_command
+ .resolve_some_revsets_default_single(ui, &args.insert_before)?
+ .into_iter()
+ .collect_vec();
+ children_commit_ids = children_commits.iter().ids().cloned().collect();
+ workspace_command.check_rewritable(&children_commit_ids)?;
+ let children_expression = RevsetExpression::commits(children_commit_ids.clone());
+ let parents_expression = RevsetExpression::commits(parent_commit_ids.clone());
+ ensure_no_commit_loop(
+ workspace_command.repo(),
+ &children_expression,
+ &parents_expression,
+ )?;
+ } else if !args.insert_before.is_empty() {
+ let children_commits = workspace_command
+ .resolve_some_revsets_default_single(ui, &args.insert_before)?
+ .into_iter()
+ .collect_vec();
+ children_commit_ids = children_commits.iter().ids().cloned().collect();
+ workspace_command.check_rewritable(&children_commit_ids)?;
+ let children_expression = RevsetExpression::commits(children_commit_ids.clone());
+ let parents_expression = children_expression.parents();
+ ensure_no_commit_loop(
+ workspace_command.repo(),
+ &children_expression,
+ &parents_expression,
+ )?;
+ // Manually collect the parent commit IDs to preserve the order of parents.
+ parent_commit_ids = children_commits
+ .iter()
+ .flat_map(|commit| commit.parent_ids())
+ .unique()
+ .cloned()
+ .collect_vec();
+ } else if !args.insert_after.is_empty() {
+ let parent_commits = workspace_command
+ .resolve_some_revsets_default_single(ui, &args.insert_after)?
+ .into_iter()
+ .collect_vec();
+ parent_commit_ids = parent_commits.iter().ids().cloned().collect();
+ let parents_expression = RevsetExpression::commits(parent_commit_ids.clone());
+ let children_expression = parents_expression.children();
+ children_commit_ids = children_expression
+ .clone()
+ .evaluate_programmatic(workspace_command.repo().as_ref())
+ .map_err(|err| err.expect_backend_error())?
  .iter()
- .map(|id| duplicated_old_to_new.get(id).map_or(id, |c| c.id()).clone())
- .collect();
- let new_commit = mut_repo
- .rewrite_commit(command.settings(), &original_commit)
- .generate_new_change_id()
- .set_parents(new_parents)
- .write()?;
- duplicated_old_to_new.insert(original_commit_id, new_commit);
+ .try_collect()?;
+ workspace_command.check_rewritable(&children_commit_ids)?;
+ ensure_no_commit_loop(
+ workspace_command.repo(),
+ &children_expression,
+ &parents_expression,
+ )?;
+ } else if !args.destination.is_empty() {
+ let parent_commits = workspace_command
+ .resolve_some_revsets_default_single(ui, &args.destination)?
+ .into_iter()
+ .collect_vec();
+ parent_commit_ids = parent_commits.iter().ids().cloned().collect();
+ children_commit_ids = vec![];
+ } else {
+ parent_commit_ids = vec![];
+ children_commit_ids = vec![];
+ };
+
+ let mut tx = workspace_command.start_transaction();
+
+ if !parent_commit_ids.is_empty() {
+ for commit_id in &to_duplicate {
+ for parent_commit_id in &parent_commit_ids {
+ if tx.repo().index().is_ancestor(commit_id, parent_commit_id) {
+ writeln!(
+ ui.warning_default(),
+ "Duplicating commit {} as a descendant of itself",
+ short_commit_hash(commit_id)
+ )?;
+ break;
+ }
+ }
+ }
+
+ for commit_id in &to_duplicate {
+ for child_commit_id in &children_commit_ids {
+ if tx.repo().index().is_ancestor(child_commit_id, commit_id) {
+ writeln!(
+ ui.warning_default(),
+ "Duplicating commit {} as an ancestor of itself",
+ short_commit_hash(commit_id)
+ )?;
+ break;
+ }
+ }
+ }
  }
 
+ let num_to_duplicate = to_duplicate.len();
+ let DuplicateCommitsResult {
+ duplicated_commits,
+ num_rebased,
+ } = duplicate_commits(
+ command.settings(),
+ tx.repo_mut(),
+ to_duplicate,
+ if parent_commit_ids.is_empty() {
+ DuplicateCommitsDestination::Parents
+ } else {
+ DuplicateCommitsDestination::Destination {
+ parent_commit_ids,
+ children_commit_ids,
+ }
+ },
+ )?;
+
  if let Some(mut formatter) = ui.status_formatter() {
- for (old_id, new_commit) in &duplicated_old_to_new {
+ for (old_id, new_commit) in &duplicated_commits {
  write!(formatter, "Duplicated {} as ", short_commit_hash(old_id))?;
  tx.write_commit_summary(formatter.as_mut(), new_commit)?;
  writeln!(formatter)?;
  }
+ if num_rebased > 0 {
+ writeln!(
+ ui.status(),
+ "Rebased {num_rebased} commits onto duplicated commits"
+ )?;
+ }
+ }
+ tx.finish(ui, format!("duplicate {num_to_duplicate} commit(s)"))?;
+ Ok(())
+}
+
+/// Ensure that there is no possible cycle between the potential children and
+/// parents of the duplicated commits.
+fn ensure_no_commit_loop(
+ repo: &ReadonlyRepo,
+ children_expression: &Rc<RevsetExpression>,
+ parents_expression: &Rc<RevsetExpression>,
+) -> Result<(), CommandError> {
+ if let Some(commit_id) = children_expression
+ .dag_range_to(parents_expression)
+ .evaluate_programmatic(repo)?
+ .iter()
+ .next()
+ {
+ let commit_id = commit_id?;
+ return Err(user_error(format!(
+ "Refusing to create a loop: commit {} would be both an ancestor and a descendant of \
+ the duplicated commits",
+ short_commit_hash(&commit_id),
+ )));
  }
- tx.finish(ui, format!("duplicate {} commit(s)", to_duplicate.len()))?;
  Ok(())
 }

cli/tests/cli-reference@.md.snap

@@ -689,14 +689,20 @@ See `jj restore` if you want to move entire files from one revision to another.
 
 Create a new change with the same content as an existing one
 
-**Usage:** `jj duplicate [REVISIONS]...`
+**Usage:** `jj duplicate [OPTIONS] [REVISIONS]...`
 
 ###### **Arguments:**
 
 * `<REVISIONS>` — The revision(s) to duplicate
 
  Default value: `@`
 
+###### **Options:**
+
+* `-d`, `--destination <DESTINATION>` — The revision(s) to duplicate onto (can be repeated to create a merge commit)
+* `-A`, `--insert-after <INSERT_AFTER>` — The revision(s) to insert after (can be repeated to create a merge commit)
+* `-B`, `--insert-before <INSERT_BEFORE>` — The revision(s) to insert before (can be repeated to create a merge commit)
+
 
 
 ## `jj edit`