This is an archive of the discontinued Mercurial Phabricator instance.

Differential D6602

copies: inline _chainandfilter() to prepare for next patch
ClosedPublic

Authored by martinvonz on Jul 2 2019, 1:13 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG11ceb1b8fd74: copies: inline _chainandfilter() to prepare for next patch

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

martinvonz created this revision.Jul 2 2019, 1:13 PM
martinvonz added a comment.Jul 4 2019, 1:56 PM

Wow, Phabricator decides to send the email almost two full days after the
review was created. Anyone knows what's going on?

martinvonz added a commit: rHG11ceb1b8fd74: copies: inline _chainandfilter() to prepare for next patch.Jul 10 2019, 3:39 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG11ceb1b8fd74: copies: inline _chainandfilter() to prepare for next patch (authored by martinvonz). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/copies.py (26 lines)

Diff 15874

mercurial/copies.py

# o 0 a0 # o 0 a0
# #
# When _findlimit is called, a and b are revs 3 and 0, so limit will be 2, # When _findlimit is called, a and b are revs 3 and 0, so limit will be 2,
# yet the filelog has the copy information in rev 1 and we will not look # yet the filelog has the copy information in rev 1 and we will not look
# back far enough unless we also look at the a and b as candidates. # back far enough unless we also look at the a and b as candidates.
# This only occurs when a is a descendent of b or visa-versa. # This only occurs when a is a descendent of b or visa-versa.
return min(limit, a, b) return min(limit, a, b)
def _chainandfilter(src, dst, a, b): def _filter(src, dst, t):
"""chain two sets of copies 'a' and 'b' and filter result""" """filters out invalid copies after chaining"""
# When chaining copies in 'a' (from 'src' via some other commit 'mid') with # When _chain()'ing copies in 'a' (from 'src' via some other commit 'mid')
# copies in 'b' (from 'mid' to 'dst'), we can get the different cases in the # with copies in 'b' (from 'mid' to 'dst'), we can get the different cases
# following table (not including trivial cases). For example, case 2 is # in the following table (not including trivial cases). For example, case 2
# where a file existed in 'src' and remained under that name in 'mid' and # is where a file existed in 'src' and remained under that name in 'mid' and
# then was renamed between 'mid' and 'dst'. # then was renamed between 'mid' and 'dst'.
# #
# case src mid dst result # case src mid dst result
# 1 x y - - # 1 x y - -
# 2 x y y x->y # 2 x y y x->y
# 3 x y x - # 3 x y x -
# 4 x y z x->z # 4 x y z x->z
# 5 - x y - # 5 - x y -
# 6 x x y x->y # 6 x x y x->y
# #
# _chain() takes care of chaining the copies in 'a' and 'b', but it # _chain() takes care of chaining the copies in 'a' and 'b', but it
# cannot tell the difference between cases 1 and 2, between 3 and 4, or # cannot tell the difference between cases 1 and 2, between 3 and 4, or
# between 5 and 6, so it includes all cases in its result. # between 5 and 6, so it includes all cases in its result.
# Cases 1, 3, and 5 are then removed by _filter(). # Cases 1, 3, and 5 are then removed by _filter().
t = _chain(a, b)
_filter(src, dst, t)
return t
def _filter(src, dst, t):
"""filters out invalid copies after chaining"""
for k, v in list(t.items()): for k, v in list(t.items()):
# remove copies from files that didn't exist # remove copies from files that didn't exist
if v not in src: if v not in src:
del t[k] del t[k]
# remove criss-crossed copies # remove criss-crossed copies
elif k in src and v in dst: elif k in src and v in dst:
del t[k] del t[k]
# remove copies to files that were then removed # remove copies to files that were then removed
def _forwardcopies(a, b, match=None): def _forwardcopies(a, b, match=None):
"""find {dst@b: src@a} copy mapping where a is an ancestor of b""" """find {dst@b: src@a} copy mapping where a is an ancestor of b"""
match = a.repo().narrowmatch(match) match = a.repo().narrowmatch(match)
# check for working copy # check for working copy
if b.rev() is None: if b.rev() is None:
cm = _committedforwardcopies(a, b.p1(), match) cm = _committedforwardcopies(a, b.p1(), match)
# combine copies from dirstate if necessary # combine copies from dirstate if necessary
copies = _chainandfilter(a, b, cm, _dirstatecopies(b._repo, match)) copies = _chain(cm, _dirstatecopies(b._repo, match))
_filter(a, b, copies)
else: else:
copies = _committedforwardcopies(a, b, match) copies = _committedforwardcopies(a, b, match)
return copies return copies
def _backwardrenames(a, b, match): def _backwardrenames(a, b, match):
if a._repo.ui.config('experimental', 'copytrace') == 'off': if a._repo.ui.config('experimental', 'copytrace') == 'off':
return {} return {}
copies = _forwardcopies(x, y, match=match) copies = _forwardcopies(x, y, match=match)
elif a == y: elif a == y:
if debug: if debug:
repo.ui.debug('debug.copies: search mode: backward\n') repo.ui.debug('debug.copies: search mode: backward\n')
copies = _backwardrenames(x, y, match=match) copies = _backwardrenames(x, y, match=match)
else: else:
if debug: if debug:
repo.ui.debug('debug.copies: search mode: combined\n') repo.ui.debug('debug.copies: search mode: combined\n')
copies = _chainandfilter(x, y, _backwardrenames(x, a, match=match), copies = _chain(_backwardrenames(x, a, match=match),
_forwardcopies(a, y, match=match)) _forwardcopies(a, y, match=match))
_filter(x, y, copies)
return copies return copies
def mergecopies(repo, c1, c2, base): def mergecopies(repo, c1, c2, base):
""" """
Finds moves and copies between context c1 and c2 that are relevant for Finds moves and copies between context c1 and c2 that are relevant for
merging. 'base' will be used as the merge base. merging. 'base' will be used as the merge base.
Copytracing is used in commands like rebase, merge, unshelve, etc to merge Copytracing is used in commands like rebase, merge, unshelve, etc to merge