This is an archive of the discontinued Mercurial Phabricator instance.

Differential D5176

archive: change "matcnfn" argument to a real matcher
ClosedPublic

Authored by martinvonz on Oct 20 2018, 2:32 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG3d76a8e627a6: archive: change "matcnfn" argument to a real matcher
Summary

All callers seem to be passing a real matcher, not just a function. We
were also passing it into match.subdirmatcher(), which assumes it is a
matcher.

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.Oct 20 2018, 2:32 PM
Closed by commit rHG3d76a8e627a6: archive: change "matcnfn" argument to a real matcher (authored by martinvonz). · Explain WhyOct 22 2018, 3:15 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 12311

hgext/extdiff.py

else: else:
ui.note(_('making snapshot of %d files from working directory\n') % ui.note(_('making snapshot of %d files from working directory\n') %
(len(files))) (len(files)))
if files: if files:
repo.ui.setconfig("ui", "archivemeta", False) repo.ui.setconfig("ui", "archivemeta", False)
archival.archive(repo, base, node, 'files', archival.archive(repo, base, node, 'files',
matchfn=scmutil.matchfiles(repo, files), match=scmutil.matchfiles(repo, files),
subrepos=listsubrepos) subrepos=listsubrepos)
for fn in sorted(files): for fn in sorted(files):
wfn = util.pconvert(fn) wfn = util.pconvert(fn)
ui.note(' %s\n' % wfn) ui.note(' %s\n' % wfn)
if node is None: if node is None:
dest = os.path.join(base, wfn) dest = os.path.join(base, wfn)

hgext/largefiles/overrides.py

def hgwebarchive(orig, web): def hgwebarchive(orig, web):
web.repo.lfstatus = True web.repo.lfstatus = True
try: try:
return orig(web) return orig(web)
finally: finally:
web.repo.lfstatus = False web.repo.lfstatus = False
def overridearchive(orig, repo, dest, node, kind, decode=True, matchfn=None, def overridearchive(orig, repo, dest, node, kind, decode=True, match=None,
prefix='', mtime=None, subrepos=None): prefix='', mtime=None, subrepos=None):
# For some reason setting repo.lfstatus in hgwebarchive only changes the # For some reason setting repo.lfstatus in hgwebarchive only changes the
# unfiltered repo's attr, so check that as well. # unfiltered repo's attr, so check that as well.
if not repo.lfstatus and not repo.unfiltered().lfstatus: if not repo.lfstatus and not repo.unfiltered().lfstatus:
return orig(repo, dest, node, kind, decode, matchfn, prefix, mtime, return orig(repo, dest, node, kind, decode, match, prefix, mtime,
subrepos) subrepos)
# No need to lock because we are only reading history and # No need to lock because we are only reading history and
# largefile caches, neither of which are modified. # largefile caches, neither of which are modified.
if node is not None: if node is not None:
lfcommands.cachelfiles(repo.ui, repo, node) lfcommands.cachelfiles(repo.ui, repo, node)
if kind not in archival.archivers: if kind not in archival.archivers:
raise error.Abort(_("unknown archive type '%s'") % kind) raise error.Abort(_("unknown archive type '%s'") % kind)
ctx = repo[node] ctx = repo[node]
if kind == 'files': if kind == 'files':
if prefix: if prefix:
raise error.Abort( raise error.Abort(
_('cannot give prefix when archiving to files')) _('cannot give prefix when archiving to files'))
else: else:
prefix = archival.tidyprefix(dest, kind, prefix) prefix = archival.tidyprefix(dest, kind, prefix)
def write(name, mode, islink, getdata): def write(name, mode, islink, getdata):
if matchfn and not matchfn(name): if match and not match(name):
return return
data = getdata() data = getdata()
if decode: if decode:
data = repo.wwritedata(name, data) data = repo.wwritedata(name, data)
archiver.addfile(prefix + name, mode, islink, data) archiver.addfile(prefix + name, mode, islink, data)
archiver = archival.archivers[kind](dest, mtime or ctx.date()[0]) archiver = archival.archivers[kind](dest, mtime or ctx.date()[0])
f = lfile f = lfile
getdata = lambda: util.readfile(path) getdata = lambda: util.readfile(path)
write(f, 'x' in ff and 0o755 or 0o644, 'l' in ff, getdata) write(f, 'x' in ff and 0o755 or 0o644, 'l' in ff, getdata)
if subrepos: if subrepos:
for subpath in sorted(ctx.substate): for subpath in sorted(ctx.substate):
sub = ctx.workingsub(subpath) sub = ctx.workingsub(subpath)
submatch = matchmod.subdirmatcher(subpath, matchfn) submatch = matchmod.subdirmatcher(subpath, match)
sub._repo.lfstatus = True sub._repo.lfstatus = True
sub.archive(archiver, prefix, submatch) sub.archive(archiver, prefix, submatch)
archiver.done() archiver.done()
def hgsubrepoarchive(orig, repo, archiver, prefix, match=None, decode=True): def hgsubrepoarchive(orig, repo, archiver, prefix, match=None, decode=True):
lfenabled = util.safehasattr(repo._repo, '_largefilesenabled') lfenabled = util.safehasattr(repo._repo, '_largefilesenabled')
if not lfenabled or not repo._repo.lfstatus: if not lfenabled or not repo._repo.lfstatus:

mercurial/archival.py

'files': fileit, 'files': fileit,
'tar': tarit, 'tar': tarit,
'tbz2': lambda name, mtime: tarit(name, mtime, 'bz2'), 'tbz2': lambda name, mtime: tarit(name, mtime, 'bz2'),
'tgz': lambda name, mtime: tarit(name, mtime, 'gz'), 'tgz': lambda name, mtime: tarit(name, mtime, 'gz'),
'uzip': lambda name, mtime: zipit(name, mtime, False), 'uzip': lambda name, mtime: zipit(name, mtime, False),
'zip': zipit, 'zip': zipit,
} }
def archive(repo, dest, node, kind, decode=True, matchfn=None, def archive(repo, dest, node, kind, decode=True, match=None,
prefix='', mtime=None, subrepos=False): prefix='', mtime=None, subrepos=False):
'''create archive of repo as it was at node. '''create archive of repo as it was at node.
dest can be name of directory, name of archive file, or file dest can be name of directory, name of archive file, or file
object to write archive to. object to write archive to.
kind is type of archive to create. kind is type of archive to create.
decode tells whether to put files through decode filters from decode tells whether to put files through decode filters from
hgrc. hgrc.
matchfn is function to filter names of files to write to archive. match is a matcher to filter names of files to write to archive.
prefix is name of path to put before every archive member. prefix is name of path to put before every archive member.
mtime is the modified time, in seconds, or None to use the changeset time. mtime is the modified time, in seconds, or None to use the changeset time.
subrepos tells whether to include subrepos. subrepos tells whether to include subrepos.
''' '''
if kind not in archivers: if kind not in archivers:
raise error.Abort(_("unknown archive type '%s'") % kind) raise error.Abort(_("unknown archive type '%s'") % kind)
ctx = repo[node] ctx = repo[node]
archiver = archivers[kind](dest, mtime or ctx.date()[0]) archiver = archivers[kind](dest, mtime or ctx.date()[0])
if repo.ui.configbool("ui", "archivemeta"): if repo.ui.configbool("ui", "archivemeta"):
name = '.hg_archival.txt' name = '.hg_archival.txt'
if not matchfn or matchfn(name): if not match or match(name):
write(name, 0o644, False, lambda: buildmetadata(ctx)) write(name, 0o644, False, lambda: buildmetadata(ctx))
if matchfn: if match:
files = [f for f in ctx.manifest().keys() if matchfn(f)] files = [f for f in ctx.manifest().keys() if match(f)]
else: else:
files = ctx.manifest().keys() files = ctx.manifest().keys()
total = len(files) total = len(files)
if total: if total:
files.sort() files.sort()
scmutil.prefetchfiles(repo, [ctx.rev()], scmutil.prefetchfiles(repo, [ctx.rev()],
scmutil.matchfiles(repo, files)) scmutil.matchfiles(repo, files))
progress = scmutil.progress(repo.ui, _('archiving'), unit=_('files'), progress = scmutil.progress(repo.ui, _('archiving'), unit=_('files'),
total=total) total=total)
progress.update(0) progress.update(0)
for f in files: for f in files:
ff = ctx.flags(f) ff = ctx.flags(f)
write(f, 'x' in ff and 0o755 or 0o644, 'l' in ff, ctx[f].data) write(f, 'x' in ff and 0o755 or 0o644, 'l' in ff, ctx[f].data)
progress.increment(item=f) progress.increment(item=f)
progress.complete() progress.complete()
if subrepos: if subrepos:
for subpath in sorted(ctx.substate): for subpath in sorted(ctx.substate):
sub = ctx.workingsub(subpath) sub = ctx.workingsub(subpath)
submatch = matchmod.subdirmatcher(subpath, matchfn) submatch = matchmod.subdirmatcher(subpath, match)
total += sub.archive(archiver, prefix, submatch, decode) total += sub.archive(archiver, prefix, submatch, decode)
if total == 0: if total == 0:
raise error.Abort(_('no files match the archive pattern')) raise error.Abort(_('no files match the archive pattern'))
archiver.done() archiver.done()
return total return total

mercurial/hgweb/webcommands.py

web.res.setbodywillwrite() web.res.setbodywillwrite()
if list(web.res.sendresponse()): if list(web.res.sendresponse()):
raise error.ProgrammingError('sendresponse() should not emit data ' raise error.ProgrammingError('sendresponse() should not emit data '
'if writing later') 'if writing later')
bodyfh = web.res.getbodyfile() bodyfh = web.res.getbodyfile()
archival.archive(web.repo, bodyfh, cnode, artype, prefix=name, archival.archive(web.repo, bodyfh, cnode, artype, prefix=name, match=match,
matchfn=match,
subrepos=web.configbool("web", "archivesubrepos")) subrepos=web.configbool("web", "archivesubrepos"))
return [] return []
@webcommand('static') @webcommand('static')
def static(web): def static(web):
fname = web.req.qsparams['file'] fname = web.req.qsparams['file']
# a repo owner may set web.static in .hg/hgrc to get any file # a repo owner may set web.static in .hg/hgrc to get any file