( )⚙ D1746 repoview: add visibilityexceptions as an optional argument to repo.filtered()

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D1746

repoview: add visibilityexceptions as an optional argument to repo.filtered()
ClosedPublic

Authored by pulkit on Dec 22 2017, 12:56 PM.

Details

Reviewers
yuja
Group Reviewers
hg-reviewers
Commits
rHG3ad582b2895c: repoview: add visibilityexceptions as an optional argument to repo.filtered()
Summary

This will help us in having an API where we can pass the filtername and the
visibilityexceptions to get a new repo object.

Visibility exceptions are the revs which must be visible even they should in
theory belong to the hidden set. They are required as there has been desire to
have a functionality to access hidden changesets using certain commands without
passing --hidden. After this patch we can make those changesets visibility
exceptions so that we can access them without requiring a unfiltered repo.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

pulkit created this revision.Dec 22 2017, 12:56 PM
yuja requested changes to this revision.Dec 25 2017, 7:49 AM
yuja added a subscriber: yuja.
yuja added inline comments.
mercurial/repoview.py
196

We have to use object.__setattr__() because __setattr__() is
proxied to the unfilteredrepo.

This revision now requires changes to proceed.Dec 25 2017, 7:49 AM
pulkit updated this revision to Diff 4606.Dec 25 2017, 10:08 AM
yuja accepted this revision.Dec 26 2017, 8:42 AM
This revision is now accepted and ready to land.Dec 26 2017, 8:42 AM
Closed by commit rHG3ad582b2895c: repoview: add visibilityexceptions as an optional argument to repo.filtered() (authored by pulkit). · Explain WhyDec 26 2017, 9:11 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/localrepo.py (4 lines)
Mmercurial/repoview.py (10 lines)

Diff 4581

mercurial/localrepo.py

return localpeer(self) # not cached to avoid reference cycle return localpeer(self) # not cached to avoid reference cycle
def unfiltered(self): def unfiltered(self):
"""Return unfiltered version of the repository """Return unfiltered version of the repository
Intended to be overwritten by filtered repo.""" Intended to be overwritten by filtered repo."""
return self return self
def filtered(self, name): def filtered(self, name, visibilityexceptions=None):
"""Return a filtered version of a repository""" """Return a filtered version of a repository"""
cls = repoview.newtype(self.unfiltered().__class__) cls = repoview.newtype(self.unfiltered().__class__)
return cls(self, name) return cls(self, name, visibilityexceptions)
@repofilecache('bookmarks', 'bookmarks.current') @repofilecache('bookmarks', 'bookmarks.current')
def _bookmarks(self): def _bookmarks(self):
return bookmarks.bmstore(self) return bookmarks.bmstore(self)
@property @property
def _activebookmark(self): def _activebookmark(self):
return self._bookmarks.active return self._bookmarks.active

mercurial/repoview.py

leads to the property below. leads to the property below.
repoview.method() --> repo.__class__.method(repoview) repoview.method() --> repo.__class__.method(repoview)
The inheritance has to be done dynamically because `repo` can be of any The inheritance has to be done dynamically because `repo` can be of any
subclasses of `localrepo`. Eg: `bundlerepo` or `statichttprepo`. subclasses of `localrepo`. Eg: `bundlerepo` or `statichttprepo`.
""" """
def __init__(self, repo, filtername): def __init__(self, repo, filtername, visibilityexceptions=None):
object.__setattr__(self, r'_unfilteredrepo', repo) object.__setattr__(self, r'_unfilteredrepo', repo)
object.__setattr__(self, r'filtername', filtername) object.__setattr__(self, r'filtername', filtername)
object.__setattr__(self, r'_clcachekey', None) object.__setattr__(self, r'_clcachekey', None)
object.__setattr__(self, r'_clcache', None) object.__setattr__(self, r'_clcache', None)
# revs which are exceptions and must not be hidden
self._visibilityexceptions = visibilityexceptions
yujaUnsubmitted
Not Done

We have to use object.__setattr__() because __setattr__() is
proxied to the unfilteredrepo.

yuja: We have to use `object.__setattr__()` because `__setattr__()` is proxied to the unfilteredrepo.
# not a propertycache on purpose we shall implement a proper cache later # not a propertycache on purpose we shall implement a proper cache later
@property @property
def changelog(self): def changelog(self):
"""return a filtered version of the changeset """return a filtered version of the changeset
this changelog must not be used for writing""" this changelog must not be used for writing"""
# some cache may be implemented later # some cache may be implemented later
object.__setattr__(self, r'_clcache', cl) object.__setattr__(self, r'_clcache', cl)
object.__setattr__(self, r'_clcachekey', newkey) object.__setattr__(self, r'_clcachekey', newkey)
return cl return cl
def unfiltered(self): def unfiltered(self):
"""Return an unfiltered version of a repo""" """Return an unfiltered version of a repo"""
return self._unfilteredrepo return self._unfilteredrepo
def filtered(self, name): def filtered(self, name, visibilityexceptions=None):
"""Return a filtered version of a repository""" """Return a filtered version of a repository"""
if name == self.filtername: if name == self.filtername and not visibilityexceptions:
return self return self
return self.unfiltered().filtered(name) return self.unfiltered().filtered(name, visibilityexceptions)
def __repr__(self): def __repr__(self):
return r'<%s:%s %r>' % (self.__class__.__name__, return r'<%s:%s %r>' % (self.__class__.__name__,
pycompat.sysstr(self.filtername), pycompat.sysstr(self.filtername),
self.unfiltered()) self.unfiltered())
# everything access are forwarded to the proxied repo # everything access are forwarded to the proxied repo
def __getattr__(self, attr): def __getattr__(self, attr):