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.

Download Raw Diff

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

Herald added a reviewer: hg-reviewers. · View Herald TranscriptFeb 8 2019, 3:30 AM

Herald added a subscriber: mercurial-devel. · View Herald Transcript

martinvonz added a child revision: D5895: diff: make `hg diff --root=subrepo` work.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

			Path	Packages
M			mercurial/context.py (7 lines)
M			mercurial/logcmdutil.py (15 lines)
M			mercurial/patch.py (37 lines)

Diff	ID	Description	Created	Lint	Unit
Base		Base
Diff 1	13908		Feb 8 2019, 3:30 AM	★	★
Diff 2	13927		Feb 8 2019, 3:18 PM	★	★
Diff 3	13967		Feb 9 2019, 5:20 PM	★	★
Diff 4	13978	rHGd4c9eebdd72d1d97ae5071559c3e85f729152cc6	Feb 7 2019, 2:12 AM	★	★

Status	Author	Revision
Closed	martinvonz	D5916 scmutil: respect ui.relative-paths in default match.badfn
Closed	martinvonz	D5915 cmdutil: migrate previously missed instances to uipathfn
Closed	martinvonz	D5914 cat: respect ui.relative-paths for "skipping missing subrepository"
Closed	martinvonz	D5913 addremove: use uipathfn instead of m.rel() for recorded similatity message
Closed	martinvonz	D5912 forget: use relative paths for --interactive
Closed	martinvonz	D5910 automv: respect ui.relative-paths
Closed	martinvonz	D5909 debugwalk: avoid match.rel() and use repo.pathto() instead
Closed	martinvonz	D5908 match: delete unused abs() (API)
Closed	martinvonz	D5907 copy: respect ui.relative-paths in copy/rename
Closed	martinvonz	D5906 match: delete unused uipath() and _uipathrelative (API)
Closed	martinvonz	D5905 diff: respect ui.relative-paths for warning about path outside --root
Closed	martinvonz	D5904 largefiles: use uipathfn instead of match.{rel,uipath}() (API)
Closed	martinvonz	D5911 forget: pass around uipathfn and use instead of m.rel() (API)
Closed	martinvonz	D5903 addremove: pass around uipathfn and use instead of m.uipath() (API)
Closed	martinvonz	D5902 remove: pass around uipathfn and use instead of m.rel() (API)
Closed	martinvonz	D5901 add: pass around uipathfn and use instead of m.rel() (API)
Closed	martinvonz	D5900 subrepo: (mostly) use relative path in "skipping missing subrepository"
Closed	martinvonz	D5899 subrepo: use relative path for "already tracked" message
Closed	martinvonz	D5924 match: delete unused argument "listsubrepos" from _buildmatch()
Closed	martinvonz	D5923 match: delete unused rel() (API)
Closed	martinvonz	D5922 largefiles: get cwd and relative paths from repo instead of matcher
Closed	martinvonz	D5921 scmutil: remove special handling of pats==("",) in matchandpats() (API)
Closed	martinvonz	D5896 diff: make --stat respect ui.relative-paths
Closed	martinvonz	D5895 diff: make `hg diff --root=subrepo` work
Closed	martinvonz	D5894 patch: replace "prefix" and "relroot" arguments by "pathfn" (API)
Closed	martinvonz	D5893 patch: accept second matcher that applies only to copy sources (API)
Closed	martinvonz	D5892 patch: let caller pass in root-filtering matcher (API)
Closed	martinvonz	D5891 patch: pass in context objects into diffhunks() (API)

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])