cybercyst/jj
1
0
Fork 0
mirror of https://github.com/martinvonz/jj.git synced 2025-05-06 07:52:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

view: rename RemoteRefState::Tracking to Tracked

Browse Source 
In jj's model, a local bookmark "tracks" remote bookmarks. It's wrong to call
a remote bookmark state as "tracking".
This commit is contained in:
Yuya Nishihara 2025-03-30 16:32:05 +09:00
parent 15e5bf7188
commit f87db58617
23 changed files with 128 additions and 128 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
cli/src/cli_util.rs
View File

@ -2899,7 +2899,7 @@ pub fn has_tracked_remote_bookmarks(view: &View, bookmark: &RefName) -> bool {
&StringPattern::everything(), &StringPattern::everything(),
) )
.filter(|&(symbol, _)| !jj_lib::git::is_special_git_remote(symbol.remote)) .filter(|&(symbol, _)| !jj_lib::git::is_special_git_remote(symbol.remote))
.any(|(_, remote_ref)| remote_ref.is_tracking()) .any(|(_, remote_ref)| remote_ref.is_tracked())
} }
pub fn load_template_aliases( pub fn load_template_aliases(

12
cli/src/commands/bookmark/list.rs
View File

@ -182,7 +182,7 @@ pub fn cmd_bookmark_list(
for (name, bookmark_target) in bookmarks_to_list { for (name, bookmark_target) in bookmarks_to_list {
let local_target = bookmark_target.local_target; let local_target = bookmark_target.local_target;
let remote_refs = bookmark_target.remote_refs; let remote_refs = bookmark_target.remote_refs;
let (mut tracking_remote_refs, untracked_remote_refs) = remote_refs let (mut tracked_remote_refs, untracked_remote_refs) = remote_refs
.iter() .iter()
.copied() .copied()
.filter(|(remote_name, _)| { .filter(|(remote_name, _)| {
@ -192,22 +192,22 @@ pub fn cmd_bookmark_list(
.any(|pattern| pattern.matches(remote_name.as_str())) .any(|pattern| pattern.matches(remote_name.as_str()))
}) })
}) })
.partition::<Vec<_>, _>(|&(_, remote_ref)| remote_ref.is_tracking()); .partition::<Vec<_>, _>(|&(_, remote_ref)| remote_ref.is_tracked());
if args.tracked { if args.tracked {
tracking_remote_refs.retain(|&(remote, _)| !jj_lib::git::is_special_git_remote(remote)); tracked_remote_refs.retain(|&(remote, _)| !jj_lib::git::is_special_git_remote(remote));
} else if !args.all_remotes && args.remotes.is_none() { } else if !args.all_remotes && args.remotes.is_none() {
tracking_remote_refs.retain(|&(_, remote_ref)| remote_ref.target != *local_target); tracked_remote_refs.retain(|&(_, remote_ref)| remote_ref.target != *local_target);
} }
let include_local_only = !args.tracked && args.remotes.is_none(); let include_local_only = !args.tracked && args.remotes.is_none();
if include_local_only && local_target.is_present() || !tracking_remote_refs.is_empty() { if include_local_only && local_target.is_present() || !tracked_remote_refs.is_empty() {
let primary = CommitRef::local( let primary = CommitRef::local(
name, name,
local_target.clone(), local_target.clone(),
remote_refs.iter().map(|&(_, remote_ref)| remote_ref), remote_refs.iter().map(|&(_, remote_ref)| remote_ref),
); );
let tracked = tracking_remote_refs let tracked = tracked_remote_refs
.iter() .iter()
.map(|&(remote, remote_ref)| { .map(|&(remote, remote_ref)| {
CommitRef::remote(name, remote, remote_ref.clone(), local_target) CommitRef::remote(name, remote, remote_ref.clone(), local_target)

2
cli/src/commands/bookmark/track.rs
View File

@ -59,7 +59,7 @@ pub fn cmd_bookmark_track(
let repo = workspace_command.repo().clone(); let repo = workspace_command.repo().clone();
let mut symbols = Vec::new(); let mut symbols = Vec::new();
for (symbol, remote_ref) in find_remote_bookmarks(repo.view(), &args.names)? { for (symbol, remote_ref) in find_remote_bookmarks(repo.view(), &args.names)? {
if remote_ref.is_tracking() { if remote_ref.is_tracked() {
writeln!( writeln!(
ui.warning_default(), ui.warning_default(),
"Remote bookmark already tracked: {symbol}" "Remote bookmark already tracked: {symbol}"

2
cli/src/commands/bookmark/untrack.rs
View File

@ -64,7 +64,7 @@ pub fn cmd_bookmark_untrack(
ui.warning_default(), ui.warning_default(),
"Git-tracking bookmark cannot be untracked: {symbol}" "Git-tracking bookmark cannot be untracked: {symbol}"
)?; )?;
} else if !remote_ref.is_tracking() { } else if !remote_ref.is_tracked() {
writeln!( writeln!(
ui.warning_default(), ui.warning_default(),
"Remote bookmark not tracked yet: {symbol}" "Remote bookmark not tracked yet: {symbol}"

2
cli/src/commands/git/init.rs
View File

@ -262,7 +262,7 @@ fn print_trackable_remote_bookmarks(ui: &Ui, view: &View) -> io::Result<()> {
bookmark_target bookmark_target
.remote_refs .remote_refs
.into_iter() .into_iter()
.filter(|&(_, remote_ref)| !remote_ref.is_tracking()) .filter(|&(_, remote_ref)| !remote_ref.is_tracked())
.map(move |(remote, _)| name.to_remote_symbol(remote)) .map(move |(remote, _)| name.to_remote_symbol(remote))
}) })
.collect_vec(); .collect_vec();

6
cli/src/commands/git/push.rs
View File

@ -227,7 +227,7 @@ pub fn cmd_git_push(
); );
} else if args.tracked { } else if args.tracked {
for (name, targets) in view.local_remote_bookmarks(remote) { for (name, targets) in view.local_remote_bookmarks(remote) {
if !targets.remote_ref.is_tracking() { if !targets.remote_ref.is_tracked() {
continue; continue;
} }
let allow_new = false; // doesn't matter let allow_new = false; // doesn't matter
@ -796,9 +796,9 @@ fn find_bookmarks_to_push<'a>(
let mut matches = view let mut matches = view
.local_remote_bookmarks_matching(pattern, remote) .local_remote_bookmarks_matching(pattern, remote)
.filter(|(_, targets)| { .filter(|(_, targets)| {
// If the remote exists but is not tracking, the absent local shouldn't // If the remote exists but is not tracked, the absent local shouldn't
// be considered a deleted bookmark. // be considered a deleted bookmark.
targets.local_target.is_present() || targets.remote_ref.is_tracking() targets.local_target.is_present() || targets.remote_ref.is_tracked()
}) })
.peekable(); .peekable();
if matches.peek().is_none() { if matches.peek().is_none() {

2
cli/src/commands/operation/diff.rs
View File

@ -389,7 +389,7 @@ pub fn show_op_diff(
})?; })?;
let get_remote_ref_prefix = |remote_ref: &RemoteRef| match remote_ref.state { let get_remote_ref_prefix = |remote_ref: &RemoteRef| match remote_ref.state {
RemoteRefState::New => "untracked", RemoteRefState::New => "untracked",
RemoteRefState::Tracking => "tracked", RemoteRefState::Tracked => "tracked",
}; };
for (symbol, (from_ref, to_ref)) in changed_remote_bookmarks { for (symbol, (from_ref, to_ref)) in changed_remote_bookmarks {
with_content_format.write(formatter, |formatter| { with_content_format.write(formatter, |formatter| {

6
cli/src/commit_templater.rs
View File

@ -1173,7 +1173,7 @@ impl CommitRef {
) -> Rc<Self> { ) -> Rc<Self> {
let synced = remote_refs let synced = remote_refs
.into_iter() .into_iter()
.all(|remote_ref| !remote_ref.is_tracking() || remote_ref.target == target); .all(|remote_ref| !remote_ref.is_tracked() || remote_ref.target == target);
Rc::new(CommitRef { Rc::new(CommitRef {
name: name.into(), name: name.into(),
remote: None, remote: None,
@ -1196,8 +1196,8 @@ impl CommitRef {
remote_ref: RemoteRef, remote_ref: RemoteRef,
local_target: &RefTarget, local_target: &RefTarget,
) -> Rc<Self> { ) -> Rc<Self> {
let synced = remote_ref.is_tracking() && remote_ref.target == *local_target; let synced = remote_ref.is_tracked() && remote_ref.target == *local_target;
let tracking_ref = remote_ref.is_tracking().then(|| { let tracking_ref = remote_ref.is_tracked().then(|| {
let count = if synced { let count = if synced {
OnceCell::from((0, Some(0))) // fast path for synced remotes OnceCell::from((0, Some(0))) // fast path for synced remotes
} else { } else {

2
cli/src/git_util.rs
View File

@ -514,7 +514,7 @@ impl RefStatus {
) -> Self { ) -> Self {
let tracking_status = match ref_kind { let tracking_status = match ref_kind {
GitRefKind::Bookmark => { GitRefKind::Bookmark => {
if repo.view().get_remote_bookmark(symbol).is_tracking() { if repo.view().get_remote_bookmark(symbol).is_tracked() {
TrackingStatus::Tracked TrackingStatus::Tracked
} else { } else {
TrackingStatus::Untracked TrackingStatus::Untracked

6
docs/design/tracking-branches.md
View File

@ -126,9 +126,9 @@ branch. `jj branch` sub commands will be added to change the tracking state.
```rust ```rust
fn default_state_for_newly_imported_branch(config, remote) { fn default_state_for_newly_imported_branch(config, remote) {
if remote == "git" { if remote == "git" {
State::Tracking State::Tracked
} else if config["git.auto-local-bookmark"] { } else if config["git.auto-local-bookmark"] {
State::Tracking State::Tracked
} else { } else {
State::New State::New
} }
@ -141,7 +141,7 @@ A branch target to be merged is calculated based on the `state`.
fn target_in_merge_context(known_target, state) { fn target_in_merge_context(known_target, state) {
match state { match state {
State::New => RefTarget::absent(), State::New => RefTarget::absent(),
State::Tracking => known_target, State::Tracked => known_target,
} }
} }
``` ```

20
lib/src/git.rs
View File

@ -488,7 +488,7 @@ pub fn import_some_refs(
} }
for (symbol, (old_remote_ref, new_target)) in &changed_remote_bookmarks { for (symbol, (old_remote_ref, new_target)) in &changed_remote_bookmarks {
let symbol = symbol.as_ref(); let symbol = symbol.as_ref();
let base_target = old_remote_ref.tracking_target(); let base_target = old_remote_ref.tracked_target();
let new_remote_ref = RemoteRef { let new_remote_ref = RemoteRef {
target: new_target.clone(), target: new_target.clone(),
state: if old_remote_ref.is_present() { state: if old_remote_ref.is_present() {
@ -497,7 +497,7 @@ pub fn import_some_refs(
default_remote_ref_state_for(GitRefKind::Bookmark, symbol, git_settings) default_remote_ref_state_for(GitRefKind::Bookmark, symbol, git_settings)
}, },
}; };
if new_remote_ref.is_tracking() { if new_remote_ref.is_tracked() {
mut_repo.merge_local_bookmark(symbol.name, base_target, &new_remote_ref.target); mut_repo.merge_local_bookmark(symbol.name, base_target, &new_remote_ref.target);
} }
// Remote-tracking branch is the last known state of the branch in the remote. // Remote-tracking branch is the last known state of the branch in the remote.
@ -506,7 +506,7 @@ pub fn import_some_refs(
} }
for (symbol, (old_remote_ref, new_target)) in &changed_remote_tags { for (symbol, (old_remote_ref, new_target)) in &changed_remote_tags {
let symbol = symbol.as_ref(); let symbol = symbol.as_ref();
let base_target = old_remote_ref.tracking_target(); let base_target = old_remote_ref.tracked_target();
let new_remote_ref = RemoteRef { let new_remote_ref = RemoteRef {
target: new_target.clone(), target: new_target.clone(),
state: if old_remote_ref.is_present() { state: if old_remote_ref.is_present() {
@ -515,7 +515,7 @@ pub fn import_some_refs(
default_remote_ref_state_for(GitRefKind::Tag, symbol, git_settings) default_remote_ref_state_for(GitRefKind::Tag, symbol, git_settings)
}, },
}; };
if new_remote_ref.is_tracking() { if new_remote_ref.is_tracked() {
mut_repo.merge_tag(symbol.name, base_target, &new_remote_ref.target); mut_repo.merge_tag(symbol.name, base_target, &new_remote_ref.target);
} }
// TODO: If we add Git-tracking tag, it will be updated here. // TODO: If we add Git-tracking tag, it will be updated here.
@ -604,7 +604,7 @@ fn diff_refs_to_import(
.iter() .iter()
.map(|(name, target)| { .map(|(name, target)| {
let symbol = name.to_remote_symbol(REMOTE_NAME_FOR_LOCAL_GIT_REPO); let symbol = name.to_remote_symbol(REMOTE_NAME_FOR_LOCAL_GIT_REPO);
let state = RemoteRefState::Tracking; let state = RemoteRefState::Tracked;
(symbol, (target, state)) (symbol, (target, state))
}) })
.filter(|&(symbol, _)| git_ref_filter(GitRefKind::Tag, symbol)) .filter(|&(symbol, _)| git_ref_filter(GitRefKind::Tag, symbol))
@ -737,12 +737,12 @@ fn default_remote_ref_state_for(
match kind { match kind {
GitRefKind::Bookmark => { GitRefKind::Bookmark => {
if symbol.remote == REMOTE_NAME_FOR_LOCAL_GIT_REPO || git_settings.auto_local_bookmark { if symbol.remote == REMOTE_NAME_FOR_LOCAL_GIT_REPO || git_settings.auto_local_bookmark {
RemoteRefState::Tracking RemoteRefState::Tracked
} else { } else {
RemoteRefState::New RemoteRefState::New
} }
} }
GitRefKind::Tag => RemoteRefState::Tracking, GitRefKind::Tag => RemoteRefState::Tracked,
} }
} }
@ -769,7 +769,7 @@ fn pinned_commit_ids(view: &View) -> Vec<CommitId> {
/// branches are considered independent refs. /// branches are considered independent refs.
fn remotely_pinned_commit_ids(view: &View) -> Vec<CommitId> { fn remotely_pinned_commit_ids(view: &View) -> Vec<CommitId> {
view.all_remote_bookmarks() view.all_remote_bookmarks()
.filter(|(_, remote_ref)| !remote_ref.is_tracking()) .filter(|(_, remote_ref)| !remote_ref.is_tracked())
.map(|(_, remote_ref)| &remote_ref.target) .map(|(_, remote_ref)| &remote_ref.target)
.flat_map(|target| target.added_ids()) .flat_map(|target| target.added_ids())
.cloned() .cloned()
@ -1021,7 +1021,7 @@ fn copy_exportable_local_bookmarks_to_remote_view(
for (name, new_target) in new_local_bookmarks { for (name, new_target) in new_local_bookmarks {
let new_remote_ref = RemoteRef { let new_remote_ref = RemoteRef {
target: new_target, target: new_target,
state: RemoteRefState::Tracking, state: RemoteRefState::Tracked,
}; };
mut_repo.set_remote_bookmark(name.to_remote_symbol(remote), new_remote_ref); mut_repo.set_remote_bookmark(name.to_remote_symbol(remote), new_remote_ref);
} }
@ -2515,7 +2515,7 @@ pub fn push_branches(
.into(); .into();
let new_remote_ref = RemoteRef { let new_remote_ref = RemoteRef {
target: RefTarget::resolved(update.new_target.clone()), target: RefTarget::resolved(update.new_target.clone()),
state: RemoteRefState::Tracking, state: RemoteRefState::Tracked,
}; };
mut_repo.set_git_ref_target(&git_ref_name, new_remote_ref.target.clone()); mut_repo.set_git_ref_target(&git_ref_name, new_remote_ref.target.clone());
mut_repo.set_remote_bookmark(name.to_remote_symbol(remote), new_remote_ref); mut_repo.set_remote_bookmark(name.to_remote_symbol(remote), new_remote_ref);

12
lib/src/op_store.rs
View File

@ -193,16 +193,16 @@ impl RemoteRef {
} }
/// Returns true if the ref is supposed to be merged in to the local ref. /// Returns true if the ref is supposed to be merged in to the local ref.
pub fn is_tracking(&self) -> bool { pub fn is_tracked(&self) -> bool {
self.state == RemoteRefState::Tracking self.state == RemoteRefState::Tracked
} }
/// Target that should have been merged in to the local ref. /// Target that should have been merged in to the local ref.
/// ///
/// Use this as the base or known target when merging new remote ref in to /// Use this as the base or known target when merging new remote ref in to
/// local or pushing local ref to remote. /// local or pushing local ref to remote.
pub fn tracking_target(&self) -> &RefTarget { pub fn tracked_target(&self) -> &RefTarget {
if self.is_tracking() { if self.is_tracked() {
&self.target &self.target
} else { } else {
RefTarget::absent_ref() RefTarget::absent_ref()
@ -217,7 +217,7 @@ pub enum RemoteRefState {
New, New,
/// Remote ref has been merged in to the local ref. Incoming ref will be /// Remote ref has been merged in to the local ref. Incoming ref will be
/// merged, too. /// merged, too.
Tracking, Tracked,
} }
/// Helper to strip redundant `Option<T>` from `RefTarget` lookup result. /// Helper to strip redundant `Option<T>` from `RefTarget` lookup result.
@ -507,7 +507,7 @@ mod tests {
fn test_merge_join_bookmark_views() { fn test_merge_join_bookmark_views() {
let remote_ref = |target: &RefTarget| RemoteRef { let remote_ref = |target: &RefTarget| RemoteRef {
target: target.clone(), target: target.clone(),
state: RemoteRefState::Tracking, // doesn't matter state: RemoteRefState::Tracked, // doesn't matter
}; };
let local_bookmark1_target = RefTarget::normal(CommitId::from_hex("111111")); let local_bookmark1_target = RefTarget::normal(CommitId::from_hex("111111"));
let local_bookmark2_target = RefTarget::normal(CommitId::from_hex("222222")); let local_bookmark2_target = RefTarget::normal(CommitId::from_hex("222222"));

2
lib/src/protos/op_store.proto
View File

@ -40,7 +40,7 @@ message RefTarget {
enum RemoteRefState { enum RemoteRefState {
New = 0; New = 0;
Tracking = 1; Tracked = 1;
} }
message RemoteBookmark { message RemoteBookmark {

6
lib/src/protos/op_store.rs
View File

@ -167,7 +167,7 @@ pub struct OperationMetadata {
#[repr(i32)] #[repr(i32)]
pub enum RemoteRefState { pub enum RemoteRefState {
New = 0, New = 0,
Tracking = 1, Tracked = 1,
} }
impl RemoteRefState { impl RemoteRefState {
/// String value of the enum field names used in the ProtoBuf definition. /// String value of the enum field names used in the ProtoBuf definition.
@ -177,14 +177,14 @@ impl RemoteRefState {
pub fn as_str_name(&self) -> &'static str { pub fn as_str_name(&self) -> &'static str {
match self { match self {
RemoteRefState::New => "New", RemoteRefState::New => "New",
RemoteRefState::Tracking => "Tracking", RemoteRefState::Tracked => "Tracked",
} }
} }
/// Creates an enum from field names used in the ProtoBuf definition. /// Creates an enum from field names used in the ProtoBuf definition.
pub fn from_str_name(value: &str) -> ::core::option::Option<Self> { pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
match value { match value {
"New" => Some(Self::New), "New" => Some(Self::New),
"Tracking" => Some(Self::Tracking), "Tracked" => Some(Self::Tracked),
_ => None, _ => None,
} }
} }

18
lib/src/refs.rs
View File

@ -209,14 +209,14 @@ pub enum BookmarkPushAction {
/// this bookmark. /// this bookmark.
pub fn classify_bookmark_push_action(targets: LocalAndRemoteRef) -> BookmarkPushAction { pub fn classify_bookmark_push_action(targets: LocalAndRemoteRef) -> BookmarkPushAction {
let local_target = targets.local_target; let local_target = targets.local_target;
let remote_target = targets.remote_ref.tracking_target(); let remote_target = targets.remote_ref.tracked_target();
if local_target == remote_target { if local_target == remote_target {
BookmarkPushAction::AlreadyMatches BookmarkPushAction::AlreadyMatches
} else if local_target.has_conflict() { } else if local_target.has_conflict() {
BookmarkPushAction::LocalConflicted BookmarkPushAction::LocalConflicted
} else if remote_target.has_conflict() { } else if remote_target.has_conflict() {
BookmarkPushAction::RemoteConflicted BookmarkPushAction::RemoteConflicted
} else if targets.remote_ref.is_present() && !targets.remote_ref.is_tracking() { } else if targets.remote_ref.is_present() && !targets.remote_ref.is_tracked() {
BookmarkPushAction::RemoteUntracked BookmarkPushAction::RemoteUntracked
} else { } else {
BookmarkPushAction::Update(BookmarkPushUpdate { BookmarkPushAction::Update(BookmarkPushUpdate {
@ -238,10 +238,10 @@ mod tests {
} }
} }
fn tracking_remote_ref(target: RefTarget) -> RemoteRef { fn tracked_remote_ref(target: RefTarget) -> RemoteRef {
RemoteRef { RemoteRef {
target, target,
state: RemoteRefState::Tracking, state: RemoteRefState::Tracked,
} }
} }
@ -250,7 +250,7 @@ mod tests {
let commit_id1 = CommitId::from_hex("11"); let commit_id1 = CommitId::from_hex("11");
let targets = LocalAndRemoteRef { let targets = LocalAndRemoteRef {
local_target: &RefTarget::normal(commit_id1.clone()), local_target: &RefTarget::normal(commit_id1.clone()),
remote_ref: &tracking_remote_ref(RefTarget::normal(commit_id1)), remote_ref: &tracked_remote_ref(RefTarget::normal(commit_id1)),
}; };
assert_eq!( assert_eq!(
classify_bookmark_push_action(targets), classify_bookmark_push_action(targets),
@ -279,7 +279,7 @@ mod tests {
let commit_id1 = CommitId::from_hex("11"); let commit_id1 = CommitId::from_hex("11");
let targets = LocalAndRemoteRef { let targets = LocalAndRemoteRef {
local_target: RefTarget::absent_ref(), local_target: RefTarget::absent_ref(),
remote_ref: &tracking_remote_ref(RefTarget::normal(commit_id1.clone())), remote_ref: &tracked_remote_ref(RefTarget::normal(commit_id1.clone())),
}; };
assert_eq!( assert_eq!(
classify_bookmark_push_action(targets), classify_bookmark_push_action(targets),
@ -296,7 +296,7 @@ mod tests {
let commit_id2 = CommitId::from_hex("22"); let commit_id2 = CommitId::from_hex("22");
let targets = LocalAndRemoteRef { let targets = LocalAndRemoteRef {
local_target: &RefTarget::normal(commit_id2.clone()), local_target: &RefTarget::normal(commit_id2.clone()),
remote_ref: &tracking_remote_ref(RefTarget::normal(commit_id1.clone())), remote_ref: &tracked_remote_ref(RefTarget::normal(commit_id1.clone())),
}; };
assert_eq!( assert_eq!(
classify_bookmark_push_action(targets), classify_bookmark_push_action(targets),
@ -342,7 +342,7 @@ mod tests {
let commit_id2 = CommitId::from_hex("22"); let commit_id2 = CommitId::from_hex("22");
let targets = LocalAndRemoteRef { let targets = LocalAndRemoteRef {
local_target: &RefTarget::from_legacy_form([], [commit_id1.clone(), commit_id2]), local_target: &RefTarget::from_legacy_form([], [commit_id1.clone(), commit_id2]),
remote_ref: &tracking_remote_ref(RefTarget::normal(commit_id1)), remote_ref: &tracked_remote_ref(RefTarget::normal(commit_id1)),
}; };
assert_eq!( assert_eq!(
classify_bookmark_push_action(targets), classify_bookmark_push_action(targets),
@ -356,7 +356,7 @@ mod tests {
let commit_id2 = CommitId::from_hex("22"); let commit_id2 = CommitId::from_hex("22");
let targets = LocalAndRemoteRef { let targets = LocalAndRemoteRef {
local_target: &RefTarget::normal(commit_id1.clone()), local_target: &RefTarget::normal(commit_id1.clone()),
remote_ref: &tracking_remote_ref(RefTarget::from_legacy_form( remote_ref: &tracked_remote_ref(RefTarget::from_legacy_form(
[], [],
[commit_id1, commit_id2], [commit_id1, commit_id2],
)), )),

4
lib/src/repo.rs
View File

@ -1578,9 +1578,9 @@ impl MutableRepo {
/// tracking it. /// tracking it.
pub fn track_remote_bookmark(&mut self, symbol: RemoteRefSymbol<'_>) { pub fn track_remote_bookmark(&mut self, symbol: RemoteRefSymbol<'_>) {
let mut remote_ref = self.get_remote_bookmark(symbol); let mut remote_ref = self.get_remote_bookmark(symbol);
let base_target = remote_ref.tracking_target(); let base_target = remote_ref.tracked_target();
self.merge_local_bookmark(symbol.name, base_target, &remote_ref.target); self.merge_local_bookmark(symbol.name, base_target, &remote_ref.target);
remote_ref.state = RemoteRefState::Tracking; remote_ref.state = RemoteRefState::Tracked;
self.set_remote_bookmark(symbol, remote_ref); self.set_remote_bookmark(symbol, remote_ref);
} }

8
lib/src/revset.rs
View File

@ -743,7 +743,7 @@ static BUILTIN_FUNCTION_MAP: Lazy<HashMap<&'static str, RevsetFunction>> = Lazy:
map.insert( map.insert(
"tracked_remote_bookmarks", "tracked_remote_bookmarks",
|diagnostics, function, _context| { |diagnostics, function, _context| {
parse_remote_bookmarks_arguments(diagnostics, function, Some(RemoteRefState::Tracking)) parse_remote_bookmarks_arguments(diagnostics, function, Some(RemoteRefState::Tracked))
}, },
); );
map.insert( map.insert(
@ -1832,7 +1832,7 @@ fn all_formatted_bookmark_symbols(
.into_iter() .into_iter()
.filter(move |&(_, remote_ref)| { .filter(move |&(_, remote_ref)| {
include_synced_remotes include_synced_remotes
|| !remote_ref.is_tracking() || !remote_ref.is_tracked()
|| remote_ref.target != *local_target || remote_ref.target != *local_target
}) })
.map(move |(remote, _)| format_remote_symbol(name.as_str(), remote.as_str())); .map(move |(remote, _)| format_remote_symbol(name.as_str(), remote.as_str()));
@ -2983,7 +2983,7 @@ mod tests {
RemoteBookmarks { RemoteBookmarks {
bookmark_pattern: Substring(""), bookmark_pattern: Substring(""),
remote_pattern: Substring(""), remote_pattern: Substring(""),
remote_ref_state: Some(Tracking), remote_ref_state: Some(Tracked),
}, },
) )
"#); "#);
@ -3317,7 +3317,7 @@ mod tests {
RemoteBookmarks { RemoteBookmarks {
bookmark_pattern: Substring("foo"), bookmark_pattern: Substring("foo"),
remote_pattern: Substring("bar"), remote_pattern: Substring("bar"),
remote_ref_state: Some(Tracking), remote_ref_state: Some(Tracked),
}, },
) )
"#); "#);

22
lib/src/simple_op_store.rs
View File

@ -608,7 +608,7 @@ fn bookmark_views_from_proto_legacy(
// setting could be toggled after the bookmark got merged. // setting could be toggled after the bookmark got merged.
let is_git_tracking = crate::git::is_special_git_remote(&remote_name); let is_git_tracking = crate::git::is_special_git_remote(&remote_name);
let default_state = if is_git_tracking || local_target.is_present() { let default_state = if is_git_tracking || local_target.is_present() {
RemoteRefState::Tracking RemoteRefState::Tracked
} else { } else {
RemoteRefState::New RemoteRefState::New
}; };
@ -712,7 +712,7 @@ fn ref_target_from_proto(maybe_proto: Option<crate::protos::op_store::RefTarget>
fn remote_ref_state_to_proto(state: RemoteRefState) -> Option<i32> { fn remote_ref_state_to_proto(state: RemoteRefState) -> Option<i32> {
let proto_state = match state { let proto_state = match state {
RemoteRefState::New => crate::protos::op_store::RemoteRefState::New, RemoteRefState::New => crate::protos::op_store::RemoteRefState::New,
RemoteRefState::Tracking => crate::protos::op_store::RemoteRefState::Tracking, RemoteRefState::Tracked => crate::protos::op_store::RemoteRefState::Tracked,
}; };
Some(proto_state as i32) Some(proto_state as i32)
} }
@ -721,7 +721,7 @@ fn remote_ref_state_from_proto(proto_value: Option<i32>) -> Option<RemoteRefStat
let proto_state = proto_value?.try_into().ok()?; let proto_state = proto_value?.try_into().ok()?;
let state = match proto_state { let state = match proto_state {
crate::protos::op_store::RemoteRefState::New => RemoteRefState::New, crate::protos::op_store::RemoteRefState::New => RemoteRefState::New,
crate::protos::op_store::RemoteRefState::Tracking => RemoteRefState::Tracking, crate::protos::op_store::RemoteRefState::Tracked => RemoteRefState::Tracked,
}; };
Some(state) Some(state)
} }
@ -742,9 +742,9 @@ mod tests {
target: target.clone(), target: target.clone(),
state: RemoteRefState::New, state: RemoteRefState::New,
}; };
let tracking_remote_ref = |target: &RefTarget| RemoteRef { let tracked_remote_ref = |target: &RefTarget| RemoteRef {
target: target.clone(), target: target.clone(),
state: RemoteRefState::Tracking, state: RemoteRefState::Tracked,
}; };
let head_id1 = CommitId::from_hex("aaa111"); let head_id1 = CommitId::from_hex("aaa111");
let head_id2 = CommitId::from_hex("aaa222"); let head_id2 = CommitId::from_hex("aaa222");
@ -770,7 +770,7 @@ mod tests {
remote_views: btreemap! { remote_views: btreemap! {
"origin".into() => RemoteView { "origin".into() => RemoteView {
bookmarks: btreemap! { bookmarks: btreemap! {
"main".into() => tracking_remote_ref(&bookmark_main_origin_target), "main".into() => tracked_remote_ref(&bookmark_main_origin_target),
"deleted".into() => new_remote_ref(&bookmark_deleted_origin_target), "deleted".into() => new_remote_ref(&bookmark_deleted_origin_target),
}, },
}, },
@ -870,9 +870,9 @@ mod tests {
target: target.clone(), target: target.clone(),
state: RemoteRefState::New, state: RemoteRefState::New,
}; };
let tracking_remote_ref = |target: &RefTarget| RemoteRef { let tracked_remote_ref = |target: &RefTarget| RemoteRef {
target: target.clone(), target: target.clone(),
state: RemoteRefState::Tracking, state: RemoteRefState::Tracked,
}; };
let local_bookmark1_target = RefTarget::normal(CommitId::from_hex("111111")); let local_bookmark1_target = RefTarget::normal(CommitId::from_hex("111111"));
let local_bookmark3_target = RefTarget::normal(CommitId::from_hex("222222")); let local_bookmark3_target = RefTarget::normal(CommitId::from_hex("222222"));
@ -887,19 +887,19 @@ mod tests {
let remote_views = btreemap! { let remote_views = btreemap! {
"git".into() => RemoteView { "git".into() => RemoteView {
bookmarks: btreemap! { bookmarks: btreemap! {
"bookmark1".into() => tracking_remote_ref(&git_bookmark1_target), "bookmark1".into() => tracked_remote_ref(&git_bookmark1_target),
}, },
}, },
"remote1".into() => RemoteView { "remote1".into() => RemoteView {
bookmarks: btreemap! { bookmarks: btreemap! {
"bookmark1".into() => tracking_remote_ref(&remote1_bookmark1_target), "bookmark1".into() => tracked_remote_ref(&remote1_bookmark1_target),
}, },
}, },
"remote2".into() => RemoteView { "remote2".into() => RemoteView {
bookmarks: btreemap! { bookmarks: btreemap! {
// "bookmark2" is non-tracking. "bookmark4" is tracking, but locally deleted. // "bookmark2" is non-tracking. "bookmark4" is tracking, but locally deleted.
"bookmark2".into() => new_remote_ref(&remote2_bookmark2_target), "bookmark2".into() => new_remote_ref(&remote2_bookmark2_target),
"bookmark4".into() => tracking_remote_ref(&remote2_bookmark4_target), "bookmark4".into() => tracked_remote_ref(&remote2_bookmark4_target),
}, },
}, },
}; };

74
lib/tests/test_git.rs
View File

@ -227,14 +227,14 @@ fn test_import_refs() {
view.get_remote_bookmark(remote_symbol("main", "git")), view.get_remote_bookmark(remote_symbol("main", "git")),
&RemoteRef { &RemoteRef {
target: RefTarget::normal(jj_id(commit2)), target: RefTarget::normal(jj_id(commit2)),
state: RemoteRefState::Tracking, state: RemoteRefState::Tracked,
}, },
); );
assert_eq!( assert_eq!(
view.get_remote_bookmark(remote_symbol("main", "origin")), view.get_remote_bookmark(remote_symbol("main", "origin")),
&RemoteRef { &RemoteRef {
target: RefTarget::normal(jj_id(commit1)), target: RefTarget::normal(jj_id(commit1)),
state: RemoteRefState::Tracking, state: RemoteRefState::Tracked,
}, },
); );
assert_eq!( assert_eq!(
@ -245,7 +245,7 @@ fn test_import_refs() {
view.get_remote_bookmark(remote_symbol("feature1", "git")), view.get_remote_bookmark(remote_symbol("feature1", "git")),
&RemoteRef { &RemoteRef {
target: RefTarget::normal(jj_id(commit3)), target: RefTarget::normal(jj_id(commit3)),
state: RemoteRefState::Tracking, state: RemoteRefState::Tracked,
}, },
); );
assert!(view assert!(view
@ -259,7 +259,7 @@ fn test_import_refs() {
view.get_remote_bookmark(remote_symbol("feature2", "git")), view.get_remote_bookmark(remote_symbol("feature2", "git")),
&RemoteRef { &RemoteRef {
target: RefTarget::normal(jj_id(commit4)), target: RefTarget::normal(jj_id(commit4)),
state: RemoteRefState::Tracking, state: RemoteRefState::Tracked,
}, },
); );
assert!(view assert!(view
@ -276,7 +276,7 @@ fn test_import_refs() {
view.get_remote_bookmark(remote_symbol("feature3", "origin")), view.get_remote_bookmark(remote_symbol("feature3", "origin")),
&RemoteRef { &RemoteRef {
target: RefTarget::normal(jj_id(commit6)), target: RefTarget::normal(jj_id(commit6)),
state: RemoteRefState::Tracking, state: RemoteRefState::Tracked,
}, },
); );
@ -397,14 +397,14 @@ fn test_import_refs_reimport() {
view.get_remote_bookmark(remote_symbol("main", "git")), view.get_remote_bookmark(remote_symbol("main", "git")),
&RemoteRef { &RemoteRef {
target: RefTarget::normal(jj_id(commit2)), target: RefTarget::normal(jj_id(commit2)),
state: RemoteRefState::Tracking, state: RemoteRefState::Tracked,
}, },
); );
assert_eq!( assert_eq!(
view.get_remote_bookmark(remote_symbol("main", "origin")), view.get_remote_bookmark(remote_symbol("main", "origin")),
&RemoteRef { &RemoteRef {
target: commit1_target.clone(), target: commit1_target.clone(),
state: RemoteRefState::Tracking, state: RemoteRefState::Tracked,
}, },
); );
assert_eq!( assert_eq!(
@ -415,7 +415,7 @@ fn test_import_refs_reimport() {
view.get_remote_bookmark(remote_symbol("feature2", "git")), view.get_remote_bookmark(remote_symbol("feature2", "git")),
&RemoteRef { &RemoteRef {
target: RefTarget::normal(jj_id(commit5)), target: RefTarget::normal(jj_id(commit5)),
state: RemoteRefState::Tracking, state: RemoteRefState::Tracked,
}, },
); );
assert!(view assert!(view
@ -637,7 +637,7 @@ fn test_import_refs_reimport_with_deleted_remote_ref() {
view.get_remote_bookmark(remote_symbol("feature-remote-only", "origin")), view.get_remote_bookmark(remote_symbol("feature-remote-only", "origin")),
&RemoteRef { &RemoteRef {
target: RefTarget::normal(jj_id(commit_remote_only)), target: RefTarget::normal(jj_id(commit_remote_only)),
state: RemoteRefState::Tracking, state: RemoteRefState::Tracked,
}, },
); );
assert_eq!( assert_eq!(
@ -648,14 +648,14 @@ fn test_import_refs_reimport_with_deleted_remote_ref() {
view.get_remote_bookmark(remote_symbol("feature-remote-and-local", "git")), view.get_remote_bookmark(remote_symbol("feature-remote-and-local", "git")),
&RemoteRef { &RemoteRef {
target: RefTarget::normal(jj_id(commit_remote_and_local)), target: RefTarget::normal(jj_id(commit_remote_and_local)),
state: RemoteRefState::Tracking, state: RemoteRefState::Tracked,
}, },
); );
assert_eq!( assert_eq!(
view.get_remote_bookmark(remote_symbol("feature-remote-and-local", "origin")), view.get_remote_bookmark(remote_symbol("feature-remote-and-local", "origin")),
&RemoteRef { &RemoteRef {
target: RefTarget::normal(jj_id(commit_remote_and_local)), target: RefTarget::normal(jj_id(commit_remote_and_local)),
state: RemoteRefState::Tracking, state: RemoteRefState::Tracked,
}, },
); );
assert!(view.get_local_bookmark("main".as_ref()).is_present()); // bookmark #3 of 3 assert!(view.get_local_bookmark("main".as_ref()).is_present()); // bookmark #3 of 3
@ -688,7 +688,7 @@ fn test_import_refs_reimport_with_deleted_remote_ref() {
view.get_remote_bookmark(remote_symbol("feature-remote-and-local", "git")), view.get_remote_bookmark(remote_symbol("feature-remote-and-local", "git")),
&RemoteRef { &RemoteRef {
target: RefTarget::normal(jj_id(commit_remote_and_local)), target: RefTarget::normal(jj_id(commit_remote_and_local)),
state: RemoteRefState::Tracking, state: RemoteRefState::Tracked,
}, },
); );
assert!(view assert!(view
@ -760,7 +760,7 @@ fn test_import_refs_reimport_with_moved_remote_ref() {
view.get_remote_bookmark(remote_symbol("feature-remote-only", "origin")), view.get_remote_bookmark(remote_symbol("feature-remote-only", "origin")),
&RemoteRef { &RemoteRef {
target: RefTarget::normal(jj_id(commit_remote_only)), target: RefTarget::normal(jj_id(commit_remote_only)),
state: RemoteRefState::Tracking, state: RemoteRefState::Tracked,
}, },
); );
assert_eq!( assert_eq!(
@ -771,14 +771,14 @@ fn test_import_refs_reimport_with_moved_remote_ref() {
view.get_remote_bookmark(remote_symbol("feature-remote-and-local", "git")), view.get_remote_bookmark(remote_symbol("feature-remote-and-local", "git")),
&RemoteRef { &RemoteRef {
target: RefTarget::normal(jj_id(commit_remote_and_local)), target: RefTarget::normal(jj_id(commit_remote_and_local)),
state: RemoteRefState::Tracking, state: RemoteRefState::Tracked,
}, },
); );
assert_eq!( assert_eq!(
view.get_remote_bookmark(remote_symbol("feature-remote-and-local", "origin")), view.get_remote_bookmark(remote_symbol("feature-remote-and-local", "origin")),
&RemoteRef { &RemoteRef {
target: RefTarget::normal(jj_id(commit_remote_and_local)), target: RefTarget::normal(jj_id(commit_remote_and_local)),
state: RemoteRefState::Tracking, state: RemoteRefState::Tracked,
}, },
); );
assert!(view.get_local_bookmark("main".as_ref()).is_present()); // bookmark #3 of 3 assert!(view.get_local_bookmark("main".as_ref()).is_present()); // bookmark #3 of 3
@ -818,7 +818,7 @@ fn test_import_refs_reimport_with_moved_remote_ref() {
view.get_remote_bookmark(remote_symbol("feature-remote-only", "origin")), view.get_remote_bookmark(remote_symbol("feature-remote-only", "origin")),
&RemoteRef { &RemoteRef {
target: RefTarget::normal(jj_id(new_commit_remote_only)), target: RefTarget::normal(jj_id(new_commit_remote_only)),
state: RemoteRefState::Tracking, state: RemoteRefState::Tracked,
}, },
); );
assert_eq!( assert_eq!(
@ -829,14 +829,14 @@ fn test_import_refs_reimport_with_moved_remote_ref() {
view.get_remote_bookmark(remote_symbol("feature-remote-and-local", "git")), view.get_remote_bookmark(remote_symbol("feature-remote-and-local", "git")),
&RemoteRef { &RemoteRef {
target: RefTarget::normal(jj_id(commit_remote_and_local)), target: RefTarget::normal(jj_id(commit_remote_and_local)),
state: RemoteRefState::Tracking, state: RemoteRefState::Tracked,
}, },
); );
assert_eq!( assert_eq!(
view.get_remote_bookmark(remote_symbol("feature-remote-and-local", "origin")), view.get_remote_bookmark(remote_symbol("feature-remote-and-local", "origin")),
&RemoteRef { &RemoteRef {
target: RefTarget::normal(jj_id(new_commit_remote_and_local)), target: RefTarget::normal(jj_id(new_commit_remote_and_local)),
state: RemoteRefState::Tracking, state: RemoteRefState::Tracked,
}, },
); );
assert!(view.get_local_bookmark("main".as_ref()).is_present()); // bookmark #3 of 3 assert!(view.get_local_bookmark("main".as_ref()).is_present()); // bookmark #3 of 3
@ -1180,7 +1180,7 @@ fn test_import_refs_reimport_conflicted_remote_bookmark() {
.get_remote_bookmark(remote_symbol("main", "origin")), .get_remote_bookmark(remote_symbol("main", "origin")),
&RemoteRef { &RemoteRef {
target: RefTarget::from_legacy_form([], [jj_id(commit1), jj_id(commit2)]), target: RefTarget::from_legacy_form([], [jj_id(commit1), jj_id(commit2)]),
state: RemoteRefState::Tracking, state: RemoteRefState::Tracked,
}, },
); );
@ -1197,7 +1197,7 @@ fn test_import_refs_reimport_conflicted_remote_bookmark() {
.get_remote_bookmark(remote_symbol("main", "origin")), .get_remote_bookmark(remote_symbol("main", "origin")),
&RemoteRef { &RemoteRef {
target: RefTarget::normal(jj_id(commit2)), target: RefTarget::normal(jj_id(commit2)),
state: RemoteRefState::Tracking, state: RemoteRefState::Tracked,
}, },
); );
} }
@ -1269,19 +1269,19 @@ fn test_import_some_refs() {
assert_eq!(view.bookmarks().count(), 4); assert_eq!(view.bookmarks().count(), 4);
let commit_feat1_remote_ref = RemoteRef { let commit_feat1_remote_ref = RemoteRef {
target: RefTarget::normal(jj_id(commit_feat1)), target: RefTarget::normal(jj_id(commit_feat1)),
state: RemoteRefState::Tracking, state: RemoteRefState::Tracked,
}; };
let commit_feat2_remote_ref = RemoteRef { let commit_feat2_remote_ref = RemoteRef {
target: RefTarget::normal(jj_id(commit_feat2)), target: RefTarget::normal(jj_id(commit_feat2)),
state: RemoteRefState::Tracking, state: RemoteRefState::Tracked,
}; };
let commit_feat3_remote_ref = RemoteRef { let commit_feat3_remote_ref = RemoteRef {
target: RefTarget::normal(jj_id(commit_feat3)), target: RefTarget::normal(jj_id(commit_feat3)),
state: RemoteRefState::Tracking, state: RemoteRefState::Tracked,
}; };
let commit_feat4_remote_ref = RemoteRef { let commit_feat4_remote_ref = RemoteRef {
target: RefTarget::normal(jj_id(commit_feat4)), target: RefTarget::normal(jj_id(commit_feat4)),
state: RemoteRefState::Tracking, state: RemoteRefState::Tracked,
}; };
assert_eq!( assert_eq!(
view.get_local_bookmark("feature1".as_ref()), view.get_local_bookmark("feature1".as_ref()),
@ -1892,7 +1892,7 @@ fn test_import_export_non_tracking_bookmark() {
.get_remote_bookmark(remote_symbol("feat", "origin")), .get_remote_bookmark(remote_symbol("feat", "origin")),
&RemoteRef { &RemoteRef {
target: RefTarget::normal(jj_id(commit_feat_t1)), target: RefTarget::normal(jj_id(commit_feat_t1)),
state: RemoteRefState::Tracking, state: RemoteRefState::Tracked,
}, },
); );
@ -1924,7 +1924,7 @@ fn test_import_export_non_tracking_bookmark() {
.get_remote_bookmark(remote_symbol("feat", "origin")), .get_remote_bookmark(remote_symbol("feat", "origin")),
&RemoteRef { &RemoteRef {
target: RefTarget::normal(jj_id(commit_feat_t2)), target: RefTarget::normal(jj_id(commit_feat_t2)),
state: RemoteRefState::Tracking, state: RemoteRefState::Tracked,
}, },
); );
} }
@ -1979,14 +1979,14 @@ fn test_export_conflicts() {
mut_repo.get_remote_bookmark(remote_symbol("feature", "git")), mut_repo.get_remote_bookmark(remote_symbol("feature", "git")),
RemoteRef { RemoteRef {
target: RefTarget::normal(commit_a.id().clone()), target: RefTarget::normal(commit_a.id().clone()),
state: RemoteRefState::Tracking, state: RemoteRefState::Tracked,
}, },
); );
assert_eq!( assert_eq!(
mut_repo.get_remote_bookmark(remote_symbol("main", "git")), mut_repo.get_remote_bookmark(remote_symbol("main", "git")),
RemoteRef { RemoteRef {
target: RefTarget::normal(commit_b.id().clone()), target: RefTarget::normal(commit_b.id().clone()),
state: RemoteRefState::Tracking, state: RemoteRefState::Tracked,
}, },
); );
} }
@ -2081,7 +2081,7 @@ fn test_export_partial_failure() {
mut_repo.get_remote_bookmark(remote_symbol("main", "git")), mut_repo.get_remote_bookmark(remote_symbol("main", "git")),
RemoteRef { RemoteRef {
target: target.clone(), target: target.clone(),
state: RemoteRefState::Tracking, state: RemoteRefState::Tracked,
}, },
); );
assert!(mut_repo assert!(mut_repo
@ -2135,7 +2135,7 @@ fn test_export_partial_failure() {
mut_repo.get_remote_bookmark(remote_symbol("main/sub", "git")), mut_repo.get_remote_bookmark(remote_symbol("main/sub", "git")),
RemoteRef { RemoteRef {
target: target.clone(), target: target.clone(),
state: RemoteRefState::Tracking, state: RemoteRefState::Tracked,
}, },
); );
} }
@ -2328,7 +2328,7 @@ fn test_export_undo_reexport() {
mut_repo.get_remote_bookmark(remote_symbol("main", "git")), mut_repo.get_remote_bookmark(remote_symbol("main", "git")),
RemoteRef { RemoteRef {
target: target_a.clone(), target: target_a.clone(),
state: RemoteRefState::Tracking, state: RemoteRefState::Tracked,
}, },
); );
@ -2351,7 +2351,7 @@ fn test_export_undo_reexport() {
mut_repo.get_remote_bookmark(remote_symbol("main", "git")), mut_repo.get_remote_bookmark(remote_symbol("main", "git")),
RemoteRef { RemoteRef {
target: target_a.clone(), target: target_a.clone(),
state: RemoteRefState::Tracking, state: RemoteRefState::Tracked,
}, },
); );
} }
@ -2900,7 +2900,7 @@ fn test_fetch_initial_commit_head_is_not_set(subprocess: bool) {
let initial_commit_target = RefTarget::normal(jj_id(initial_git_commit)); let initial_commit_target = RefTarget::normal(jj_id(initial_git_commit));
let initial_commit_remote_ref = RemoteRef { let initial_commit_remote_ref = RemoteRef {
target: initial_commit_target.clone(), target: initial_commit_target.clone(),
state: RemoteRefState::Tracking, state: RemoteRefState::Tracked,
}; };
assert_eq!( assert_eq!(
*view.git_refs(), *view.git_refs(),
@ -3013,7 +3013,7 @@ fn test_fetch_success(subprocess: bool) {
let new_commit_target = RefTarget::normal(jj_id(new_git_commit)); let new_commit_target = RefTarget::normal(jj_id(new_git_commit));
let new_commit_remote_ref = RemoteRef { let new_commit_remote_ref = RemoteRef {
target: new_commit_target.clone(), target: new_commit_target.clone(),
state: RemoteRefState::Tracking, state: RemoteRefState::Tracked,
}; };
assert_eq!( assert_eq!(
*view.git_refs(), *view.git_refs(),
@ -3276,7 +3276,7 @@ fn set_up_push_repos(settings: &UserSettings, temp_dir: &TempDir) -> PushTestSet
target: RefTarget::normal(main_commit.id().clone()), target: RefTarget::normal(main_commit.id().clone()),
// Caller expects the main bookmark is tracked. The corresponding local bookmark will // Caller expects the main bookmark is tracked. The corresponding local bookmark will
// be created (or left as deleted) by caller. // be created (or left as deleted) by caller.
state: RemoteRefState::Tracking, state: RemoteRefState::Tracked,
}, },
); );
let jj_repo = tx.commit("test").unwrap(); let jj_repo = tx.commit("test").unwrap();
@ -3348,7 +3348,7 @@ fn test_push_bookmarks_success(subprocess: bool) {
*view.get_remote_bookmark(remote_symbol("main", "origin")), *view.get_remote_bookmark(remote_symbol("main", "origin")),
RemoteRef { RemoteRef {
target: RefTarget::normal(setup.child_of_main_commit.id().clone()), target: RefTarget::normal(setup.child_of_main_commit.id().clone()),
state: RemoteRefState::Tracking, state: RemoteRefState::Tracked,
}, },
); );
@ -3492,7 +3492,7 @@ fn test_push_bookmarks_mixed_deletion_and_addition(subprocess: bool) {
*view.get_remote_bookmark(remote_symbol("topic", "origin")), *view.get_remote_bookmark(remote_symbol("topic", "origin")),
RemoteRef { RemoteRef {
target: RefTarget::normal(setup.child_of_main_commit.id().clone()), target: RefTarget::normal(setup.child_of_main_commit.id().clone()),
state: RemoteRefState::Tracking, state: RemoteRefState::Tracked,
}, },
); );

4
lib/tests/test_mut_repo.rs
View File

@ -468,7 +468,7 @@ fn test_has_changed() {
let repo = &test_repo.repo; let repo = &test_repo.repo;
let normal_remote_ref = |id: &CommitId| RemoteRef { let normal_remote_ref = |id: &CommitId| RemoteRef {
target: RefTarget::normal(id.clone()), target: RefTarget::normal(id.clone()),
state: RemoteRefState::Tracking, // doesn't matter state: RemoteRefState::Tracked, // doesn't matter
}; };
let mut tx = repo.start_transaction(); let mut tx = repo.start_transaction();
@ -613,7 +613,7 @@ fn test_rename_remote() {
let commit = write_random_commit(mut_repo); let commit = write_random_commit(mut_repo);
let remote_ref = RemoteRef { let remote_ref = RemoteRef {
target: RefTarget::normal(commit.id().clone()), target: RefTarget::normal(commit.id().clone()),
state: RemoteRefState::Tracking, // doesn't matter state: RemoteRefState::Tracked, // doesn't matter
}; };
mut_repo.set_remote_bookmark(remote_symbol("main", "origin"), remote_ref.clone()); mut_repo.set_remote_bookmark(remote_symbol("main", "origin"), remote_ref.clone());
mut_repo.rename_remote("origin".as_ref(), "upstream".as_ref()); mut_repo.rename_remote("origin".as_ref(), "upstream".as_ref());

36
lib/tests/test_revset.rs
View File

@ -524,12 +524,12 @@ fn test_resolve_symbol_bookmarks() {
target, target,
state: RemoteRefState::New, state: RemoteRefState::New,
}; };
let tracking_remote_ref = |target| RemoteRef { let tracked_remote_ref = |target| RemoteRef {
target, target,
state: RemoteRefState::Tracking, state: RemoteRefState::Tracked,
}; };
let normal_tracking_remote_ref = let normal_tracked_remote_ref =
|id: &CommitId| tracking_remote_ref(RefTarget::normal(id.clone())); |id: &CommitId| tracked_remote_ref(RefTarget::normal(id.clone()));
let mut tx = repo.start_transaction(); let mut tx = repo.start_transaction();
let mut_repo = tx.repo_mut(); let mut_repo = tx.repo_mut();
@ -543,7 +543,7 @@ fn test_resolve_symbol_bookmarks() {
mut_repo.set_local_bookmark_target("local".as_ref(), RefTarget::normal(commit1.id().clone())); mut_repo.set_local_bookmark_target("local".as_ref(), RefTarget::normal(commit1.id().clone()));
mut_repo.set_remote_bookmark( mut_repo.set_remote_bookmark(
remote_symbol("remote", "origin"), remote_symbol("remote", "origin"),
normal_tracking_remote_ref(commit2.id()), normal_tracked_remote_ref(commit2.id()),
); );
mut_repo.set_local_bookmark_target( mut_repo.set_local_bookmark_target(
"local-remote".as_ref(), "local-remote".as_ref(),
@ -551,7 +551,7 @@ fn test_resolve_symbol_bookmarks() {
); );
mut_repo.set_remote_bookmark( mut_repo.set_remote_bookmark(
remote_symbol("local-remote", "origin"), remote_symbol("local-remote", "origin"),
normal_tracking_remote_ref(commit4.id()), normal_tracked_remote_ref(commit4.id()),
); );
mut_repo.set_local_bookmark_target( mut_repo.set_local_bookmark_target(
"local-remote@origin".as_ref(), // not a remote bookmark "local-remote@origin".as_ref(), // not a remote bookmark
@ -559,7 +559,7 @@ fn test_resolve_symbol_bookmarks() {
); );
mut_repo.set_remote_bookmark( mut_repo.set_remote_bookmark(
remote_symbol("local-remote", "mirror"), remote_symbol("local-remote", "mirror"),
tracking_remote_ref(mut_repo.get_local_bookmark("local-remote".as_ref())), tracked_remote_ref(mut_repo.get_local_bookmark("local-remote".as_ref())),
); );
mut_repo.set_remote_bookmark( mut_repo.set_remote_bookmark(
remote_symbol("local-remote", "untracked"), remote_symbol("local-remote", "untracked"),
@ -567,7 +567,7 @@ fn test_resolve_symbol_bookmarks() {
); );
mut_repo.set_remote_bookmark( mut_repo.set_remote_bookmark(
remote_symbol("local-remote", git::REMOTE_NAME_FOR_LOCAL_GIT_REPO), remote_symbol("local-remote", git::REMOTE_NAME_FOR_LOCAL_GIT_REPO),
tracking_remote_ref(mut_repo.get_local_bookmark("local-remote".as_ref())), tracked_remote_ref(mut_repo.get_local_bookmark("local-remote".as_ref())),
); );
mut_repo.set_local_bookmark_target( mut_repo.set_local_bookmark_target(
@ -579,7 +579,7 @@ fn test_resolve_symbol_bookmarks() {
); );
mut_repo.set_remote_bookmark( mut_repo.set_remote_bookmark(
remote_symbol("remote-conflicted", "origin"), remote_symbol("remote-conflicted", "origin"),
tracking_remote_ref(RefTarget::from_legacy_form( tracked_remote_ref(RefTarget::from_legacy_form(
[commit3.id().clone()], [commit3.id().clone()],
[commit5.id().clone(), commit4.id().clone()], [commit5.id().clone(), commit4.id().clone()],
)), )),
@ -2126,12 +2126,12 @@ fn test_evaluate_expression_bookmarks() {
fn test_evaluate_expression_remote_bookmarks() { fn test_evaluate_expression_remote_bookmarks() {
let test_repo = TestRepo::init(); let test_repo = TestRepo::init();
let repo = &test_repo.repo; let repo = &test_repo.repo;
let tracking_remote_ref = |target| RemoteRef { let tracked_remote_ref = |target| RemoteRef {
target, target,
state: RemoteRefState::Tracking, state: RemoteRefState::Tracked,
}; };
let normal_tracking_remote_ref = let normal_tracked_remote_ref =
|id: &CommitId| tracking_remote_ref(RefTarget::normal(id.clone())); |id: &CommitId| tracked_remote_ref(RefTarget::normal(id.clone()));
let mut tx = repo.start_transaction(); let mut tx = repo.start_transaction();
let mut_repo = tx.repo_mut(); let mut_repo = tx.repo_mut();
@ -2155,12 +2155,12 @@ fn test_evaluate_expression_remote_bookmarks() {
// Bookmark 2 is tracked on remote private // Bookmark 2 is tracked on remote private
mut_repo.set_remote_bookmark( mut_repo.set_remote_bookmark(
remote_symbol("bookmark2", "private"), remote_symbol("bookmark2", "private"),
normal_tracking_remote_ref(commit2.id()), normal_tracked_remote_ref(commit2.id()),
); );
// Git-tracking bookmarks aren't included // Git-tracking bookmarks aren't included
mut_repo.set_remote_bookmark( mut_repo.set_remote_bookmark(
remote_symbol("bookmark", git::REMOTE_NAME_FOR_LOCAL_GIT_REPO), remote_symbol("bookmark", git::REMOTE_NAME_FOR_LOCAL_GIT_REPO),
normal_tracking_remote_ref(commit_git_remote.id()), normal_tracked_remote_ref(commit_git_remote.id()),
); );
// Can get a few bookmarks // Can get a few bookmarks
assert_eq!( assert_eq!(
@ -2259,7 +2259,7 @@ fn test_evaluate_expression_remote_bookmarks() {
// the revset // the revset
mut_repo.set_remote_bookmark( mut_repo.set_remote_bookmark(
remote_symbol("bookmark3", "origin"), remote_symbol("bookmark3", "origin"),
normal_tracking_remote_ref(commit2.id()), normal_tracked_remote_ref(commit2.id()),
); );
assert_eq!( assert_eq!(
resolve_commit_ids(mut_repo, "remote_bookmarks()"), resolve_commit_ids(mut_repo, "remote_bookmarks()"),
@ -2274,14 +2274,14 @@ fn test_evaluate_expression_remote_bookmarks() {
// Can get bookmarks when there are conflicted refs // Can get bookmarks when there are conflicted refs
mut_repo.set_remote_bookmark( mut_repo.set_remote_bookmark(
remote_symbol("bookmark1", "origin"), remote_symbol("bookmark1", "origin"),
tracking_remote_ref(RefTarget::from_legacy_form( tracked_remote_ref(RefTarget::from_legacy_form(
[commit1.id().clone()], [commit1.id().clone()],
[commit2.id().clone(), commit3.id().clone()], [commit2.id().clone(), commit3.id().clone()],
)), )),
); );
mut_repo.set_remote_bookmark( mut_repo.set_remote_bookmark(
remote_symbol("bookmark2", "private"), remote_symbol("bookmark2", "private"),
tracking_remote_ref(RefTarget::from_legacy_form( tracked_remote_ref(RefTarget::from_legacy_form(
[commit2.id().clone()], [commit2.id().clone()],
[commit3.id().clone(), commit4.id().clone()], [commit3.id().clone(), commit4.id().clone()],
)), )),

4
lib/tests/test_rewrite.rs
View File

@ -1023,7 +1023,7 @@ fn test_rebase_descendants_basic_bookmark_update_with_non_local_bookmark() {
let commit_b = graph_builder.commit_with_parents(&[&commit_a]); let commit_b = graph_builder.commit_with_parents(&[&commit_a]);
let commit_b_remote_ref = RemoteRef { let commit_b_remote_ref = RemoteRef {
target: RefTarget::normal(commit_b.id().clone()), target: RefTarget::normal(commit_b.id().clone()),
state: RemoteRefState::Tracking, state: RemoteRefState::Tracked,
}; };
tx.repo_mut() tx.repo_mut()
.set_local_bookmark_target("main".as_ref(), RefTarget::normal(commit_b.id().clone())); .set_local_bookmark_target("main".as_ref(), RefTarget::normal(commit_b.id().clone()));
@ -1077,7 +1077,7 @@ fn test_rebase_descendants_update_bookmark_after_abandon(delete_abandoned_bookma
let commit_c = graph_builder.commit_with_parents(&[&commit_b]); let commit_c = graph_builder.commit_with_parents(&[&commit_b]);
let commit_b_remote_ref = RemoteRef { let commit_b_remote_ref = RemoteRef {
target: RefTarget::normal(commit_b.id().clone()), target: RefTarget::normal(commit_b.id().clone()),
state: RemoteRefState::Tracking, state: RemoteRefState::Tracked,
}; };
tx.repo_mut() tx.repo_mut()
.set_local_bookmark_target("main".as_ref(), RefTarget::normal(commit_b.id().clone())); .set_local_bookmark_target("main".as_ref(), RefTarget::normal(commit_b.id().clone()));

4
lib/tests/test_view.rs
View File

@ -229,7 +229,7 @@ fn test_merge_views_bookmarks() {
}; };
let main_bookmark_alternate_tx0_remote_ref = RemoteRef { let main_bookmark_alternate_tx0_remote_ref = RemoteRef {
target: RefTarget::normal(main_bookmark_alternate_tx0.id().clone()), target: RefTarget::normal(main_bookmark_alternate_tx0.id().clone()),
state: RemoteRefState::Tracking, state: RemoteRefState::Tracked,
}; };
mut_repo.set_local_bookmark_target( mut_repo.set_local_bookmark_target(
"main".as_ref(), "main".as_ref(),
@ -267,7 +267,7 @@ fn test_merge_views_bookmarks() {
let main_bookmark_origin_tx2 = write_random_commit(tx2.repo_mut()); let main_bookmark_origin_tx2 = write_random_commit(tx2.repo_mut());
let main_bookmark_origin_tx2_remote_ref = RemoteRef { let main_bookmark_origin_tx2_remote_ref = RemoteRef {
target: RefTarget::normal(main_bookmark_origin_tx2.id().clone()), target: RefTarget::normal(main_bookmark_origin_tx2.id().clone()),
state: RemoteRefState::Tracking, state: RemoteRefState::Tracked,
}; };
tx2.repo_mut().set_local_bookmark_target( tx2.repo_mut().set_local_bookmark_target(
"main".as_ref(), "main".as_ref(),