This is an archive of the discontinued Mercurial Phabricator instance.

Differential D5894

patch: replace "prefix" and "relroot" arguments by "pathfn" (API)
ClosedPublic

Authored by martinvonz on Feb 8 2019, 3:30 AM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHGd4c9eebdd72d: patch: replace "prefix" and "relroot" arguments by "pathfn" (API)
Summary

The two arguments serve a very similar purpose: "relroot" is stripped
from the front of the path, and then "prefix" (a subrepo path) is
added (also to the front). Passing in a function that does that is
more generic and will make it easier to respect ui.relative-paths in
later patches (don't worry, I'm not going to respect that option for
regular patches, only for --stat). I'm deliberately not calling it
"uipathfn", because it's generally for producing valid diffs
(including when prefix is non-empty), so things like using backslash
on Windows is not an option.

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.Feb 8 2019, 3:30 AM
martinvonz updated this revision to Diff 13927.Feb 8 2019, 3:18 PM
martinvonz updated this revision to Diff 13967.Feb 9 2019, 5:20 PM
Closed by commit rHGd4c9eebdd72d: patch: replace "prefix" and "relroot" arguments by "pathfn" (API) (authored by martinvonz). · Explain WhyFeb 9 2019, 10:37 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/context.py (7 lines)
Mmercurial/logcmdutil.py (15 lines)
Mmercurial/patch.py (37 lines)

Diff 13978

mercurial/context.py

listsubrepos=False, badfn=None): listsubrepos=False, badfn=None):
r = self._repo r = self._repo
return matchmod.match(r.root, r.getcwd(), pats, return matchmod.match(r.root, r.getcwd(), pats,
include, exclude, default, include, exclude, default,
auditor=r.nofsauditor, ctx=self, auditor=r.nofsauditor, ctx=self,
listsubrepos=listsubrepos, badfn=badfn) listsubrepos=listsubrepos, badfn=badfn)
def diff(self, ctx2=None, match=None, changes=None, opts=None, def diff(self, ctx2=None, match=None, changes=None, opts=None,
losedatafn=None, prefix='', relroot='', copy=None, losedatafn=None, pathfn=None, copy=None,
copysourcematch=None, hunksfilterfn=None): copysourcematch=None, hunksfilterfn=None):
"""Returns a diff generator for the given contexts and matcher""" """Returns a diff generator for the given contexts and matcher"""
if ctx2 is None: if ctx2 is None:
ctx2 = self.p1() ctx2 = self.p1()
if ctx2 is not None: if ctx2 is not None:
ctx2 = self._repo[ctx2] ctx2 = self._repo[ctx2]
return patch.diff(self._repo, ctx2, self, match=match, changes=changes, return patch.diff(self._repo, ctx2, self, match=match, changes=changes,
opts=opts, losedatafn=losedatafn, prefix=prefix, opts=opts, losedatafn=losedatafn, pathfn=pathfn,
relroot=relroot, copy=copy, copy=copy, copysourcematch=copysourcematch,
copysourcematch=copysourcematch,
hunksfilterfn=hunksfilterfn) hunksfilterfn=hunksfilterfn)
def dirs(self): def dirs(self):
return self._manifest.dirs() return self._manifest.dirs()
def hasdir(self, dir): def hasdir(self, dir):
return self._manifest.hasdir(dir) return self._manifest.hasdir(dir)

mercurial/logcmdutil.py

# logcmdutil.py - utility for log-like commands # logcmdutil.py - utility for log-like commands
# #
# Copyright 2005-2007 Matt Mackall <mpm@selenic.com> # Copyright 2005-2007 Matt Mackall <mpm@selenic.com>
# #
# 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 itertools import itertools
import os import os
import posixpath
from .i18n import _ from .i18n import _
from .node import ( from .node import (
nullid, nullid,
wdirid, wdirid,
wdirrev, wdirrev,
) )
'''show diff or diffstat.''' '''show diff or diffstat.'''
ctx1 = repo[node1] ctx1 = repo[node1]
ctx2 = repo[node2] ctx2 = repo[node2]
if root: if root:
relroot = pathutil.canonpath(repo.root, repo.getcwd(), root) relroot = pathutil.canonpath(repo.root, repo.getcwd(), root)
else: else:
relroot = '' relroot = ''
copysourcematch = None copysourcematch = None
def pathfn(f):
return posixpath.join(prefix, f)
if relroot != '': if relroot != '':
# XXX relative roots currently don't work if the root is within a # XXX relative roots currently don't work if the root is within a
# subrepo # subrepo
uirelroot = match.uipath(relroot) uirelroot = match.uipath(relroot)
relroot += '/' relroot += '/'
for matchroot in match.files(): for matchroot in match.files():
if not matchroot.startswith(relroot): if not matchroot.startswith(relroot):
ui.warn(_('warning: %s not inside relative root %s\n') % ( ui.warn(_('warning: %s not inside relative root %s\n') % (
match.uipath(matchroot), uirelroot)) match.uipath(matchroot), uirelroot))
relrootmatch = scmutil.match(ctx2, pats=[relroot], default='path') relrootmatch = scmutil.match(ctx2, pats=[relroot], default='path')
match = matchmod.intersectmatchers(match, relrootmatch) match = matchmod.intersectmatchers(match, relrootmatch)
copysourcematch = relrootmatch copysourcematch = relrootmatch
checkroot = (repo.ui.configbool('devel', 'all-warnings') or
repo.ui.configbool('devel', 'check-relroot'))
def pathfn(f):
if checkroot and not f.startswith(relroot):
raise AssertionError(
"file %s doesn't start with relroot %s" % (f, relroot))
return posixpath.join(prefix, f[len(relroot):])
if stat: if stat:
diffopts = diffopts.copy(context=0, noprefix=False) diffopts = diffopts.copy(context=0, noprefix=False)
width = 80 width = 80
if not ui.plain(): if not ui.plain():
width = ui.termwidth() - graphwidth width = ui.termwidth() - graphwidth
chunks = ctx2.diff(ctx1, match, changes, opts=diffopts, prefix=prefix, chunks = ctx2.diff(ctx1, match, changes, opts=diffopts, pathfn=pathfn,
relroot=relroot, copysourcematch=copysourcematch, copysourcematch=copysourcematch,
hunksfilterfn=hunksfilterfn) hunksfilterfn=hunksfilterfn)
if fp is not None or ui.canwritewithoutlabels(): if fp is not None or ui.canwritewithoutlabels():
out = fp or ui out = fp or ui
if stat: if stat:
chunks = [patch.diffstat(util.iterlines(chunks), width=width)] chunks = [patch.diffstat(util.iterlines(chunks), width=width)]
for chunk in util.filechunkiter(util.chunkbuffer(chunks)): for chunk in util.filechunkiter(util.chunkbuffer(chunks)):
out.write(chunk) out.write(chunk)

mercurial/patch.py

import collections import collections
import contextlib import contextlib
import copy import copy
import email import email
import errno import errno
import hashlib import hashlib
import os import os
import posixpath
import re import re
import shutil import shutil
import zlib import zlib
from .i18n import _ from .i18n import _
from .node import ( from .node import (
hex, hex,
short, short,
class GitDiffRequired(Exception): class GitDiffRequired(Exception):
pass pass
diffopts = diffutil.diffallopts diffopts = diffutil.diffallopts
diffallopts = diffutil.diffallopts diffallopts = diffutil.diffallopts
difffeatureopts = diffutil.difffeatureopts difffeatureopts = diffutil.difffeatureopts
def diff(repo, node1=None, node2=None, match=None, changes=None, def diff(repo, node1=None, node2=None, match=None, changes=None,
opts=None, losedatafn=None, prefix='', relroot='', copy=None, opts=None, losedatafn=None, pathfn=None, copy=None,
copysourcematch=None, hunksfilterfn=None): copysourcematch=None, hunksfilterfn=None):
'''yields diff of changes to files between two nodes, or node and '''yields diff of changes to files between two nodes, or node and
working directory. working directory.
if node1 is None, use first dirstate parent instead. if node1 is None, use first dirstate parent instead.
if node2 is None, compare node1 with working directory. if node2 is None, compare node1 with working directory.
losedatafn(**kwarg) is a callable run when opts.upgrade=True and losedatafn(**kwarg) is a callable run when opts.upgrade=True and
''' '''
if not node1 and not node2: if not node1 and not node2:
node1 = repo.dirstate.p1() node1 = repo.dirstate.p1()
ctx1 = repo[node1] ctx1 = repo[node1]
ctx2 = repo[node2] ctx2 = repo[node2]
for fctx1, fctx2, hdr, hunks in diffhunks( for fctx1, fctx2, hdr, hunks in diffhunks(
repo, ctx1=ctx1, ctx2=ctx2, repo, ctx1=ctx1, ctx2=ctx2, match=match, changes=changes, opts=opts,
match=match, changes=changes, opts=opts, losedatafn=losedatafn, pathfn=pathfn, copy=copy,
losedatafn=losedatafn, prefix=prefix, relroot=relroot, copy=copy,
copysourcematch=copysourcematch): copysourcematch=copysourcematch):
if hunksfilterfn is not None: if hunksfilterfn is not None:
# If the file has been removed, fctx2 is None; but this should # If the file has been removed, fctx2 is None; but this should
# not occur here since we catch removed files early in # not occur here since we catch removed files early in
# logcmdutil.getlinerangerevs() for 'hg log -L'. # logcmdutil.getlinerangerevs() for 'hg log -L'.
assert fctx2 is not None, \ assert fctx2 is not None, \
'fctx2 unexpectly None in diff hunks filtering' 'fctx2 unexpectly None in diff hunks filtering'
hunks = hunksfilterfn(fctx2, hunks) hunks = hunksfilterfn(fctx2, hunks)
text = ''.join(sum((list(hlines) for hrange, hlines in hunks), [])) text = ''.join(sum((list(hlines) for hrange, hlines in hunks), []))
if hdr and (text or len(hdr) > 1): if hdr and (text or len(hdr) > 1):
yield '\n'.join(hdr) + '\n' yield '\n'.join(hdr) + '\n'
if text: if text:
yield text yield text
def diffhunks(repo, ctx1, ctx2, match=None, changes=None, def diffhunks(repo, ctx1, ctx2, match=None, changes=None, opts=None,
opts=None, losedatafn=None, prefix='', relroot='', copy=None, losedatafn=None, pathfn=None, copy=None, copysourcematch=None):
copysourcematch=None):
"""Yield diff of changes to files in the form of (`header`, `hunks`) tuples """Yield diff of changes to files in the form of (`header`, `hunks`) tuples
where `header` is a list of diff headers and `hunks` is an iterable of where `header` is a list of diff headers and `hunks` is an iterable of
(`hunkrange`, `hunklines`) tuples. (`hunkrange`, `hunklines`) tuples.
See diff() for the meaning of parameters. See diff() for the meaning of parameters.
""" """
if opts is None: if opts is None:
del copy[dst] del copy[dst]
prefetchmatch = scmutil.matchfiles( prefetchmatch = scmutil.matchfiles(
repo, list(modifiedset | addedset | removedset)) repo, list(modifiedset | addedset | removedset))
scmutil.prefetchfiles(repo, [ctx1.rev(), ctx2.rev()], prefetchmatch) scmutil.prefetchfiles(repo, [ctx1.rev(), ctx2.rev()], prefetchmatch)
def difffn(opts, losedata): def difffn(opts, losedata):
return trydiff(repo, revs, ctx1, ctx2, modified, added, removed, return trydiff(repo, revs, ctx1, ctx2, modified, added, removed,
copy, getfilectx, opts, losedata, prefix, relroot) copy, getfilectx, opts, losedata, pathfn)
if opts.upgrade and not opts.git: if opts.upgrade and not opts.git:
try: try:
def losedata(fn): def losedata(fn):
if not losedatafn or not losedatafn(fn=fn): if not losedatafn or not losedatafn(fn=fn):
raise GitDiffRequired raise GitDiffRequired
# Buffer the whole output until we are sure it can be generated # Buffer the whole output until we are sure it can be generated
return list(difffn(opts.copy(git=False), losedata)) return list(difffn(opts.copy(git=False), losedata))
except GitDiffRequired: except GitDiffRequired:
if opts.git: if opts.git:
# have we already reported a copy above? # have we already reported a copy above?
if (f in copyto and copyto[f] in addedset if (f in copyto and copyto[f] in addedset
and copy[copyto[f]] == f): and copy[copyto[f]] == f):
continue continue
yield f1, f2, copyop yield f1, f2, copyop
def trydiff(repo, revs, ctx1, ctx2, modified, added, removed, def trydiff(repo, revs, ctx1, ctx2, modified, added, removed,
copy, getfilectx, opts, losedatafn, prefix, relroot): copy, getfilectx, opts, losedatafn, pathfn):
'''given input data, generate a diff and yield it in blocks '''given input data, generate a diff and yield it in blocks
If generating a diff would lose data like flags or binary data and If generating a diff would lose data like flags or binary data and
losedatafn is not None, it will be called. losedatafn is not None, it will be called.
relroot is removed and prefix is added to every path in the diff output. pathfn is applied to every path in the diff output.
'''
If relroot is not empty, this function expects every path in modified,
added, removed and copy to start with it.'''
def gitindex(text): def gitindex(text):
if not text: if not text:
text = "" text = ""
l = len(text) l = len(text)
s = hashlib.sha1('blob %d\0' % l) s = hashlib.sha1('blob %d\0' % l)
s.update(text) s.update(text)
return hex(s.digest()) return hex(s.digest())
def isempty(fctx): def isempty(fctx):
return fctx is None or fctx.size() == 0 return fctx is None or fctx.size() == 0
date1 = dateutil.datestr(ctx1.date()) date1 = dateutil.datestr(ctx1.date())
date2 = dateutil.datestr(ctx2.date()) date2 = dateutil.datestr(ctx2.date())
gitmode = {'l': '120000', 'x': '100755', '': '100644'} gitmode = {'l': '120000', 'x': '100755', '': '100644'}
if relroot != '' and (repo.ui.configbool('devel', 'all-warnings') if not pathfn:
or repo.ui.configbool('devel', 'check-relroot')): pathfn = lambda f: f
for f in modified + added + removed + list(copy) + list(copy.values()):
if f is not None and not f.startswith(relroot):
raise AssertionError(
"file %s doesn't start with relroot %s" % (f, relroot))
for f1, f2, copyop in _filepairs(modified, added, removed, copy, opts): for f1, f2, copyop in _filepairs(modified, added, removed, copy, opts):
content1 = None content1 = None
content2 = None content2 = None
fctx1 = None fctx1 = None
fctx2 = None fctx2 = None
flag1 = None flag1 = None
flag2 = None flag2 = None
# empty file deletion # empty file deletion
(isempty(fctx1) and not f2) or (isempty(fctx1) and not f2) or
# create with flags # create with flags
(not f1 and flag2) or (not f1 and flag2) or
# change flags # change flags
(f1 and f2 and flag1 != flag2)): (f1 and f2 and flag1 != flag2)):
losedatafn(f2 or f1) losedatafn(f2 or f1)
path1 = f1 or f2 path1 = pathfn(f1 or f2)
path2 = f2 or f1 path2 = pathfn(f2 or f1)
path1 = posixpath.join(prefix, path1[len(relroot):])
path2 = posixpath.join(prefix, path2[len(relroot):])
header = [] header = []
if opts.git: if opts.git:
header.append('diff --git %s%s %s%s' % header.append('diff --git %s%s %s%s' %
(aprefix, path1, bprefix, path2)) (aprefix, path1, bprefix, path2))
if not f1: # added if not f1: # added
header.append('new file mode %s' % gitmode[flag2]) header.append('new file mode %s' % gitmode[flag2])
elif not f2: # removed elif not f2: # removed
header.append('deleted file mode %s' % gitmode[flag1]) header.append('deleted file mode %s' % gitmode[flag1])