// Copyright 2020-2023 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::HashMap;use std::collections::HashSet;use std::future;use std::io;use std::io::Write as _;use std::iter;use std::sync::Arc; use clap::ArgGroup;use clap_complete::ArgValueCandidates;use clap_complete::ArgValueCompleter;use futures::StreamExt as _;use futures::TryStreamExt as _;use futures::future::try_join_all;use indexmap::IndexSet;use itertools::Itertools as _;use jj_lib::backend::CommitId;use jj_lib::config::ConfigGetResultExt as _;use jj_lib::git;use jj_lib::git::GitPushOptions;use jj_lib::git::GitPushRefTargets;use jj_lib::git::GitSettings;use jj_lib::index::IndexResult;use jj_lib::merge::Diff;use jj_lib::op_store::RefTarget;use jj_lib::operation::Operation;use jj_lib::ref_name::RefName;use jj_lib::ref_name::RefNameBuf;use jj_lib::ref_name::RemoteName;use jj_lib::ref_name::RemoteNameBuf;use jj_lib::ref_name::RemoteRefSymbol;use jj_lib::refs::LocalAndRemoteRef;use jj_lib::refs::RefPushAction;use jj_lib::refs::classify_ref_push_action;use jj_lib::repo::Repo;use jj_lib::revset::RemoteRefSymbolExpression;use jj_lib::revset::RevsetExpression;use jj_lib::revset::UserRevsetExpression;use jj_lib::rewrite::CommitRewriter;use jj_lib::signing::SignBehavior;use jj_lib::str_util::StringExpression;use jj_lib::view::View; use crate::cli_util::CommandHelper;use crate::cli_util::RevisionArg;use crate::cli_util::WorkspaceCommandHelper;use crate::cli_util::WorkspaceCommandTransaction;use crate::cli_util::has_tracked_remote_bookmarks;use crate::cli_util::short_change_hash;use crate::cli_util::short_commit_hash;use crate::command_error::CommandError;use crate::command_error::cli_error;use crate::command_error::cli_error_with_message;use crate::command_error::user_error;use crate::command_error::user_error_with_message;use crate::commands::git::get_single_remote;use crate::complete;use crate::formatter::Formatter;use crate::git_util::GitSubprocessUi;use crate::git_util::print_push_stats;use crate::progress::ProgressWriter;use crate::revset_util::parse_bookmark_name;use crate::revset_util::parse_union_name_patterns;use crate::ui::Ui; /// Push to a Git remote////// By default, pushes tracking bookmarks pointing to/// `remote_bookmarks(remote=<remote>)..@`. Use `--bookmark` to push specific/// bookmarks. Use `--all` to push all bookmarks. Use `--change` to generate/// bookmark names based on the change IDs of specific commits.////// When pushing a bookmark, the command pushes all commits in the range from/// the remote's current position up to and including the bookmark's target/// commit. Any descendant commits beyond the bookmark are not pushed.////// If the local bookmark has changed from the last fetch, push will update the/// remote bookmark to the new position after passing safety checks. This is/// similar to `git push --force-with-lease` - the remote is updated only if its/// current state matches what Jujutsu last fetched.////// Unlike in Git, the remote to push to is not derived from the tracked remote/// bookmarks. Use `--remote` to select the remote Git repository by name. There/// is no option to push to multiple remotes.////// Before the command actually moves, creates, or deletes a remote bookmark, it/// makes several [safety checks]. If there is a problem, you may need to run/// `jj git fetch --remote <remote name>` and/or resolve some [bookmark/// conflicts].////// [safety checks]:/// https://docs.jj-vcs.dev/latest/bookmarks/#pushing-bookmarks-safety-checks////// [bookmark conflicts]:/// https://docs.jj-vcs.dev/latest/bookmarks/#conflicts #[derive(clap::Args, Clone, Debug)]#[command(group(ArgGroup::new("specific").args(&["bookmark", "change", "revisions", "named"]).multiple(true)))]#[command(group(ArgGroup::new("what").args(&["all", "tracked"]).conflicts_with("specific")))]pub struct GitPushArgs { /// The remote to push to (only named remotes are supported) /// /// This defaults to the `git.push` setting. If that is not configured, and /// if there are multiple remotes, the remote named "origin" will be used. #[arg(long)] #[arg(add = ArgValueCandidates::new(complete::git_remotes))] remote: Option<RemoteNameBuf>, /// Push only this bookmark, or bookmarks matching a pattern (can be /// repeated) /// /// If a bookmark isn't tracking anything yet, the remote bookmark will be /// tracked automatically. /// /// By default, the specified pattern matches bookmark names with glob /// syntax. You can also use other [string pattern syntax]. /// /// [string pattern syntax]: /// https://docs.jj-vcs.dev/latest/revsets/#string-patterns #[arg(long, short, alias = "branch")] #[arg(add = ArgValueCandidates::new(complete::local_bookmarks))] bookmark: Vec<String>, /// Push all bookmarks (including new bookmarks) #[arg(long)] all: bool, /// Push all tracked bookmarks /// /// This usually means that the bookmark was already pushed to or fetched /// from the [relevant remote]. /// /// [relevant remote]: /// https://docs.jj-vcs.dev/latest/bookmarks#remotes-and-tracked-bookmarks #[arg(long)] tracked: bool, /// Push all deleted bookmarks /// /// Only tracked bookmarks can be successfully deleted on the remote. A /// warning will be printed if any untracked bookmarks on the remote /// correspond to missing local bookmarks. #[arg(long, conflicts_with = "specific")] deleted: bool, // TODO: Delete in jj 0.42.0+ /// Allow pushing new bookmarks /// /// Newly-created remote bookmarks will be tracked automatically. #[arg(long, short = 'N', hide = true, conflicts_with = "what")] allow_new: bool, /// Allow pushing commits with empty descriptions #[arg(long)] allow_empty_description: bool, /// Allow pushing commits that are private /// /// The set of private commits can be configured by the /// `git.private-commits` setting. The default is `none()`, meaning all /// commits are eligible to be pushed. #[arg(long)] allow_private: bool, /// Push bookmarks pointing to these commits (can be repeated) #[arg(long = "revision", short, value_name = "REVSETS", alias = "revisions")] // While `-r` will often be used with mutable revisions, immutable revisions // can be useful as parts of revsets or to push special-purpose branches. #[arg(add = ArgValueCompleter::new(complete::revset_expression_all))] revisions: Vec<RevisionArg>, /// Push this commit by creating a bookmark (can be repeated) /// /// The created bookmark will be tracked automatically. Use the /// `templates.git_push_bookmark` setting to customize the generated /// bookmark name. The default is `"push-" ++ change_id.short()`. #[arg(long, short, value_name = "REVSETS")] // I'm guessing that `git push -c` is almost exclusively used with recently // created mutable revisions, even though it can in theory be used with // immutable ones as well. We can change it if the guess turns out to be // wrong. #[arg(add = ArgValueCompleter::new(complete::revset_expression_mutable))] change: Vec<RevisionArg>, /// Specify a new bookmark name and a revision to push under that name, e.g. /// '--named myfeature=@' /// /// Automatically tracks the bookmark if it is new. #[arg(long, value_name = "NAME=REVISION")] #[arg(add = ArgValueCompleter::new(complete::branch_name_equals_any_revision))] named: Vec<String>, /// Only display what will change on the remote #[arg(long)] dry_run: bool, /// Git push options #[arg(long, short)] option: Vec<String>,} fn make_bookmark_term(updates: &[(RefNameBuf, Diff<Option<CommitId>>)]) -> String { match updates { [(name, _)] => format!("bookmark {}", name.as_symbol()), _ => format!( "bookmarks {}", updates.iter().map(|(name, _)| name.as_symbol()).join(", ") ), }} const DEFAULT_REMOTE: &RemoteName = RemoteName::new("origin"); const TX_DESC_PUSH: &str = "push "; #[derive(Clone, Copy, Debug, Eq, PartialEq)]enum BookmarkMoveDirection { Forward, Backward, Sideways,} pub async fn cmd_git_push( ui: &mut Ui, command: &CommandHelper, args: &GitPushArgs,) -> Result<(), CommandError> { if args.allow_new { writeln!( ui.warning_default(), "--allow-new is deprecated, track bookmarks manually or configure \ remotes.<name>.auto-track-bookmarks instead." )?; } let mut workspace_command = command.workspace_helper(ui)?; let default_remote; let remote = if let Some(name) = &args.remote { name } else { default_remote = get_default_push_remote(ui, &workspace_command)?; &default_remote }; let mut tx = workspace_command.start_transaction(); let view = tx.repo().view(); let tx_description; let mut bookmark_updates = vec![]; if args.all { for (name, targets) in view.local_remote_bookmarks(remote) { let allow_new = true; // implied by --all match classify_bookmark_update( name.to_remote_symbol(remote), targets, allow_new, args.deleted, ) { Ok(Some(update)) => bookmark_updates.push((name.to_owned(), update)), Ok(None) => {} Err(reason) => reason.print(ui)?, } } tx_description = format!( "{TX_DESC_PUSH}all bookmarks to git remote {remote}", remote = remote.as_symbol() ); } else if args.tracked { for (name, targets) in view.local_remote_bookmarks(remote) { if !targets.remote_ref.is_tracked() { continue; } let allow_new = false; // doesn't matter match classify_bookmark_update( name.to_remote_symbol(remote), targets, allow_new, args.deleted, ) { Ok(Some(update)) => bookmark_updates.push((name.to_owned(), update)), Ok(None) => {} Err(reason) => reason.print(ui)?, } } tx_description = format!( "{TX_DESC_PUSH}all tracked bookmarks to git remote {remote}", remote = remote.as_symbol() ); } else if args.deleted { for (name, targets) in view.local_remote_bookmarks(remote) { if targets.local_target.is_present() { continue; } let allow_new = false; // doesn't matter let allow_delete = true; match classify_bookmark_update( name.to_remote_symbol(remote), targets, allow_new, allow_delete, ) { Ok(Some(update)) => bookmark_updates.push((name.to_owned(), update)), Ok(None) => {} Err(reason) => reason.print(ui)?, } } tx_description = format!( "{TX_DESC_PUSH}all deleted bookmarks to git remote {remote}", remote = remote.as_symbol() ); } else { let mut seen_bookmarks: HashSet<&RefName> = HashSet::new(); // --change and --named don't move existing bookmarks. If they did, be // careful to not select old state by -r/--revisions and bookmark names. let change_bookmark_names = create_change_bookmarks(ui, &mut tx, &args.change).await?; let named_bookmark_commits = try_join_all(args.named.iter().map(|arg| async { let (name, revision_arg) = parse_named_bookmark(arg)?; let commit = tx .base_workspace_helper() .resolve_single_rev(ui, &revision_arg) .await?; Ok::<_, CommandError>((name, commit)) })) .await?; for (name, commit) in &named_bookmark_commits { ensure_new_bookmark_name(tx.repo(), name)?; tx.repo_mut() .set_local_bookmark_target(name, RefTarget::normal(commit.id().clone())); } let created_bookmarks = change_bookmark_names .iter() .chain(named_bookmark_commits.iter().map(|(name, _)| name)) .map(|name| { let remote_symbol = name.to_remote_symbol(remote); let targets = LocalAndRemoteRef { local_target: tx.repo().view().get_local_bookmark(name), remote_ref: tx.repo().view().get_remote_bookmark(remote_symbol), }; (remote_symbol, targets) }); for (remote_symbol, targets) in created_bookmarks { let name = remote_symbol.name; if !seen_bookmarks.insert(name) { continue; } let allow_new = true; // --change implies creation of remote bookmark let allow_delete = false; // doesn't matter match classify_bookmark_update(remote_symbol, targets, allow_new, allow_delete) { Ok(Some(update)) => bookmark_updates.push((name.to_owned(), update)), Ok(None) => writeln!( ui.status(), "Bookmark {remote_symbol} already matches {name}", name = name.as_symbol() )?, Err(reason) => return Err(reason.into()), } } let view = tx.repo().view(); // TODO: Delete in jj 0.42.0+ let allow_new = args.allow_new || tx.settings().get("git.push-new-bookmarks")?; let bookmarks_by_name = find_bookmarks_to_push(ui, view, &args.bookmark, remote)?; for &(name, targets) in &bookmarks_by_name { if !seen_bookmarks.insert(name) { continue; } let remote_symbol = name.to_remote_symbol(remote); // Override allow_new if the bookmark is not tracked with any remote // already. The user has specified --bookmark, so their intent which // bookmarks to push is clear. let allow_new = allow_new || !has_tracked_remote_bookmarks(tx.repo(), name); let allow_delete = true; // named explicitly, allow delete without --delete match classify_bookmark_update(remote_symbol, targets, allow_new, allow_delete) { Ok(Some(update)) => bookmark_updates.push((name.to_owned(), update)), Ok(None) => writeln!( ui.status(), "Bookmark {remote_symbol} already matches {name}", name = name.as_symbol() )?, Err(reason) => return Err(reason.into()), } } let use_default_revset = args.bookmark.is_empty() && args.change.is_empty() && args.revisions.is_empty() && args.named.is_empty(); let target_revisions = if use_default_revset { find_default_target_revisions(ui, tx.base_workspace_helper(), remote).await? } else { find_bookmarked_revisions(ui, tx.base_workspace_helper(), &args.revisions).await? }; for (name, targets) in tx.base_repo().view().local_remote_bookmarks(remote) { if !matches_local_target(targets, &target_revisions) || !seen_bookmarks.insert(name) { continue; } let allow_delete = false; match classify_bookmark_update( name.to_remote_symbol(remote), targets, allow_new, allow_delete, ) { Ok(Some(update)) => bookmark_updates.push((name.to_owned(), update)), Ok(None) => {} Err(reason) => reason.print(ui)?, } } tx_description = format!( "{TX_DESC_PUSH}{names} to git remote {remote}", names = make_bookmark_term(&bookmark_updates), remote = remote.as_symbol() ); } if bookmark_updates.is_empty() { writeln!(ui.status(), "Nothing changed.")?; return Ok(()); } let to_push_expr = ready_to_push_revset_expression(&tx, remote, &bookmark_updates); validate_commits_ready_to_push(ui, tx.base_workspace_helper(), to_push_expr.clone(), args) .await?; if !args.dry_run && tx.settings().get_bool("git.sign-on-push")? { bookmark_updates = sign_commits_before_push(ui, &mut tx, to_push_expr, bookmark_updates).await?; } if let Some(mut formatter) = ui.status_formatter() { writeln!( formatter, "Changes to push to {remote}:", remote = remote.as_symbol() )?; print_commits_ready_to_push(formatter.as_mut(), tx.repo(), &bookmark_updates)?; } if args.dry_run { writeln!(ui.status(), "Dry-run requested, not pushing.")?; return Ok(()); } let targets = GitPushRefTargets { bookmarks: bookmark_updates, }; let git_settings = GitSettings::from_settings(tx.settings())?; let options = GitPushOptions { extra_args: vec![], remote_push_options: args.option.clone(), }; let push_stats = git::push_refs( tx.repo_mut(), git_settings.to_subprocess_options(), remote, &targets, &mut GitSubprocessUi::new(ui), &options, )?; print_push_stats(ui, &push_stats)?; // TODO: On partial success, locally-created --change/--named bookmarks will // be committed. It's probably better to remove failed local bookmarks. if push_stats.all_ok() || push_stats.some_exported() { tx.finish(ui, tx_description).await?; } if push_stats.all_ok() { Ok(()) } else { Err(user_error("Failed to push some bookmarks")) }} fn ready_to_push_revset_expression( tx: &WorkspaceCommandTransaction, remote: &RemoteName, bookmark_updates: &[(RefNameBuf, Diff<Option<CommitId>>)],) -> Arc<UserRevsetExpression> { let workspace_helper = tx.base_workspace_helper(); let repo = workspace_helper.repo(); let new_heads = bookmark_updates .iter() .filter_map(|(_, update)| update.after.clone()) .collect_vec(); let old_heads = repo .view() .remote_bookmarks(remote) .flat_map(|(_, old_head)| old_head.target.added_ids())Lines 1–500 of 1031. Load more
// Copyright 2020-2023 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::HashMap; use std::collections::HashSet; use std::future; use std::io; use std::io::Write as _; use std::iter; use std::sync::Arc; use clap::ArgGroup; use clap_complete::ArgValueCandidates; use clap_complete::ArgValueCompleter; use futures::StreamExt as _; use futures::TryStreamExt as _; use futures::future::try_join_all; use indexmap::IndexSet; use itertools::Itertools as _; use jj_lib::backend::CommitId; use jj_lib::config::ConfigGetResultExt as _; use jj_lib::git; use jj_lib::git::GitPushOptions; use jj_lib::git::GitPushRefTargets; use jj_lib::git::GitSettings; use jj_lib::index::IndexResult; use jj_lib::merge::Diff; use jj_lib::op_store::RefTarget; use jj_lib::operation::Operation; use jj_lib::ref_name::RefName; use jj_lib::ref_name::RefNameBuf; use jj_lib::ref_name::RemoteName; use jj_lib::ref_name::RemoteNameBuf; use jj_lib::ref_name::RemoteRefSymbol; use jj_lib::refs::LocalAndRemoteRef; use jj_lib::refs::RefPushAction; use jj_lib::refs::classify_ref_push_action; use jj_lib::repo::Repo; use jj_lib::revset::RemoteRefSymbolExpression; use jj_lib::revset::RevsetExpression; use jj_lib::revset::UserRevsetExpression; use jj_lib::rewrite::CommitRewriter; use jj_lib::signing::SignBehavior; use jj_lib::str_util::StringExpression; use jj_lib::view::View; use crate::cli_util::CommandHelper; use crate::cli_util::RevisionArg; use crate::cli_util::WorkspaceCommandHelper; use crate::cli_util::WorkspaceCommandTransaction; use crate::cli_util::has_tracked_remote_bookmarks; use crate::cli_util::short_change_hash; use crate::cli_util::short_commit_hash; use crate::command_error::CommandError; use crate::command_error::cli_error; use crate::command_error::cli_error_with_message; use crate::command_error::user_error; use crate::command_error::user_error_with_message; use crate::commands::git::get_single_remote; use crate::complete; use crate::formatter::Formatter; use crate::git_util::GitSubprocessUi; use crate::git_util::print_push_stats; use crate::progress::ProgressWriter; use crate::revset_util::parse_bookmark_name; use crate::revset_util::parse_union_name_patterns; use crate::ui::Ui; /// Push to a Git remote /// /// By default, pushes tracking bookmarks pointing to /// `remote_bookmarks(remote=<remote>)..@`. Use `--bookmark` to push specific /// bookmarks. Use `--all` to push all bookmarks. Use `--change` to generate /// bookmark names based on the change IDs of specific commits. /// /// When pushing a bookmark, the command pushes all commits in the range from /// the remote's current position up to and including the bookmark's target /// commit. Any descendant commits beyond the bookmark are not pushed. /// /// If the local bookmark has changed from the last fetch, push will update the /// remote bookmark to the new position after passing safety checks. This is /// similar to `git push --force-with-lease` - the remote is updated only if its /// current state matches what Jujutsu last fetched. /// /// Unlike in Git, the remote to push to is not derived from the tracked remote /// bookmarks. Use `--remote` to select the remote Git repository by name. There /// is no option to push to multiple remotes. /// /// Before the command actually moves, creates, or deletes a remote bookmark, it /// makes several [safety checks]. If there is a problem, you may need to run /// `jj git fetch --remote <remote name>` and/or resolve some [bookmark /// conflicts]. /// /// [safety checks]: /// https://docs.jj-vcs.dev/latest/bookmarks/#pushing-bookmarks-safety-checks /// /// [bookmark conflicts]: /// https://docs.jj-vcs.dev/latest/bookmarks/#conflicts #[derive(clap::Args, Clone, Debug)] #[command(group(ArgGroup::new("specific").args(&["bookmark", "change", "revisions", "named"]).multiple(true)))] #[command(group(ArgGroup::new("what").args(&["all", "tracked"]).conflicts_with("specific")))] pub struct GitPushArgs { /// The remote to push to (only named remotes are supported) /// /// This defaults to the `git.push` setting. If that is not configured, and /// if there are multiple remotes, the remote named "origin" will be used. #[arg(long)] #[arg(add = ArgValueCandidates::new(complete::git_remotes))] remote: Option<RemoteNameBuf>, /// Push only this bookmark, or bookmarks matching a pattern (can be /// repeated) /// /// If a bookmark isn't tracking anything yet, the remote bookmark will be /// tracked automatically. /// /// By default, the specified pattern matches bookmark names with glob /// syntax. You can also use other [string pattern syntax]. /// /// [string pattern syntax]: /// https://docs.jj-vcs.dev/latest/revsets/#string-patterns #[arg(long, short, alias = "branch")] #[arg(add = ArgValueCandidates::new(complete::local_bookmarks))] bookmark: Vec<String>, /// Push all bookmarks (including new bookmarks) #[arg(long)] all: bool, /// Push all tracked bookmarks /// /// This usually means that the bookmark was already pushed to or fetched /// from the [relevant remote]. /// /// [relevant remote]: /// https://docs.jj-vcs.dev/latest/bookmarks#remotes-and-tracked-bookmarks #[arg(long)] tracked: bool, /// Push all deleted bookmarks /// /// Only tracked bookmarks can be successfully deleted on the remote. A /// warning will be printed if any untracked bookmarks on the remote /// correspond to missing local bookmarks. #[arg(long, conflicts_with = "specific")] deleted: bool, // TODO: Delete in jj 0.42.0+ /// Allow pushing new bookmarks /// /// Newly-created remote bookmarks will be tracked automatically. #[arg(long, short = 'N', hide = true, conflicts_with = "what")] allow_new: bool, /// Allow pushing commits with empty descriptions #[arg(long)] allow_empty_description: bool, /// Allow pushing commits that are private /// /// The set of private commits can be configured by the /// `git.private-commits` setting. The default is `none()`, meaning all /// commits are eligible to be pushed. #[arg(long)] allow_private: bool, /// Push bookmarks pointing to these commits (can be repeated) #[arg(long = "revision", short, value_name = "REVSETS", alias = "revisions")] // While `-r` will often be used with mutable revisions, immutable revisions // can be useful as parts of revsets or to push special-purpose branches. #[arg(add = ArgValueCompleter::new(complete::revset_expression_all))] revisions: Vec<RevisionArg>, /// Push this commit by creating a bookmark (can be repeated) /// /// The created bookmark will be tracked automatically. Use the /// `templates.git_push_bookmark` setting to customize the generated /// bookmark name. The default is `"push-" ++ change_id.short()`. #[arg(long, short, value_name = "REVSETS")] // I'm guessing that `git push -c` is almost exclusively used with recently // created mutable revisions, even though it can in theory be used with // immutable ones as well. We can change it if the guess turns out to be // wrong. #[arg(add = ArgValueCompleter::new(complete::revset_expression_mutable))] change: Vec<RevisionArg>, /// Specify a new bookmark name and a revision to push under that name, e.g. /// '--named myfeature=@' /// /// Automatically tracks the bookmark if it is new. #[arg(long, value_name = "NAME=REVISION")] #[arg(add = ArgValueCompleter::new(complete::branch_name_equals_any_revision))] named: Vec<String>, /// Only display what will change on the remote #[arg(long)] dry_run: bool, /// Git push options #[arg(long, short)] option: Vec<String>, } fn make_bookmark_term(updates: &[(RefNameBuf, Diff<Option<CommitId>>)]) -> String { match updates { [(name, _)] => format!("bookmark {}", name.as_symbol()), _ => format!( "bookmarks {}", updates.iter().map(|(name, _)| name.as_symbol()).join(", ") ), } } const DEFAULT_REMOTE: &RemoteName = RemoteName::new("origin"); const TX_DESC_PUSH: &str = "push "; #[derive(Clone, Copy, Debug, Eq, PartialEq)] enum BookmarkMoveDirection { Forward, Backward, Sideways, } pub async fn cmd_git_push( ui: &mut Ui, command: &CommandHelper, args: &GitPushArgs, ) -> Result<(), CommandError> { if args.allow_new { writeln!( ui.warning_default(), "--allow-new is deprecated, track bookmarks manually or configure \ remotes.<name>.auto-track-bookmarks instead." )?; } let mut workspace_command = command.workspace_helper(ui)?; let default_remote; let remote = if let Some(name) = &args.remote { name } else { default_remote = get_default_push_remote(ui, &workspace_command)?; &default_remote }; let mut tx = workspace_command.start_transaction(); let view = tx.repo().view(); let tx_description; let mut bookmark_updates = vec![]; if args.all { for (name, targets) in view.local_remote_bookmarks(remote) { let allow_new = true; // implied by --all match classify_bookmark_update( name.to_remote_symbol(remote), targets, allow_new, args.deleted, ) { Ok(Some(update)) => bookmark_updates.push((name.to_owned(), update)), Ok(None) => {} Err(reason) => reason.print(ui)?, } } tx_description = format!( "{TX_DESC_PUSH}all bookmarks to git remote {remote}", remote = remote.as_symbol() ); } else if args.tracked { for (name, targets) in view.local_remote_bookmarks(remote) { if !targets.remote_ref.is_tracked() { continue; } let allow_new = false; // doesn't matter match classify_bookmark_update( name.to_remote_symbol(remote), targets, allow_new, args.deleted, ) { Ok(Some(update)) => bookmark_updates.push((name.to_owned(), update)), Ok(None) => {} Err(reason) => reason.print(ui)?, } } tx_description = format!( "{TX_DESC_PUSH}all tracked bookmarks to git remote {remote}", remote = remote.as_symbol() ); } else if args.deleted { for (name, targets) in view.local_remote_bookmarks(remote) { if targets.local_target.is_present() { continue; } let allow_new = false; // doesn't matter let allow_delete = true; match classify_bookmark_update( name.to_remote_symbol(remote), targets, allow_new, allow_delete, ) { Ok(Some(update)) => bookmark_updates.push((name.to_owned(), update)), Ok(None) => {} Err(reason) => reason.print(ui)?, } } tx_description = format!( "{TX_DESC_PUSH}all deleted bookmarks to git remote {remote}", remote = remote.as_symbol() ); } else { let mut seen_bookmarks: HashSet<&RefName> = HashSet::new(); // --change and --named don't move existing bookmarks. If they did, be // careful to not select old state by -r/--revisions and bookmark names. let change_bookmark_names = create_change_bookmarks(ui, &mut tx, &args.change).await?; let named_bookmark_commits = try_join_all(args.named.iter().map(|arg| async { let (name, revision_arg) = parse_named_bookmark(arg)?; let commit = tx .base_workspace_helper() .resolve_single_rev(ui, &revision_arg) .await?; Ok::<_, CommandError>((name, commit)) })) .await?; for (name, commit) in &named_bookmark_commits { ensure_new_bookmark_name(tx.repo(), name)?; tx.repo_mut() .set_local_bookmark_target(name, RefTarget::normal(commit.id().clone())); } let created_bookmarks = change_bookmark_names .iter() .chain(named_bookmark_commits.iter().map(|(name, _)| name)) .map(|name| { let remote_symbol = name.to_remote_symbol(remote); let targets = LocalAndRemoteRef { local_target: tx.repo().view().get_local_bookmark(name), remote_ref: tx.repo().view().get_remote_bookmark(remote_symbol), }; (remote_symbol, targets) }); for (remote_symbol, targets) in created_bookmarks { let name = remote_symbol.name; if !seen_bookmarks.insert(name) { continue; } let allow_new = true; // --change implies creation of remote bookmark let allow_delete = false; // doesn't matter match classify_bookmark_update(remote_symbol, targets, allow_new, allow_delete) { Ok(Some(update)) => bookmark_updates.push((name.to_owned(), update)), Ok(None) => writeln!( ui.status(), "Bookmark {remote_symbol} already matches {name}", name = name.as_symbol() )?, Err(reason) => return Err(reason.into()), } } let view = tx.repo().view(); // TODO: Delete in jj 0.42.0+ let allow_new = args.allow_new || tx.settings().get("git.push-new-bookmarks")?; let bookmarks_by_name = find_bookmarks_to_push(ui, view, &args.bookmark, remote)?; for &(name, targets) in &bookmarks_by_name { if !seen_bookmarks.insert(name) { continue; } let remote_symbol = name.to_remote_symbol(remote); // Override allow_new if the bookmark is not tracked with any remote // already. The user has specified --bookmark, so their intent which // bookmarks to push is clear. let allow_new = allow_new || !has_tracked_remote_bookmarks(tx.repo(), name); let allow_delete = true; // named explicitly, allow delete without --delete match classify_bookmark_update(remote_symbol, targets, allow_new, allow_delete) { Ok(Some(update)) => bookmark_updates.push((name.to_owned(), update)), Ok(None) => writeln!( ui.status(), "Bookmark {remote_symbol} already matches {name}", name = name.as_symbol() )?, Err(reason) => return Err(reason.into()), } } let use_default_revset = args.bookmark.is_empty() && args.change.is_empty() && args.revisions.is_empty() && args.named.is_empty(); let target_revisions = if use_default_revset { find_default_target_revisions(ui, tx.base_workspace_helper(), remote).await? } else { find_bookmarked_revisions(ui, tx.base_workspace_helper(), &args.revisions).await? }; for (name, targets) in tx.base_repo().view().local_remote_bookmarks(remote) { if !matches_local_target(targets, &target_revisions) || !seen_bookmarks.insert(name) { continue; } let allow_delete = false; match classify_bookmark_update( name.to_remote_symbol(remote), targets, allow_new, allow_delete, ) { Ok(Some(update)) => bookmark_updates.push((name.to_owned(), update)), Ok(None) => {} Err(reason) => reason.print(ui)?, } } tx_description = format!( "{TX_DESC_PUSH}{names} to git remote {remote}", names = make_bookmark_term(&bookmark_updates), remote = remote.as_symbol() ); } if bookmark_updates.is_empty() { writeln!(ui.status(), "Nothing changed.")?; return Ok(()); } let to_push_expr = ready_to_push_revset_expression(&tx, remote, &bookmark_updates); validate_commits_ready_to_push(ui, tx.base_workspace_helper(), to_push_expr.clone(), args) .await?; if !args.dry_run && tx.settings().get_bool("git.sign-on-push")? { bookmark_updates = sign_commits_before_push(ui, &mut tx, to_push_expr, bookmark_updates).await?; } if let Some(mut formatter) = ui.status_formatter() { writeln!( formatter, "Changes to push to {remote}:", remote = remote.as_symbol() )?; print_commits_ready_to_push(formatter.as_mut(), tx.repo(), &bookmark_updates)?; } if args.dry_run { writeln!(ui.status(), "Dry-run requested, not pushing.")?; return Ok(()); } let targets = GitPushRefTargets { bookmarks: bookmark_updates, }; let git_settings = GitSettings::from_settings(tx.settings())?; let options = GitPushOptions { extra_args: vec![], remote_push_options: args.option.clone(), }; let push_stats = git::push_refs( tx.repo_mut(), git_settings.to_subprocess_options(), remote, &targets, &mut GitSubprocessUi::new(ui), &options, )?; print_push_stats(ui, &push_stats)?; // TODO: On partial success, locally-created --change/--named bookmarks will // be committed. It's probably better to remove failed local bookmarks. if push_stats.all_ok() || push_stats.some_exported() { tx.finish(ui, tx_description).await?; } if push_stats.all_ok() { Ok(()) } else { Err(user_error("Failed to push some bookmarks")) } } fn ready_to_push_revset_expression( tx: &WorkspaceCommandTransaction, remote: &RemoteName, bookmark_updates: &[(RefNameBuf, Diff<Option<CommitId>>)], ) -> Arc<UserRevsetExpression> { let workspace_helper = tx.base_workspace_helper(); let repo = workspace_helper.repo(); let new_heads = bookmark_updates .iter() .filter_map(|(_, update)| update.after.clone()) .collect_vec(); let old_heads = repo .view() .remote_bookmarks(remote) .flat_map(|(_, old_head)| old_head.target.added_ids())