This is an archive of the discontinued Mercurial Phabricator instance.

Differential D8710

commitctx: extract _filecommit too
ClosedPublic

Authored by marmoute on Jul 8 2020, 4:37 AM.

Details

Reviewers
pulkit
Group Reviewers
hg-reviewers
Commits
rHGce9ee81df9ff: commitctx: extract _filecommit too
Summary

This function is exclusively used in commitctx. So we should extract it too
for consistency and to reduce the localrepo bloat.

This is part of a larger refactoring/cleanup of the commitctx code to clarify
and augment the logic gathering metadata useful for copy tracing. The current
code is a tad too long and entangled to make such update easy.

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

marmoute created this revision.Jul 8 2020, 4:37 AM
marmoute updated this revision to Diff 21992.Jul 20 2020, 12:51 PM
marmoute updated this revision to Diff 22031.Jul 21 2020, 6:09 PM
pulkit accepted this revision.Jul 22 2020, 7:37 AM
This revision is now accepted and ready to land.Jul 22 2020, 7:37 AM
marmoute added a commit: rHGce9ee81df9ff: commitctx: extract _filecommit too.Jul 22 2020, 8:17 AM
Closed by commit rHGce9ee81df9ff: commitctx: extract _filecommit too (authored by marmoute). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/commit.py (143 lines)
Mmercurial/localrepo.py (139 lines)
Mtests/test-annotate.t (37 lines)
Mtests/test-fastannotate-hg.t (38 lines)

Diff 22043

mercurial/commit.py

# commit.py - fonction to perform commit # commit.py - fonction to perform commit
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
from __future__ import absolute_import from __future__ import absolute_import
import errno import errno
import weakref import weakref
from .i18n import _ from .i18n import _
from .node import ( from .node import (
hex, hex,
nullid,
nullrev, nullrev,
) )
from . import ( from . import (
context,
mergestate,
metadata, metadata,
phases, phases,
scmutil, scmutil,
subrepoutil, subrepoutil,
) )
def commitctx(repo, ctx, error=False, origctx=None): def commitctx(repo, ctx, error=False, origctx=None):
for f in sorted(ctx.modified() + ctx.added()): for f in sorted(ctx.modified() + ctx.added()):
repo.ui.note(uipathfn(f) + b"\n") repo.ui.note(uipathfn(f) + b"\n")
try: try:
fctx = ctx[f] fctx = ctx[f]
if fctx is None: if fctx is None:
removed.append(f) removed.append(f)
else: else:
added.append(f) added.append(f)
m[f], is_touched = repo._filecommit( m[f], is_touched = _filecommit(
fctx, m1, m2, linkrev, trp, writefilecopymeta, repo, fctx, m1, m2, linkrev, trp, writefilecopymeta,
) )
if is_touched: if is_touched:
touched.append(f) touched.append(f)
if writechangesetcopy and is_touched == 'added': if writechangesetcopy and is_touched == 'added':
filesadded.append(f) filesadded.append(f)
m.setflag(f, fctx.flags()) m.setflag(f, fctx.flags())
except OSError: except OSError:
repo.ui.warn(_(b"trouble committing %s!\n") % uipathfn(f)) repo.ui.warn(_(b"trouble committing %s!\n") % uipathfn(f))
if targetphase: if targetphase:
# retract boundary do not alter parent changeset. # retract boundary do not alter parent changeset.
# if a parent have higher the resulting phase will # if a parent have higher the resulting phase will
# be compliant anyway # be compliant anyway
# #
# if minimal phase was 0 we don't need to retract anything # if minimal phase was 0 we don't need to retract anything
phases.registernew(repo, tr, targetphase, [n]) phases.registernew(repo, tr, targetphase, [n])
return n return n
def _filecommit(
repo, fctx, manifest1, manifest2, linkrev, tr, includecopymeta,
):
"""
commit an individual file as part of a larger transaction
input:
fctx: a file context with the content we are trying to commit
manifest1: manifest of changeset first parent
manifest2: manifest of changeset second parent
linkrev: revision number of the changeset being created
tr: current transation
individual: boolean, set to False to skip storing the copy data
(only used by the Google specific feature of using
changeset extra as copy source of truth).
output: (filenode, touched)
filenode: the filenode that should be used by this changeset
touched: one of: None, 'added' or 'modified'
"""
fname = fctx.path()
fparent1 = manifest1.get(fname, nullid)
fparent2 = manifest2.get(fname, nullid)
touched = None
if fparent1 == fparent2 == nullid:
touched = 'added'
if isinstance(fctx, context.filectx):
# This block fast path most comparisons which are usually done. It
# assumes that bare filectx is used and no merge happened, hence no
# need to create a new file revision in this case.
node = fctx.filenode()
if node in [fparent1, fparent2]:
repo.ui.debug(b'reusing %s filelog entry\n' % fname)
if (
fparent1 != nullid and manifest1.flags(fname) != fctx.flags()
) or (
fparent2 != nullid and manifest2.flags(fname) != fctx.flags()
):
touched = 'modified'
return node, touched
flog = repo.file(fname)
meta = {}
cfname = fctx.copysource()
fnode = None
if cfname and cfname != fname:
# Mark the new revision of this file as a copy of another
# file. This copy data will effectively act as a parent
# of this new revision. If this is a merge, the first
# parent will be the nullid (meaning "look up the copy data")
# and the second one will be the other parent. For example:
#
# 0 --- 1 --- 3 rev1 changes file foo
# \ / rev2 renames foo to bar and changes it
# \- 2 -/ rev3 should have bar with all changes and
# should record that bar descends from
# bar in rev2 and foo in rev1
#
# this allows this merge to succeed:
#
# 0 --- 1 --- 3 rev4 reverts the content change from rev2
# \ / merging rev3 and rev4 should use bar@rev2
# \- 2 --- 4 as the merge base
#
cnode = manifest1.get(cfname)
newfparent = fparent2
if manifest2: # branch merge
if fparent2 == nullid or cnode is None: # copied on remote side
if cfname in manifest2:
cnode = manifest2[cfname]
newfparent = fparent1
# Here, we used to search backwards through history to try to find
# where the file copy came from if the source of a copy was not in
# the parent directory. However, this doesn't actually make sense to
# do (what does a copy from something not in your working copy even
# mean?) and it causes bugs (eg, issue4476). Instead, we will warn
# the user that copy information was dropped, so if they didn't
# expect this outcome it can be fixed, but this is the correct
# behavior in this circumstance.
if cnode:
repo.ui.debug(b" %s: copy %s:%s\n" % (fname, cfname, hex(cnode)))
if includecopymeta:
meta[b"copy"] = cfname
meta[b"copyrev"] = hex(cnode)
fparent1, fparent2 = nullid, newfparent
else:
repo.ui.warn(
_(
b"warning: can't find ancestor for '%s' "
b"copied from '%s'!\n"
)
% (fname, cfname)
)
elif fparent1 == nullid:
fparent1, fparent2 = fparent2, nullid
elif fparent2 != nullid:
# is one parent an ancestor of the other?
fparentancestors = flog.commonancestorsheads(fparent1, fparent2)
if fparent1 in fparentancestors:
fparent1, fparent2 = fparent2, nullid
elif fparent2 in fparentancestors:
fparent2 = nullid
elif not fparentancestors:
# TODO: this whole if-else might be simplified much more
ms = mergestate.mergestate.read(repo)
if (
fname in ms
and ms[fname] == mergestate.MERGE_RECORD_MERGED_OTHER
):
fparent1, fparent2 = fparent2, nullid
# is the file changed?
text = fctx.data()
if fparent2 != nullid or meta or flog.cmp(fparent1, text):
if touched is None: # do not overwrite added
touched = 'modified'
fnode = flog.add(text, meta, tr, linkrev, fparent1, fparent2)
# are just the flags changed during merge?
elif fname in manifest1 and manifest1.flags(fname) != fctx.flags():
touched = 'modified'
fnode = fparent1
else:
fnode = fparent1
return fnode, touched

mercurial/localrepo.py

if l is None or not l.held: if l is None or not l.held:
return None return None
return l return l
def currentwlock(self): def currentwlock(self):
"""Returns the wlock if it's held, or None if it's not.""" """Returns the wlock if it's held, or None if it's not."""
return self._currentlock(self._wlockref) return self._currentlock(self._wlockref)
def _filecommit(
self, fctx, manifest1, manifest2, linkrev, tr, includecopymeta,
):
"""
commit an individual file as part of a larger transaction
input:
fctx: a file context with the content we are trying to commit
manifest1: manifest of changeset first parent
manifest2: manifest of changeset second parent
linkrev: revision number of the changeset being created
tr: current transation
individual: boolean, set to False to skip storing the copy data
(only used by the Google specific feature of using
changeset extra as copy source of truth).
output: (filenode, touched)
filenode: the filenode that should be used by this changeset
touched: one of: None, 'added' or 'modified'
"""
fname = fctx.path()
fparent1 = manifest1.get(fname, nullid)
fparent2 = manifest2.get(fname, nullid)
touched = None
if fparent1 == fparent2 == nullid:
touched = 'added'
if isinstance(fctx, context.filectx):
# This block fast path most comparisons which are usually done. It
# assumes that bare filectx is used and no merge happened, hence no
# need to create a new file revision in this case.
node = fctx.filenode()
if node in [fparent1, fparent2]:
self.ui.debug(b'reusing %s filelog entry\n' % fname)
if (
fparent1 != nullid
and manifest1.flags(fname) != fctx.flags()
) or (
fparent2 != nullid
and manifest2.flags(fname) != fctx.flags()
):
touched = 'modified'
return node, touched
flog = self.file(fname)
meta = {}
cfname = fctx.copysource()
fnode = None
if cfname and cfname != fname:
# Mark the new revision of this file as a copy of another
# file. This copy data will effectively act as a parent
# of this new revision. If this is a merge, the first
# parent will be the nullid (meaning "look up the copy data")
# and the second one will be the other parent. For example:
#
# 0 --- 1 --- 3 rev1 changes file foo
# \ / rev2 renames foo to bar and changes it
# \- 2 -/ rev3 should have bar with all changes and
# should record that bar descends from
# bar in rev2 and foo in rev1
#
# this allows this merge to succeed:
#
# 0 --- 1 --- 3 rev4 reverts the content change from rev2
# \ / merging rev3 and rev4 should use bar@rev2
# \- 2 --- 4 as the merge base
#
cnode = manifest1.get(cfname)
newfparent = fparent2
if manifest2: # branch merge
if fparent2 == nullid or cnode is None: # copied on remote side
if cfname in manifest2:
cnode = manifest2[cfname]
newfparent = fparent1
# Here, we used to search backwards through history to try to find
# where the file copy came from if the source of a copy was not in
# the parent directory. However, this doesn't actually make sense to
# do (what does a copy from something not in your working copy even
# mean?) and it causes bugs (eg, issue4476). Instead, we will warn
# the user that copy information was dropped, so if they didn't
# expect this outcome it can be fixed, but this is the correct
# behavior in this circumstance.
if cnode:
self.ui.debug(
b" %s: copy %s:%s\n" % (fname, cfname, hex(cnode))
)
if includecopymeta:
meta[b"copy"] = cfname
meta[b"copyrev"] = hex(cnode)
fparent1, fparent2 = nullid, newfparent
else:
self.ui.warn(
_(
b"warning: can't find ancestor for '%s' "
b"copied from '%s'!\n"
)
% (fname, cfname)
)
elif fparent1 == nullid:
fparent1, fparent2 = fparent2, nullid
elif fparent2 != nullid:
# is one parent an ancestor of the other?
fparentancestors = flog.commonancestorsheads(fparent1, fparent2)
if fparent1 in fparentancestors:
fparent1, fparent2 = fparent2, nullid
elif fparent2 in fparentancestors:
fparent2 = nullid
elif not fparentancestors:
# TODO: this whole if-else might be simplified much more
ms = mergestatemod.mergestate.read(self)
if (
fname in ms
and ms[fname] == mergestatemod.MERGE_RECORD_MERGED_OTHER
):
fparent1, fparent2 = fparent2, nullid
# is the file changed?
text = fctx.data()
if fparent2 != nullid or meta or flog.cmp(fparent1, text):
if touched is None: # do not overwrite added
touched = 'modified'
fnode = flog.add(text, meta, tr, linkrev, fparent1, fparent2)
# are just the flags changed during merge?
elif fname in manifest1 and manifest1.flags(fname) != fctx.flags():
touched = 'modified'
fnode = fparent1
else:
fnode = fparent1
return fnode, touched
def checkcommitpatterns(self, wctx, match, status, fail): def checkcommitpatterns(self, wctx, match, status, fail):
"""check for commit arguments that aren't committable""" """check for commit arguments that aren't committable"""
if match.isexact() or match.prefix(): if match.isexact() or match.prefix():
matched = set(status.modified + status.added + status.removed) matched = set(status.modified + status.added + status.removed)
for f in match.files(): for f in match.files():
f = self.dirstate.normalize(f) f = self.dirstate.normalize(f)
if f == b'.' or f in matched or f in wctx.substate: if f == b'.' or f in matched or f in wctx.substate:

tests/test-annotate.t

to reproduce the situation with recent Mercurial, this script uses (1) to reproduce the situation with recent Mercurial, this script uses (1)
"hg debugsetparents" to merge without ancestor check by "hg merge", "hg debugsetparents" to merge without ancestor check by "hg merge",
and (2) the extension to allow filelog merging between the revision and (2) the extension to allow filelog merging between the revision
and its ancestor by overriding "repo._filecommit". and its ancestor by overriding "repo._filecommit".
$ cat > ../legacyrepo.py <<EOF $ cat > ../legacyrepo.py <<EOF
> from __future__ import absolute_import > from __future__ import absolute_import
> from mercurial import error, node > from mercurial import commit, error, extensions, node
> def reposetup(ui, repo): > def _filecommit(orig, repo, fctx, manifest1, manifest2,
> class legacyrepo(repo.__class__):
> def _filecommit(self, fctx, manifest1, manifest2,
> linkrev, tr, includecopymeta): > linkrev, tr, includecopymeta):
> fname = fctx.path() > fname = fctx.path()
> text = fctx.data() > text = fctx.data()
> flog = self.file(fname) > flog = repo.file(fname)
> fparent1 = manifest1.get(fname, node.nullid) > fparent1 = manifest1.get(fname, node.nullid)
> fparent2 = manifest2.get(fname, node.nullid) > fparent2 = manifest2.get(fname, node.nullid)
> meta = {} > meta = {}
> copy = fctx.copysource() > copy = fctx.copysource()
> if copy and copy != fname: > if copy and copy != fname:
> raise error.Abort('copying is not supported') > raise error.Abort('copying is not supported')
> if fparent2 != node.nullid: > if fparent2 != node.nullid:
> return flog.add(text, meta, tr, linkrev, > return flog.add(text, meta, tr, linkrev,
> fparent1, fparent2), 'modified' > fparent1, fparent2), 'modified'
> raise error.Abort('only merging is supported') > raise error.Abort('only merging is supported')
> repo.__class__ = legacyrepo > def uisetup(ui):
> extensions.wrapfunction(commit, '_filecommit', _filecommit)
> EOF > EOF
$ cat > baz <<EOF $ cat > baz <<EOF
> 1 > 1
> 2 > 2
> 3 > 3
> 4 > 4
> 5 > 5

tests/test-fastannotate-hg.t

merging between the revision and its ancestor merging between the revision and its ancestor
to reproduce the situation with recent Mercurial, this script uses (1) to reproduce the situation with recent Mercurial, this script uses (1)
"hg debugsetparents" to merge without ancestor check by "hg merge", "hg debugsetparents" to merge without ancestor check by "hg merge",
and (2) the extension to allow filelog merging between the revision and (2) the extension to allow filelog merging between the revision
and its ancestor by overriding "repo._filecommit". and its ancestor by overriding "repo._filecommit".
$ cat > ../legacyrepo.py <<EOF $ cat > ../legacyrepo.py <<EOF
> from mercurial import error, node > from __future__ import absolute_import
> def reposetup(ui, repo): > from mercurial import commit, error, extensions, node
> class legacyrepo(repo.__class__): > def _filecommit(orig, repo, fctx, manifest1, manifest2,
> def _filecommit(self, fctx, manifest1, manifest2,
> linkrev, tr, includecopymeta): > linkrev, tr, includecopymeta):
> fname = fctx.path() > fname = fctx.path()
> text = fctx.data() > text = fctx.data()
> flog = self.file(fname) > flog = repo.file(fname)
> fparent1 = manifest1.get(fname, node.nullid) > fparent1 = manifest1.get(fname, node.nullid)
> fparent2 = manifest2.get(fname, node.nullid) > fparent2 = manifest2.get(fname, node.nullid)
> meta = {} > meta = {}
> copy = fctx.renamed() > copy = fctx.copysource()
> if copy and copy[0] != fname: > if copy and copy != fname:
> raise error.Abort('copying is not supported') > raise error.Abort('copying is not supported')
> if fparent2 != node.nullid: > if fparent2 != node.nullid:
> return flog.add(text, meta, tr, linkrev, > return flog.add(text, meta, tr, linkrev,
> fparent1, fparent2), 'modified' > fparent1, fparent2), 'modified'
> raise error.Abort('only merging is supported') > raise error.Abort('only merging is supported')
> repo.__class__ = legacyrepo > def uisetup(ui):
> extensions.wrapfunction(commit, '_filecommit', _filecommit)
> EOF > EOF
$ cat > baz <<EOF $ cat > baz <<EOF
> 1 > 1
> 2 > 2
> 3 > 3
> 4 > 4
> 5 > 5