This is an archive of the discontinued Mercurial Phabricator instance.

Differential D2495

narrow: drop safehasattr() checks for always-present repo.narrowmatch
ClosedPublic

Authored by martinvonz on Feb 28 2018, 3:56 PM.

Details

Reviewers
durin42
indygreg
Group Reviewers
hg-reviewers
Commits
rHGd0d5eef57fb0: narrow: drop safehasattr() checks for always-present repo.narrowmatch
rHG1c1646f0bf5b: narrow: drop safehasattr() checks for always-present repo.narrowmatch
rHGa9d88301d495: narrow: drop safehasattr() checks for always-present repo.narrowmatch
Summary

I've added checks for repo.narrowmatch().always() in order to restore
some of the fast paths for non-narrow repos.

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 28 2018, 3:56 PM
indygreg accepted this revision.Feb 28 2018, 9:14 PM
This revision is now accepted and ready to land.Feb 28 2018, 9:14 PM
Closed by commit rHGa9d88301d495: narrow: drop safehasattr() checks for always-present repo.narrowmatch (authored by martinvonz). · Explain WhyFeb 28 2018, 9:18 PM
This revision was automatically updated to reflect the committed changes.
yuja added a subscriber: yuja.Mar 1 2018, 5:15 AM
yuja added inline comments.
hgext/narrow/narrowmerge.py
71

s/not// ?

martinvonz added inline comments.Mar 1 2018, 8:08 AM
hgext/narrow/narrowmerge.py
71

Yep, it definitely looks like it should be. Fixed in "committed"

Revision Contents
Changeset List

Diff 6227

hgext/narrow/__init__.py

narrowpatch.setup(repo) narrowpatch.setup(repo)
narrowwirepeer.reposetup(repo) narrowwirepeer.reposetup(repo)
def _verifierinit(orig, self, repo, matcher=None): def _verifierinit(orig, self, repo, matcher=None):
# The verifier's matcher argument was desgined for narrowhg, so it should # The verifier's matcher argument was desgined for narrowhg, so it should
# be None from core. If another extension passes a matcher (unlikely), # be None from core. If another extension passes a matcher (unlikely),
# we'll have to fail until matchers can be composed more easily. # we'll have to fail until matchers can be composed more easily.
assert matcher is None assert matcher is None
matcher = getattr(repo, 'narrowmatch', lambda: None)() orig(self, repo, repo.narrowmatch())
orig(self, repo, matcher)
def extsetup(ui): def extsetup(ui):
extensions.wrapfunction(verifymod.verifier, '__init__', _verifierinit) extensions.wrapfunction(verifymod.verifier, '__init__', _verifierinit)
extensions.wrapfunction(hg, 'postshare', narrowrepo.wrappostshare) extensions.wrapfunction(hg, 'postshare', narrowrepo.wrappostshare)
extensions.wrapfunction(hg, 'copystore', narrowrepo.unsharenarrowspec) extensions.wrapfunction(hg, 'copystore', narrowrepo.unsharenarrowspec)
templatekeyword = narrowtemplates.templatekeyword templatekeyword = narrowtemplates.templatekeyword
revsetpredicate = narrowtemplates.revsetpredicate revsetpredicate = narrowtemplates.revsetpredicate

hgext/narrow/narrowchangegroup.py

node, node,
revlog, revlog,
util, util,
) )
def setup(): def setup():
def _cgmatcher(cgpacker): def _cgmatcher(cgpacker):
localmatcher = getattr(cgpacker._repo, 'narrowmatch', lambda: None)() localmatcher = cgpacker._repo.narrowmatch()
remotematcher = getattr(cgpacker, '_narrow_matcher', lambda: None)() remotematcher = getattr(cgpacker, '_narrow_matcher', lambda: None)()
if localmatcher and remotematcher: if remotematcher:
return matchmod.intersectmatchers(localmatcher, remotematcher) return matchmod.intersectmatchers(localmatcher, remotematcher)
else: else:
return localmatcher or remotematcher return localmatcher
def prune(orig, self, revlog, missing, commonrevs): def prune(orig, self, revlog, missing, commonrevs):
if isinstance(revlog, manifest.manifestrevlog): if isinstance(revlog, manifest.manifestrevlog):
matcher = _cgmatcher(self) matcher = _cgmatcher(self)
if (matcher and if (matcher and
not matcher.visitdir(revlog._dir[:-1] or '.')): not matcher.visitdir(revlog._dir[:-1] or '.')):
return [] return []
return orig(self, revlog, missing, commonrevs) return orig(self, revlog, missing, commonrevs)

hgext/narrow/narrowcopies.py

# narrowcopies.py - extensions to mercurial copies module to support narrow # narrowcopies.py - extensions to mercurial copies module to support narrow
# clones # clones
# #
# Copyright 2017 Google, Inc. # Copyright 2017 Google, Inc.
# #
# 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
from mercurial import ( from mercurial import (
copies, copies,
extensions, extensions,
util,
) )
def setup(repo): def setup(repo):
def _computeforwardmissing(orig, a, b, match=None): def _computeforwardmissing(orig, a, b, match=None):
missing = orig(a, b, match) missing = orig(a, b, match)
if util.safehasattr(repo, 'narrowmatch'):
narrowmatch = repo.narrowmatch() narrowmatch = repo.narrowmatch()
if narrowmatch.always():
return missing
missing = [f for f in missing if narrowmatch(f)] missing = [f for f in missing if narrowmatch(f)]
return missing return missing
def _checkcopies(orig, srcctx, dstctx, f, base, tca, remotebase, limit, def _checkcopies(orig, srcctx, dstctx, f, base, tca, remotebase, limit,
data): data):
if util.safehasattr(repo, 'narrowmatch'):
narrowmatch = repo.narrowmatch() narrowmatch = repo.narrowmatch()
if not narrowmatch(f): if not narrowmatch(f):
return return
orig(srcctx, dstctx, f, base, tca, remotebase, limit, data) orig(srcctx, dstctx, f, base, tca, remotebase, limit, data)
extensions.wrapfunction(copies, '_computeforwardmissing', extensions.wrapfunction(copies, '_computeforwardmissing',
_computeforwardmissing) _computeforwardmissing)
extensions.wrapfunction(copies, '_checkcopies', _checkcopies) extensions.wrapfunction(copies, '_checkcopies', _checkcopies)

hgext/narrow/narrowmerge.py

# narrowmerge.py - extensions to mercurial merge module to support narrow clones # narrowmerge.py - extensions to mercurial merge module to support narrow clones
# #
# Copyright 2017 Google, Inc. # Copyright 2017 Google, Inc.
# #
# 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
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial import ( from mercurial import (
copies, copies,
error, error,
extensions, extensions,
merge, merge,
util,
) )
def setup(): def setup():
def _manifestmerge(orig, repo, wctx, p2, pa, branchmerge, *args, **kwargs): def _manifestmerge(orig, repo, wctx, p2, pa, branchmerge, *args, **kwargs):
"""Filter updates to only lay out files that match the narrow spec.""" """Filter updates to only lay out files that match the narrow spec."""
actions, diverge, renamedelete = orig( actions, diverge, renamedelete = orig(
repo, wctx, p2, pa, branchmerge, *args, **kwargs) repo, wctx, p2, pa, branchmerge, *args, **kwargs)
if not util.safehasattr(repo, 'narrowmatch'): narrowmatch = repo.narrowmatch()
if narrowmatch.always():
return actions, diverge, renamedelete return actions, diverge, renamedelete
nooptypes = set(['k']) # TODO: handle with nonconflicttypes nooptypes = set(['k']) # TODO: handle with nonconflicttypes
nonconflicttypes = set('a am c cm f g r e'.split()) nonconflicttypes = set('a am c cm f g r e'.split())
narrowmatch = repo.narrowmatch()
# We mutate the items in the dict during iteration, so iterate # We mutate the items in the dict during iteration, so iterate
# over a copy. # over a copy.
for f, action in list(actions.items()): for f, action in list(actions.items()):
if narrowmatch(f): if narrowmatch(f):
pass pass
elif not branchmerge: elif not branchmerge:
del actions[f] # just updating, ignore changes outside clone del actions[f] # just updating, ignore changes outside clone
elif action[0] in nooptypes: elif action[0] in nooptypes:
del actions[f] # merge does not affect file del actions[f] # merge does not affect file
elif action[0] in nonconflicttypes: elif action[0] in nonconflicttypes:
raise error.Abort(_('merge affects file \'%s\' outside narrow, ' raise error.Abort(_('merge affects file \'%s\' outside narrow, '
'which is not yet supported') % f, 'which is not yet supported') % f,
hint=_('merging in the other direction ' hint=_('merging in the other direction '
'may work')) 'may work'))
else: else:
raise error.Abort(_('conflict in file \'%s\' is outside ' raise error.Abort(_('conflict in file \'%s\' is outside '
'narrow clone') % f) 'narrow clone') % f)
return actions, diverge, renamedelete return actions, diverge, renamedelete
extensions.wrapfunction(merge, 'manifestmerge', _manifestmerge) extensions.wrapfunction(merge, 'manifestmerge', _manifestmerge)
def _checkcollision(orig, repo, wmf, actions): def _checkcollision(orig, repo, wmf, actions):
if util.safehasattr(repo, 'narrowmatch'):
narrowmatch = repo.narrowmatch() narrowmatch = repo.narrowmatch()
if not narrowmatch.always():
wmf = wmf.matches(narrowmatch) wmf = wmf.matches(narrowmatch)
if actions: if actions:
narrowactions = {} narrowactions = {}
for m, actionsfortype in actions.iteritems(): for m, actionsfortype in actions.iteritems():
narrowactions[m] = [] narrowactions[m] = []
for (f, args, msg) in actionsfortype: for (f, args, msg) in actionsfortype:
if narrowmatch(f): if narrowmatch(f):
narrowactions[m].append((f, args, msg)) narrowactions[m].append((f, args, msg))
actions = narrowactions actions = narrowactions
return orig(repo, wmf, actions) return orig(repo, wmf, actions)
extensions.wrapfunction(merge, '_checkcollision', _checkcollision) extensions.wrapfunction(merge, '_checkcollision', _checkcollision)
def _computenonoverlap(orig, repo, *args, **kwargs): def _computenonoverlap(orig, repo, *args, **kwargs):
u1, u2 = orig(repo, *args, **kwargs) u1, u2 = orig(repo, *args, **kwargs)
if not util.safehasattr(repo, 'narrowmatch'): narrowmatch = repo.narrowmatch()
if not narrowmatch.always():
yujaUnsubmitted
Not Done

s/not// ?

yuja: s/not// ?
martinvonzAuthorUnsubmitted
Not Done

Yep, it definitely looks like it should be. Fixed in "committed"

martinvonz: Yep, it definitely looks like it should be. Fixed in "committed"
return u1, u2 return u1, u2
narrowmatch = repo.narrowmatch()
u1 = [f for f in u1 if narrowmatch(f)] u1 = [f for f in u1 if narrowmatch(f)]
u2 = [f for f in u2 if narrowmatch(f)] u2 = [f for f in u2 if narrowmatch(f)]
return u1, u2 return u1, u2
extensions.wrapfunction(copies, '_computenonoverlap', _computenonoverlap) extensions.wrapfunction(copies, '_computenonoverlap', _computenonoverlap)

hgext/narrow/narrowpatch.py

# narrowpatch.py - extensions to mercurial patch module to support narrow clones # narrowpatch.py - extensions to mercurial patch module to support narrow clones
# #
# Copyright 2017 Google, Inc. # Copyright 2017 Google, Inc.
# #
# 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
from mercurial import ( from mercurial import (
extensions, extensions,
patch, patch,
util,
) )
def setup(repo): def setup(repo):
def _filepairs(orig, *args): def _filepairs(orig, *args):
"""Only includes files within the narrow spec in the diff.""" """Only includes files within the narrow spec in the diff."""
if util.safehasattr(repo, 'narrowmatch'):
narrowmatch = repo.narrowmatch() narrowmatch = repo.narrowmatch()
if not narrowmatch.always():
for x in orig(*args): for x in orig(*args):
f1, f2, copyop = x f1, f2, copyop = x
if ((not f1 or narrowmatch(f1)) and if ((not f1 or narrowmatch(f1)) and
(not f2 or narrowmatch(f2))): (not f2 or narrowmatch(f2))):
yield x yield x
else: else:
for x in orig(*args): for x in orig(*args):
yield x yield x
def trydiff(orig, repo, revs, ctx1, ctx2, modified, added, removed, def trydiff(orig, repo, revs, ctx1, ctx2, modified, added, removed,
copy, getfilectx, *args, **kwargs): copy, getfilectx, *args, **kwargs):
if util.safehasattr(repo, 'narrowmatch'):
narrowmatch = repo.narrowmatch() narrowmatch = repo.narrowmatch()
if not narrowmatch.always():
modified = [f for f in modified if narrowmatch(f)] modified = [f for f in modified if narrowmatch(f)]
added = [f for f in added if narrowmatch(f)] added = [f for f in added if narrowmatch(f)]
removed = [f for f in removed if narrowmatch(f)] removed = [f for f in removed if narrowmatch(f)]
copy = {k: v for k, v in copy.iteritems() if narrowmatch(k)} copy = {k: v for k, v in copy.iteritems() if narrowmatch(k)}
return orig(repo, revs, ctx1, ctx2, modified, added, removed, copy, return orig(repo, revs, ctx1, ctx2, modified, added, removed, copy,
getfilectx, *args, **kwargs) getfilectx, *args, **kwargs)
extensions.wrapfunction(patch, '_filepairs', _filepairs) extensions.wrapfunction(patch, '_filepairs', _filepairs)
extensions.wrapfunction(patch, 'trydiff', trydiff) extensions.wrapfunction(patch, 'trydiff', trydiff)

hgext/narrow/narrowtemplates.py

# narrowtemplates.py - added template keywords for narrow clones # narrowtemplates.py - added template keywords for narrow clones
# #
# Copyright 2017 Google, Inc. # Copyright 2017 Google, Inc.
# #
# 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
from mercurial import ( from mercurial import (
registrar, registrar,
revlog, revlog,
util,
) )
keywords = {} keywords = {}
templatekeyword = registrar.templatekeyword(keywords) templatekeyword = registrar.templatekeyword(keywords)
revsetpredicate = registrar.revsetpredicate() revsetpredicate = registrar.revsetpredicate()
def _isellipsis(repo, rev): def _isellipsis(repo, rev):
if repo.changelog.flags(rev) & revlog.REVIDX_ELLIPSIS: if repo.changelog.flags(rev) & revlog.REVIDX_ELLIPSIS:
return True return True
return False return False
@templatekeyword('ellipsis') @templatekeyword('ellipsis')
def ellipsis(repo, ctx, templ, **args): def ellipsis(repo, ctx, templ, **args):
"""String. 'ellipsis' if the change is an ellipsis node, else ''.""" """String. 'ellipsis' if the change is an ellipsis node, else ''."""
if _isellipsis(repo, ctx.rev()): if _isellipsis(repo, ctx.rev()):
return 'ellipsis' return 'ellipsis'
return '' return ''
@templatekeyword('outsidenarrow') @templatekeyword('outsidenarrow')
def outsidenarrow(repo, ctx, templ, **args): def outsidenarrow(repo, ctx, templ, **args):
"""String. 'outsidenarrow' if the change affects no tracked files, """String. 'outsidenarrow' if the change affects no tracked files,
else ''.""" else ''."""
if util.safehasattr(repo, 'narrowmatch'):
m = repo.narrowmatch() m = repo.narrowmatch()
if not m.always():
if not any(m(f) for f in ctx.files()): if not any(m(f) for f in ctx.files()):
return 'outsidenarrow' return 'outsidenarrow'
return '' return ''
@revsetpredicate('ellipsis') @revsetpredicate('ellipsis')
def ellipsisrevset(repo, subset, x): def ellipsisrevset(repo, subset, x):
"""Changesets that are ellipsis nodes.""" """Changesets that are ellipsis nodes."""
return subset.filter(lambda r: _isellipsis(repo, r)) return subset.filter(lambda r: _isellipsis(repo, r))