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::commit::Commit;
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::ResolvedRevsetExpression;
use jj_lib::revset::RevsetContainingFn;
use jj_lib::revset::RevsetEvaluationError;
use jj_lib::revset::RevsetExpression;
use jj_lib::revset::RevsetStreamExt as _;
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::has_tracked_remote_tags;
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;
#[derive(clap::Args, Clone, Debug)]
#[command(group(ArgGroup::new("specific").multiple(true)))]
#[command(group(ArgGroup::new("what").conflicts_with("specific")))]
pub struct GitPushArgs {
#[arg(long)]
#[arg(add = ArgValueCandidates::new(complete::git_remotes))]
remote: Option<RemoteNameBuf>,
#[arg(long, short, alias = "branch", group = "specific")]
#[arg(add = ArgValueCandidates::new(complete::local_bookmarks))]
bookmark: Vec<String>,
#[arg(long, short, group = "specific")]
#[arg(hide = true)] tag: Vec<String>,
#[arg(long, group = "what")]
all: bool,
#[arg(long, group = "what")]
tracked: bool,
#[arg(long, conflicts_with = "specific")]
deleted: bool,
#[arg(long, short = 'N', hide = true, conflicts_with = "what")]
allow_new: bool,
#[arg(long)]
allow_empty_description: bool,
#[arg(long)]
allow_private: bool,
#[arg(
long = "revision",
short,
group = "specific",
value_name = "REVSETS",
alias = "revisions"
)]
#[arg(add = ArgValueCompleter::new(complete::revset_expression_all))]
revisions: Vec<RevisionArg>,
#[arg(long, short, group = "specific", value_name = "REVSETS")]
#[arg(add = ArgValueCompleter::new(complete::revset_expression_mutable))]
change: Vec<RevisionArg>,
#[arg(long, group = "specific", value_name = "NAME=REVISION")]
#[arg(add = ArgValueCompleter::new(complete::branch_name_equals_any_revision))]
named: Vec<String>,
#[arg(long)]
dry_run: bool,
#[arg(long, short)]
option: Vec<String>,
}
fn make_updates_term(ref_updates: &GitPushRefTargets) -> String {
let kind_updates = [
("bookmark", "bookmarks", &ref_updates.bookmarks),
("tag", "tags", &ref_updates.tags),
];
kind_updates
.into_iter()
.filter_map(|(kind, kinds, refs)| match &**refs {
[] => None,
[(name, _)] => Some(format!("{kind} {}", name.as_symbol())),
_ => Some(format!(
"{kinds} {}",
refs.iter().map(|(name, _)| name.as_symbol()).join(", ")
)),
})
.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 ref_updates = GitPushRefTargets::default();
if args.all {
let mut commits_validator =
CommitsValidator::new(ui, tx.base_workspace_helper(), remote, args)?;
for (name, targets) in view.local_remote_bookmarks(remote) {
let remote_symbol = name.to_remote_symbol(remote);
let allow_new = true; match classify_bookmark_update(remote_symbol, targets, allow_new, args.deleted) {
Ok(Some(update)) => match commits_validator.validate_update(&update).await? {
Ok(()) => ref_updates.bookmarks.push((name.to_owned(), update)),
Err(reason) => reason.print_bookmark(ui, tx.base_workspace_helper(), name)?,
},
Ok(None) => {}
Err(reason) => reason.print(ui)?,
}
}
for (name, targets) in view.local_remote_tags(remote) {
let remote_symbol = name.to_remote_symbol(remote);
let allow_new = false;
match classify_tag_update(remote_symbol, targets, allow_new, args.deleted) {
Ok(Some(update)) => match commits_validator.validate_update(&update).await? {
Ok(()) => ref_updates.tags.push((name.to_owned(), update)),
Err(reason) => reason.print_tag(ui, tx.base_workspace_helper(), name)?,
},
Ok(None) => {}
Err(reason) => reason.print(ui)?,
}
}
tx_description = format!(
"{TX_DESC_PUSH}all bookmarks/tags to git remote {remote}",
remote = remote.as_symbol()
);
} else if args.tracked {
let mut commits_validator =
CommitsValidator::new(ui, tx.base_workspace_helper(), remote, args)?;
for (name, targets) in view.local_remote_bookmarks(remote) {
if !targets.remote_ref.is_tracked() {
continue;
}
let remote_symbol = name.to_remote_symbol(remote);
let allow_new = false; match classify_bookmark_update(remote_symbol, targets, allow_new, args.deleted) {
Ok(Some(update)) => match commits_validator.validate_update(&update).await? {
Ok(()) => ref_updates.bookmarks.push((name.to_owned(), update)),
Err(reason) => reason.print_bookmark(ui, tx.base_workspace_helper(), name)?,
},
Ok(None) => {}
Err(reason) => reason.print(ui)?,
}
}
for (name, targets) in view.local_remote_tags(remote) {
if !targets.remote_ref.is_tracked() {
continue;
}
let remote_symbol = name.to_remote_symbol(remote);
let allow_new = false; match classify_tag_update(remote_symbol, targets, allow_new, args.deleted) {
Ok(Some(update)) => match commits_validator.validate_update(&update).await? {
Ok(()) => ref_updates.tags.push((name.to_owned(), update)),
Err(reason) => reason.print_tag(ui, tx.base_workspace_helper(), name)?,
},
Ok(None) => {}
Err(reason) => reason.print(ui)?,
}
}
tx_description = format!(
"{TX_DESC_PUSH}all tracked bookmarks/tags to git remote {remote}",
remote = remote.as_symbol()
);
} else if args.deleted {
let mut commits_validator =
CommitsValidator::new(ui, tx.base_workspace_helper(), remote, args)?;
for (name, targets) in view.local_remote_bookmarks(remote) {
if targets.local_target.is_present() {
continue;
}
let remote_symbol = name.to_remote_symbol(remote);
let allow_new = false; let allow_delete = true;
match classify_bookmark_update(remote_symbol, targets, allow_new, allow_delete) {
Ok(Some(update)) => match commits_validator.validate_update(&update).await? {
Ok(()) => ref_updates.bookmarks.push((name.to_owned(), update)),
Err(reason) => reason.print_bookmark(ui, tx.base_workspace_helper(), name)?,
},
Ok(None) => {}
Err(reason) => reason.print(ui)?,
}
}
for (name, targets) in view.local_remote_tags(remote) {
if targets.local_target.is_present() {
continue;
}
let remote_symbol = name.to_remote_symbol(remote);
let allow_new = false; let allow_delete = true;
match classify_tag_update(remote_symbol, targets, allow_new, allow_delete) {
Ok(Some(update)) => match commits_validator.validate_update(&update).await? {
Ok(()) => ref_updates.tags.push((name.to_owned(), update)),
Err(reason) => reason.print_tag(ui, tx.base_workspace_helper(), name)?,
},
Ok(None) => {}
Err(reason) => reason.print(ui)?,
}
}
tx_description = format!(
"{TX_DESC_PUSH}all deleted bookmarks/tags to git remote {remote}",
remote = remote.as_symbol()
);
} else {
let mut seen_bookmarks: HashSet<&RefName> = HashSet::new();
let mut seen_tags: HashSet<&RefName> = HashSet::new();
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; let allow_delete = false; match classify_bookmark_update(remote_symbol, targets, allow_new, allow_delete) {
Ok(Some(update)) => ref_updates.bookmarks.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();
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);
let allow_new = allow_new || !has_tracked_remote_bookmarks(tx.repo(), name);
let allow_delete = true; match classify_bookmark_update(remote_symbol, targets, allow_new, allow_delete) {
Ok(Some(update)) => ref_updates.bookmarks.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 tags_by_name = find_tags_to_push(ui, view, &args.tag, remote)?;
for &(name, targets) in &tags_by_name {
if !seen_tags.insert(name) {
continue;
}
let remote_symbol = name.to_remote_symbol(remote);
let allow_new = !has_tracked_remote_tags(tx.repo(), name);
let allow_delete = true;
match classify_tag_update(remote_symbol, targets, allow_new, allow_delete) {
Ok(Some(update)) => ref_updates.tags.push((name.to_owned(), update)),
Ok(None) => writeln!(
ui.status(),
"Tag {remote_symbol} already matches {name}",
name = name.as_symbol()
)?,
Err(reason) => return Err(reason.into()),
}
}
let mut commits_validator =
CommitsValidator::new(ui, tx.base_workspace_helper(), remote, args)?;
commits_validator
.validate_updates(&ref_updates)
.await?
.map_err(|reason| reason.to_command_error(tx.base_workspace_helper()))?;
let use_default_revset = args.bookmark.is_empty()
&& args.tag.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_target_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 remote_symbol = name.to_remote_symbol(remote);
let allow_delete = false;
match classify_bookmark_update(remote_symbol, targets, allow_new, allow_delete) {
Ok(Some(update)) => match commits_validator.validate_update(&update).await? {
Ok(()) => ref_updates.bookmarks.push((name.to_owned(), update)),
Err(reason) => reason.print_bookmark(ui, tx.base_workspace_helper(), name)?,
},
Ok(None) => {}
Err(reason) => reason.print(ui)?,
}
}
for (name, targets) in tx.base_repo().view().local_remote_tags(remote) {
if !matches_local_target(targets, &target_revisions) || !seen_tags.insert(name) {
continue;
}
let remote_symbol = name.to_remote_symbol(remote);
let allow_delete = false;
match classify_tag_update(remote_symbol, targets, allow_new, allow_delete) {
Ok(Some(update)) => match commits_validator.validate_update(&update).await? {
Ok(()) => ref_updates.tags.push((name.to_owned(), update)),
Err(reason) => reason.print_tag(ui, tx.base_workspace_helper(), name)?,
},
Ok(None) => {}
Err(reason) => reason.print(ui)?,
}
}
tx_description = format!(
"{TX_DESC_PUSH}{names} to git remote {remote}",
names = make_updates_term(&ref_updates),
remote = remote.as_symbol()
);
}
if ref_updates.bookmarks.is_empty() && ref_updates.tags.is_empty() {
writeln!(ui.status(), "Nothing changed.")?;
return Ok(());
}
if !args.dry_run && tx.settings().get_bool("git.sign-on-push")? {
let to_push_expr = ready_to_push_revset_expression(&tx, remote, &ref_updates);
ref_updates = sign_commits_before_push(ui, &mut tx, to_push_expr, ref_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(), &ref_updates)?;
}
if args.dry_run {
writeln!(ui.status(), "Dry-run requested, not pushing.")?;
return Ok(());
}
let git_settings = GitSettings::from_settings(tx.settings())?;
let options = GitPushOptions {
remote_push_options: args.option.clone(),
};
let push_stats = git::push_refs(
tx.repo_mut(),
git_settings.to_subprocess_options(),
remote,
&ref_updates,
&mut GitSubprocessUi::new(ui),
&options,
)?;
print_push_stats(ui, &push_stats)?;
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"))
}
}
#[derive(Clone, Debug)]
struct RejectedCommitReason {
commit: Commit,
message: String,
hint: Option<String>,
}
impl RejectedCommitReason {
fn print_bookmark(
&self,
ui: &Ui,
workspace_helper: &WorkspaceCommandHelper,
name: &RefName,
) -> io::Result<()> {
self.print_inner(ui, workspace_helper, "bookmark", name)
}
fn print_tag(
&self,
ui: &Ui,
workspace_helper: &WorkspaceCommandHelper,
name: &RefName,
) -> io::Result<()> {
self.print_inner(ui, workspace_helper, "tag", name)
}
fn print_inner(
&self,
ui: &Ui,
workspace_helper: &WorkspaceCommandHelper,
kind: &str,
name: &RefName,
) -> io::Result<()> {
writeln!(
ui.warning_default(),
"Won't push {kind} {name}: commit {id} {message}",
name = name.as_symbol(),
id = short_commit_hash(self.commit.id()),
message = self.message,
)?;
if let Some(mut formatter) = ui.status_formatter() {
write!(formatter, " ")?;
workspace_helper.write_commit_summary(formatter.as_mut(), &self.commit)?;
writeln!(formatter)?;
}
if let Some(hint) = &self.hint {
writeln!(ui.hint_default(), "{hint}")?;
}
Ok(())
}
fn to_command_error(&self, workspace_helper: &WorkspaceCommandHelper) -> CommandError {
let mut error = user_error(format!(
"Won't push commit {id} since it {message}",
id = short_commit_hash(self.commit.id()),
message = self.message,
));
error.add_formatted_hint_with(|formatter| {
write!(formatter, "Rejected commit: ")?;
workspace_helper.write_commit_summary(formatter, &self.commit)?;
Ok(())
});
error.extend_hints(self.hint.clone());
error
}
}
struct CommitsValidator<'repo> {
repo: &'repo dyn Repo,
known_heads: Vec<CommitId>,
immutable_heads: Arc<ResolvedRevsetExpression>,
private_commits: Option<(String, Box<RevsetContainingFn<'repo>>)>,
allow_empty_description: bool,
}
impl<'repo> CommitsValidator<'repo> {
fn new(
ui: &Ui,
workspace_helper: &'repo WorkspaceCommandHelper,
remote: &RemoteName,
args: &GitPushArgs,
) -> Result<Self, CommandError> {
let repo = workspace_helper.repo().as_ref();
let known_heads = repo
.view()
.remote_bookmarks(remote)
.flat_map(|(_, old_head)| old_head.target.added_ids())
.cloned()
.collect();
let immutable_heads = workspace_helper
.attach_revset_evaluator(workspace_helper.env().immutable_heads_expression().clone())
.resolve()?;
let private_commits = if !args.allow_private {
let settings = workspace_helper.settings();
let revset_str = settings.get_string("git.private-commits")?;
let is_private = workspace_helper
.parse_revset(ui, &RevisionArg::from(revset_str.clone()))?
.evaluate()?
.containing_fn();
Some((revset_str, is_private))
} else {
None
};
Ok(Self {
repo,
known_heads,
immutable_heads,
private_commits,
allow_empty_description: args.allow_empty_description,
})
}
async fn validate_update(
&mut self,
update: &Diff<Option<CommitId>>,
) -> Result<Result<(), RejectedCommitReason>, RevsetEvaluationError> {
self.validate_commits(update.after.as_slice()).await
}
async fn validate_updates(
&mut self,
updates: &GitPushRefTargets,
) -> Result<Result<(), RejectedCommitReason>, RevsetEvaluationError> {
let new_heads = itertools::chain(&updates.bookmarks, &updates.tags)
.filter_map(|(_, update)| update.after.clone())
.collect_vec();
self.validate_commits(&new_heads).await
}
async fn validate_commits(
&mut self,
new_heads: &[CommitId],
) -> Result<Result<(), RejectedCommitReason>, RevsetEvaluationError> {
let new_commits = RevsetExpression::commits(self.known_heads.clone())
.union(&self.immutable_heads)
.range(&RevsetExpression::commits(new_heads.to_vec()));
let mut commit_stream = new_commits
.evaluate(self.repo)?
.stream()
.commits(self.repo.store());
while let Some(commit) = commit_stream.try_next().await? {
let mut reasons = vec![];
let mut hint = None;
if commit.description().is_empty() && !self.allow_empty_description {
reasons.push("has no description");
}
if commit.author().name.is_empty()
|| commit.author().email.is_empty()
|| commit.committer().name.is_empty()
|| commit.committer().email.is_empty()
{
reasons.push("has no author and/or committer set");
}
if commit.has_conflict() {
reasons.push("has conflicts");
}
if let Some((revset_str, is_private)) = &self.private_commits
&& is_private(commit.id())?
{
reasons.push("is private");
hint = Some(format!("Configured git.private-commits: '{revset_str}'"));
}
if reasons.is_empty() {
continue;
}
return Ok(Err(RejectedCommitReason {
commit,
message: reasons.join(" and "),
hint,
}));
}
self.known_heads.extend(new_heads.iter().cloned());
Ok(Ok(()))
}
}
fn ready_to_push_revset_expression(
tx: &WorkspaceCommandTransaction,
remote: &RemoteName,
ref_updates: &GitPushRefTargets,
) -> Arc<UserRevsetExpression> {
let workspace_helper = tx.base_workspace_helper();
let repo = workspace_helper.repo();
let new_heads = itertools::chain(&ref_updates.bookmarks, &ref_updates.tags)
.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())
.cloned()
.collect_vec();
RevsetExpression::commits(old_heads)
.union(workspace_helper.env().immutable_heads_expression())
.range(&RevsetExpression::commits(new_heads))
}
async fn sign_commits_before_push(
ui: &Ui,
tx: &mut WorkspaceCommandTransaction<'_>,
commits_to_push: Arc<UserRevsetExpression>,
ref_updates: GitPushRefTargets,
) -> Result<GitPushRefTargets, CommandError> {
let mut sign_settings = tx.settings().sign_settings();
sign_settings.behavior = SignBehavior::Own;
let commit_ids: IndexSet<CommitId> = tx
.base_workspace_helper()
.attach_revset_evaluator(commits_to_push)
.evaluate_to_commits()?
.try_filter(|commit| {
future::ready(!commit.is_signed() && sign_settings.should_sign(commit.store_commit()))
})
.map_ok(|commit| commit.id().clone())
.try_collect()
.await?;
if commit_ids.is_empty() {
return Ok(ref_updates);
}
let mut old_to_new_commits_map: HashMap<CommitId, CommitId> = HashMap::new();
let mut num_rebased_descendants = 0;
{
let mut progress_writer = ProgressWriter::new(ui, "Signing");
tx.repo_mut()
.transform_descendants(
commit_ids.iter().cloned().collect_vec(),
async |rewriter: CommitRewriter<'_>| {
let old_commit = rewriter.old_commit();
let old_commit_id = old_commit.id().clone();
if let Some(writer) = &mut progress_writer {
writer
.display(&short_change_hash(old_commit.change_id()))
.ok();
}
if commit_ids.contains(&old_commit_id) {
let commit = rewriter
.reparent()
.set_sign_behavior(sign_settings.behavior)
.write()
.await?;
old_to_new_commits_map.insert(old_commit_id, commit.id().clone());
} else {
num_rebased_descendants += 1;
let commit = rewriter.reparent().write().await?;
old_to_new_commits_map.insert(old_commit_id, commit.id().clone());
}
Ok(())
},
)
.await?;
}
let map_to_new_commits = |updates: Vec<(RefNameBuf, Diff<Option<CommitId>>)>| {
updates
.into_iter()
.map(|(name, Diff { before, after })| {
let after = after.map(|id| old_to_new_commits_map.get(&id).cloned().unwrap_or(id));
(name, Diff { before, after })
})
.collect()
};
let ref_updates = GitPushRefTargets {
bookmarks: map_to_new_commits(ref_updates.bookmarks),
tags: map_to_new_commits(ref_updates.tags),
};
if let Some(mut formatter) = ui.status_formatter() {
let num_updated_signatures = commit_ids.len();
writeln!(
formatter,
"Updated signatures of {num_updated_signatures} commits"
)?;
if num_rebased_descendants > 0 {
writeln!(
formatter,
"Rebased {num_rebased_descendants} descendant commits"
)?;
}
}
Ok(ref_updates)
}
fn print_commits_ready_to_push(
formatter: &mut dyn Formatter,
repo: &dyn Repo,
ref_updates: &GitPushRefTargets,
) -> Result<(), CommandError> {
let to_direction =
|old_target: &CommitId, new_target: &CommitId| -> IndexResult<BookmarkMoveDirection> {
assert_ne!(old_target, new_target);
if repo.index().is_ancestor(old_target, new_target)? {
Ok(BookmarkMoveDirection::Forward)
} else if repo.index().is_ancestor(new_target, old_target)? {
Ok(BookmarkMoveDirection::Backward)
} else {
Ok(BookmarkMoveDirection::Sideways)
}
};
let describe_update = |update: &Diff<Option<CommitId>>| -> IndexResult<String> {
let desc = match (&update.before, &update.after) {
(Some(old_target), Some(new_target)) => {
let old = short_commit_hash(old_target);
let new = short_commit_hash(new_target);
match to_direction(old_target, new_target)? {
BookmarkMoveDirection::Forward => {
format!("move forward from {old} to {new}")
}
BookmarkMoveDirection::Backward => {
format!("move backward from {old} to {new}")
}
BookmarkMoveDirection::Sideways => {
format!("move sideways from {old} to {new}")
}
}
}
(Some(old_target), None) => {
format!("delete from {old}", old = short_commit_hash(old_target))
}
(None, Some(new_target)) => {
format!("add to {new}", new = short_commit_hash(new_target))
}
(None, None) => {
panic!("Not pushing any change");
}
};
Ok(desc)
};
let kind_updates = [
("bookmark", &ref_updates.bookmarks),
("tag", &ref_updates.tags),
];
for (kind, updates) in kind_updates {
for (name, update) in updates {
let desc = describe_update(update)?;
writeln!(
formatter,
" {kind}: {name} [{desc}]",
name = name.as_symbol()
)?;
}
}
Ok(())
}
fn get_default_push_remote(
ui: &Ui,
workspace_command: &WorkspaceCommandHelper,
) -> Result<RemoteNameBuf, CommandError> {
let settings = workspace_command.settings();
if let Some(remote) = settings.get_string("git.push").optional()? {
Ok(remote.into())
} else if let Some(remote) = get_single_remote(workspace_command.repo().store())? {
if remote != DEFAULT_REMOTE {
writeln!(
ui.hint_default(),
"Pushing to the only existing remote: {remote}",
remote = remote.as_symbol()
)?;
}
Ok(remote)
} else {
Ok(DEFAULT_REMOTE.to_owned())
}
}
#[derive(Clone, Debug)]
struct RejectedRefUpdateReason {
message: String,
hint: Option<String>,
}
impl RejectedRefUpdateReason {
fn print(&self, ui: &Ui) -> io::Result<()> {
writeln!(ui.warning_default(), "{}", self.message)?;
if let Some(hint) = &self.hint {
writeln!(ui.hint_default(), "{hint}")?;
}
Ok(())
}
}
impl From<RejectedRefUpdateReason> for CommandError {
fn from(reason: RejectedRefUpdateReason) -> Self {
let RejectedRefUpdateReason { message, hint } = reason;
let mut cmd_err = user_error(message);
cmd_err.extend_hints(hint);
cmd_err
}
}
fn classify_bookmark_update(
remote_symbol: RemoteRefSymbol<'_>,
targets: LocalAndRemoteRef,
allow_new: bool,
allow_delete: bool,
) -> Result<Option<Diff<Option<CommitId>>>, RejectedRefUpdateReason> {
let push_action = classify_ref_push_action(targets);
match push_action {
RefPushAction::AlreadyMatches => Ok(None),
RefPushAction::LocalConflicted => Err(RejectedRefUpdateReason {
message: format!(
"Bookmark {name} is conflicted",
name = remote_symbol.name.as_symbol()
),
hint: Some(
"Run `jj bookmark list` to inspect, and use `jj bookmark set` to fix it up."
.to_owned(),
),
}),
RefPushAction::RemoteConflicted => Err(RejectedRefUpdateReason {
message: format!("Bookmark {remote_symbol} is conflicted"),
hint: Some("Run `jj git fetch` to update the conflicted remote bookmark.".to_owned()),
}),
RefPushAction::RemoteUntracked => Err(RejectedRefUpdateReason {
message: format!("Non-tracking remote bookmark {remote_symbol} exists"),
hint: Some(format!(
"Run `jj bookmark track {name} --remote={remote}` to import the remote bookmark.",
name = remote_symbol.name.as_symbol(),
remote = remote_symbol.remote.as_symbol()
)),
}),
RefPushAction::Update(_) if !targets.remote_ref.is_tracked() && !allow_new => {
Err(RejectedRefUpdateReason {
message: format!("Refusing to create new remote bookmark {remote_symbol}"),
hint: Some(format!(
"Run `jj bookmark track {name} --remote={remote}` and try again.",
name = remote_symbol.name.as_symbol(),
remote = remote_symbol.remote.as_symbol()
)),
})
}
RefPushAction::Update(update) if update.after.is_none() && !allow_delete => {
Err(RejectedRefUpdateReason {
message: format!(
"Refusing to push deleted bookmark {name}",
name = remote_symbol.name.as_symbol(),
),
hint: Some(
"Push deleted bookmarks with --deleted or forget the bookmark to suppress \
this warning."
.to_owned(),
),
})
}
RefPushAction::Update(update) => Ok(Some(update)),
}
}
fn classify_tag_update(
remote_symbol: RemoteRefSymbol<'_>,
targets: LocalAndRemoteRef<'_>,
allow_new: bool,
allow_delete: bool,
) -> Result<Option<Diff<Option<CommitId>>>, RejectedRefUpdateReason> {
let push_action = classify_ref_push_action(targets);
match push_action {
RefPushAction::AlreadyMatches => Ok(None),
RefPushAction::LocalConflicted => Err(RejectedRefUpdateReason {
message: format!(
"Tag {name} is conflicted",
name = remote_symbol.name.as_symbol()
),
hint: Some(
"Run `jj tag list` to inspect, and use `jj tag set` to fix it up.".to_owned(),
),
}),
RefPushAction::RemoteConflicted => Err(RejectedRefUpdateReason {
message: format!("Tag {remote_symbol} is conflicted"),
hint: Some("Run `jj git fetch` to update the conflicted remote tag.".to_owned()),
}),
RefPushAction::RemoteUntracked => Err(RejectedRefUpdateReason {
message: format!("Non-tracking remote tag {remote_symbol} exists"),
hint: None,
}),
RefPushAction::Update(_) if !targets.remote_ref.is_tracked() && !allow_new => {
Err(RejectedRefUpdateReason {
message: format!("Refusing to create new remote tag {remote_symbol}"),
hint: None,
})
}
RefPushAction::Update(update) if update.after.is_none() && !allow_delete => {
Err(RejectedRefUpdateReason {
message: format!(
"Refusing to push deleted tag {name}",
name = remote_symbol.name.as_symbol(),
),
hint: Some("Push deleted tags with --deleted.".to_owned()),
})
}
RefPushAction::Update(update) => Ok(Some(update)),
}
}
fn ensure_new_bookmark_name(repo: &dyn Repo, name: &RefName) -> Result<(), CommandError> {
let symbol = name.as_symbol();
if repo.view().get_local_bookmark(name).is_present() {
return Err(
user_error(format!("Bookmark already exists: {symbol}")).hinted(format!(
"Use 'jj bookmark move' to move it, and 'jj git push -b {symbol}' to push it"
)),
);
}
if has_tracked_remote_bookmarks(repo, name) {
return Err(user_error(format!(
"Tracked remote bookmarks exist for deleted bookmark: {symbol}"
))
.hinted(format!(
"Use `jj bookmark set` to recreate the local bookmark. Run `jj bookmark untrack \
{symbol}` to disassociate them."
)));
}
Ok(())
}
fn parse_named_bookmark(name_revision: &str) -> Result<(RefNameBuf, RevisionArg), CommandError> {
let hint = "For example, `--named myfeature=@` is valid syntax";
let Some((name_str, revision_str)) = name_revision.split_once('=') else {
return Err(cli_error(format!(
"Argument '{name_revision}' must include '=' and have the form NAME=REVISION"
))
.hinted(hint));
};
if name_str.is_empty() || revision_str.is_empty() {
return Err(cli_error(format!(
"Argument '{name_revision}' must have the form NAME=REVISION, with both NAME and \
REVISION non-empty"
))
.hinted(hint));
}
let name = parse_bookmark_name(name_str).map_err(|err| {
cli_error_with_message(
format!("Could not parse '{name_str}' as a bookmark name"),
err,
)
.hinted(hint)
})?;
Ok((name, RevisionArg::from(revision_str.to_owned())))
}
async fn create_change_bookmarks(
ui: &Ui,
tx: &mut WorkspaceCommandTransaction<'_>,
changes: &[RevisionArg],
) -> Result<Vec<RefNameBuf>, CommandError> {
if changes.is_empty() {
return Ok(vec![]);
}
let all_commits = try_join_all(
tx.base_workspace_helper()
.resolve_some_revsets(ui, changes)
.await?
.iter()
.map(|id| tx.repo().store().get_commit_async(id)),
)
.await?;
let bookmark_names: Vec<_> = {
let template_text = tx.settings().get_string("templates.git_push_bookmark")?;
let template = tx.parse_commit_template(ui, &template_text)?;
all_commits
.iter()
.map(|commit| {
let output = template.format_plain_text(commit);
let name = String::from_utf8(output).map_err(|err| {
user_error_with_message("Invalid character in bookmark name", err.utf8_error())
})?;
if name.is_empty() {
return Err(user_error("Empty bookmark name generated"));
}
Ok(RefNameBuf::from(name))
})
.try_collect()?
};
for (commit, name) in iter::zip(&all_commits, &bookmark_names) {
let target = RefTarget::normal(commit.id().clone());
if tx.repo().view().get_local_bookmark(name) == &target {
continue;
}
ensure_new_bookmark_name(tx.repo(), name)?;
writeln!(
ui.status(),
"Creating bookmark {name} for revision {change_id:.12}",
name = name.as_symbol(),
change_id = commit.change_id()
)?;
tx.repo_mut().set_local_bookmark_target(name, target);
}
Ok(bookmark_names)
}
fn find_bookmarks_to_push<'a>(
ui: &Ui,
view: &'a View,
bookmark_patterns: &[String],
remote: &RemoteName,
) -> Result<Vec<(&'a RefName, LocalAndRemoteRef<'a>)>, CommandError> {
let bookmark_expr = parse_union_name_patterns(ui, bookmark_patterns)?;
let bookmark_matcher = bookmark_expr.to_matcher();
let matching_bookmarks = view
.local_remote_bookmarks_matching(&bookmark_matcher, remote)
.filter(|(_, targets)| {
targets.local_target.is_present() || targets.remote_ref.is_tracked()
})
.collect();
let mut unmatched_names = bookmark_expr
.exact_strings()
.map(RefName::new)
.filter(|&name| {
let symbol = name.to_remote_symbol(remote);
view.get_local_bookmark(name).is_absent()
&& !view.get_remote_bookmark(symbol).is_tracked()
})
.peekable();
if unmatched_names.peek().is_some() {
writeln!(
ui.warning_default(),
"No matching bookmarks for names: {}",
unmatched_names.map(|name| name.as_symbol()).join(", ")
)?;
}
Ok(matching_bookmarks)
}
fn find_tags_to_push<'a>(
ui: &Ui,
view: &'a View,
tag_patterns: &[String],
remote: &RemoteName,
) -> Result<Vec<(&'a RefName, LocalAndRemoteRef<'a>)>, CommandError> {
let tag_expr = parse_union_name_patterns(ui, tag_patterns)?;
let tag_matcher = tag_expr.to_matcher();
let matching_tags = view
.local_remote_tags_matching(&tag_matcher, remote)
.filter(|(_, targets)| {
targets.local_target.is_present() || targets.remote_ref.is_tracked()
})
.collect();
let mut unmatched_names = tag_expr
.exact_strings()
.map(RefName::new)
.filter(|&name| {
let symbol = name.to_remote_symbol(remote);
view.get_local_tag(name).is_absent() && !view.get_remote_tag(symbol).is_tracked()
})
.peekable();
if unmatched_names.peek().is_some() {
writeln!(
ui.warning_default(),
"No matching tags for names: {}",
unmatched_names.map(|name| name.as_symbol()).join(", ")
)?;
}
Ok(matching_tags)
}
async fn find_default_target_revisions(
ui: &Ui,
workspace_command: &WorkspaceCommandHelper,
remote: &RemoteName,
) -> Result<HashSet<CommitId>, CommandError> {
let workspace_name = workspace_command.workspace_name();
let expression = RevsetExpression::remote_bookmarks(
RemoteRefSymbolExpression {
name: StringExpression::all(),
remote: StringExpression::exact(remote),
},
None,
)
.range(&RevsetExpression::working_copy(workspace_name.to_owned()))
.intersection(
&RevsetExpression::bookmarks(StringExpression::all())
.union(&RevsetExpression::tags(StringExpression::all())),
);
let commit_ids = workspace_command
.attach_revset_evaluator(expression)
.evaluate_to_commit_ids()?
.peekable();
let mut commit_ids = std::pin::pin!(commit_ids);
if commit_ids.as_mut().peek().await.is_none() {
writeln!(
ui.warning_default(),
"No bookmarks/tags found in the default push revset: \
remote_bookmarks(remote={remote})..@",
remote = remote.as_symbol()
)?;
}
Ok(commit_ids.try_collect().await?)
}
async fn find_target_revisions(
ui: &Ui,
workspace_command: &WorkspaceCommandHelper,
revisions: &[RevisionArg],
) -> Result<HashSet<CommitId>, CommandError> {
let mut revision_commit_ids = HashSet::new();
for rev_arg in revisions {
let mut expression = workspace_command.parse_revset(ui, rev_arg)?;
expression.intersect_with(
&RevsetExpression::bookmarks(StringExpression::all())
.union(&RevsetExpression::tags(StringExpression::all())),
);
let commit_ids = expression.evaluate_to_commit_ids()?.peekable();
let mut commit_ids = std::pin::pin!(commit_ids);
if commit_ids.as_mut().as_mut().peek().await.is_none() {
writeln!(
ui.warning_default(),
"No bookmarks/tags point to the specified revisions: {rev_arg}"
)?;
}
while let Some(commit_id) = commit_ids.try_next().await? {
revision_commit_ids.insert(commit_id);
}
}
Ok(revision_commit_ids)
}
fn matches_local_target(targets: LocalAndRemoteRef<'_>, revisions: &HashSet<CommitId>) -> bool {
let mut local_ids = targets.local_target.added_ids();
local_ids.any(|id| revisions.contains(id))
}
pub fn is_push_operation(op: &Operation) -> bool {
op.metadata().description.starts_with(TX_DESC_PUSH)
}