This is an archive of the discontinued Mercurial Phabricator instance.

Differential D2489

narrow: move checking for narrow requirement into _narrowmatch()
ClosedPublic

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

Details

Reviewers
durin42
indygreg
Group Reviewers
hg-reviewers
Commits
rHGa8b4d7673d8e: narrow: move checking for narrow requirement into _narrowmatch()
rHGcb0449f3d9fc: narrow: move checking for narrow requirement into _narrowmatch()
Summary

We want to move narrowmatch() and others into core, so we need to get
rid of the dependence on the "narrow_opts" from the closure in
narrowrepo.wraprepo(). We can simply check if the narrow requirement
is set. I think that seems like an improvement regardless of moving
narrowmatch().

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:04 PM
indygreg added a subscriber: indygreg.

Having the requirement imply the use of a narrow matcher seems OK to me. It is easy enough to change if we need something else.

This revision is now accepted and ready to land.Feb 28 2018, 9:04 PM
Closed by commit rHGcb0449f3d9fc: narrow: move checking for narrow requirement into _narrowmatch() (authored by martinvonz). · Explain WhyFeb 28 2018, 9:17 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 6222

hgext/narrow/__init__.py

narrowwirepeer.uisetup() narrowwirepeer.uisetup()
def reposetup(ui, repo): def reposetup(ui, repo):
"""Wraps local repositories with narrow repo support.""" """Wraps local repositories with narrow repo support."""
if not isinstance(repo, localrepo.localrepository): if not isinstance(repo, localrepo.localrepository):
return return
if changegroup.NARROW_REQUIREMENT in repo.requirements: if changegroup.NARROW_REQUIREMENT in repo.requirements:
narrowrepo.wraprepo(repo, True) narrowrepo.wraprepo(repo)
narrowcopies.setup(repo) narrowcopies.setup(repo)
narrowdirstate.setup(repo) narrowdirstate.setup(repo)
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),

hgext/narrow/narrowcommands.py

orig(pullop, kwargs) orig(pullop, kwargs)
if opts.get('depth'): if opts.get('depth'):
kwargs['depth'] = opts['depth'] kwargs['depth'] = opts['depth']
wrappedextraprepare = extensions.wrappedfunction(exchange, wrappedextraprepare = extensions.wrappedfunction(exchange,
'_pullbundle2extraprepare', pullbundle2extraprepare_widen) '_pullbundle2extraprepare', pullbundle2extraprepare_widen)
def pullnarrow(orig, repo, *args, **kwargs): def pullnarrow(orig, repo, *args, **kwargs):
narrowrepo.wraprepo(repo.unfiltered(), opts_narrow) narrowrepo.wraprepo(repo.unfiltered())
if isinstance(repo, repoview.repoview): if isinstance(repo, repoview.repoview):
repo.__class__.__bases__ = (repo.__class__.__bases__[0], repo.__class__.__bases__ = (repo.__class__.__bases__[0],
repo.unfiltered().__class__) repo.unfiltered().__class__)
if opts_narrow: if opts_narrow:
repo.requirements.add(changegroup.NARROW_REQUIREMENT) repo.requirements.add(changegroup.NARROW_REQUIREMENT)
repo._writerequirements() repo._writerequirements()
return orig(repo, *args, **kwargs) return orig(repo, *args, **kwargs)

hgext/narrow/narrowrepo.py

and repo.path == repopath and repo.shared()): and repo.path == repopath and repo.shared()):
srcrepo = hg.sharedreposource(repo) srcrepo = hg.sharedreposource(repo)
with srcrepo.vfs(narrowspec.FILENAME) as f: with srcrepo.vfs(narrowspec.FILENAME) as f:
spec = f.read() spec = f.read()
with repo.vfs(narrowspec.FILENAME, 'w') as f: with repo.vfs(narrowspec.FILENAME, 'w') as f:
f.write(spec) f.write(spec)
return orig(ui, repo, repopath) return orig(ui, repo, repopath)
def wraprepo(repo, opts_narrow): def wraprepo(repo):
"""Enables narrow clone functionality on a single local repository.""" """Enables narrow clone functionality on a single local repository."""
cacheprop = localrepo.storecache cacheprop = localrepo.storecache
if isinstance(repo, bundlerepo.bundlerepository): if isinstance(repo, bundlerepo.bundlerepository):
# We have to use a different caching property decorator for # We have to use a different caching property decorator for
# bundlerepo because storecache blows up in strange ways on a # bundlerepo because storecache blows up in strange ways on a
# bundlerepo. Fortunately, there's no risk of data changing in # bundlerepo. Fortunately, there's no risk of data changing in
# a bundlerepo. # a bundlerepo.
"""matcher patterns for this repository's narrowspec """matcher patterns for this repository's narrowspec
A tuple of (includes, excludes). A tuple of (includes, excludes).
""" """
return narrowspec.load(self) return narrowspec.load(self)
@localrepo.repofilecache(narrowspec.FILENAME) @localrepo.repofilecache(narrowspec.FILENAME)
def _narrowmatch(self): def _narrowmatch(self):
include, exclude = self.narrowpats if changegroup.NARROW_REQUIREMENT not in self.requirements:
if not opts_narrow and not include and not exclude:
return matchmod.always(self.root, '') return matchmod.always(self.root, '')
include, exclude = self.narrowpats
return narrowspec.match(self.root, include=include, exclude=exclude) return narrowspec.match(self.root, include=include, exclude=exclude)
# TODO(martinvonz): make this property-like instead? # TODO(martinvonz): make this property-like instead?
def narrowmatch(self): def narrowmatch(self):
return self._narrowmatch return self._narrowmatch
def setnarrowpats(self, newincludes, newexcludes): def setnarrowpats(self, newincludes, newexcludes):
narrowspec.save(self, newincludes, newexcludes) narrowspec.save(self, newincludes, newexcludes)