This is an archive of the discontinued Mercurial Phabricator instance.

Differential D3149

filelog: declare that filelog implements a storage interface
ClosedPublic

Authored by indygreg on Apr 5 2018, 8:51 PM.

Details

Reviewers
durin42
Group Reviewers
hg-reviewers
Commits
rHGa3202fa83aff: filelog: declare that filelog implements a storage interface
Summary

Now that we have a declared interface, let's declare that filelog
implements it.

Tests have been added that confirm the object conforms to the
interface.

The existing interface checks verify there are no extra public
attributes outside the declared interface. filelog has several
extra attributes. So we added a mechanism to suppress this check.
The goal is to modify the filelog class so we can drop this check.

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

indygreg created this revision.Apr 5 2018, 8:51 PM
durin42 accepted this revision.Apr 6 2018, 8:55 PM
This revision is now accepted and ready to land.Apr 6 2018, 8:55 PM
Closed by commit rHGa3202fa83aff: filelog: declare that filelog implements a storage interface (authored by indygreg). · Explain WhyApr 6 2018, 9:22 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 7847

mercurial/filelog.py

# filelog.py - file history class for mercurial # filelog.py - file history class for mercurial
# #
# 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 re import re
import struct import struct
from .thirdparty.zope import (
interface as zi,
)
from . import ( from . import (
error, error,
mdiff, mdiff,
repository,
revlog, revlog,
) )
_mdre = re.compile('\1\n') _mdre = re.compile('\1\n')
def parsemeta(text): def parsemeta(text):
"""return (metadatadict, metadatasize)""" """return (metadatadict, metadatasize)"""
# text can be buffer, so we can't use .startswith or .index # text can be buffer, so we can't use .startswith or .index
if text[:2] != '\1\n': if text[:2] != '\1\n':
keys = sorted(meta) keys = sorted(meta)
metatext = "".join("%s: %s\n" % (k, meta[k]) for k in keys) metatext = "".join("%s: %s\n" % (k, meta[k]) for k in keys)
return "\1\n%s\1\n%s" % (metatext, text) return "\1\n%s\1\n%s" % (metatext, text)
def _censoredtext(text): def _censoredtext(text):
m, offs = parsemeta(text) m, offs = parsemeta(text)
return m and "censored" in m return m and "censored" in m
@zi.implementer(repository.ifilestorage)
class filelog(revlog.revlog): class filelog(revlog.revlog):
def __init__(self, opener, path): def __init__(self, opener, path):
super(filelog, self).__init__(opener, super(filelog, self).__init__(opener,
"/".join(("data", path + ".i"))) "/".join(("data", path + ".i")))
# full name of the user visible file, relative to the repository root # full name of the user visible file, relative to the repository root
self.filename = path self.filename = path
def read(self, node): def read(self, node):

tests/simplestorerepo.py

bin, bin,
hex, hex,
nullid, nullid,
nullrev, nullrev,
) )
from mercurial.thirdparty import ( from mercurial.thirdparty import (
cbor, cbor,
) )
from mercurial.thirdparty.zope import (
interface as zi,
)
from mercurial import ( from mercurial import (
ancestor, ancestor,
bundlerepo, bundlerepo,
error, error,
extensions, extensions,
filelog, filelog,
localrepo, localrepo,
mdiff, mdiff,
pycompat, pycompat,
repository,
revlog, revlog,
store, store,
verify, verify,
) )
# Note for extension authors: ONLY specify testedwith = 'ships-with-hg-core' for # Note for extension authors: ONLY specify testedwith = 'ships-with-hg-core' for
# extensions which SHIP WITH MERCURIAL. Non-mainline extensions should # extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
# be specifying the version(s) of Mercurial they are tested with, or # be specifying the version(s) of Mercurial they are tested with, or
# leave the attribute unspecified. # leave the attribute unspecified.
testedwith = 'ships-with-hg-core' testedwith = 'ships-with-hg-core'
REQUIREMENT = 'testonly-simplestore' REQUIREMENT = 'testonly-simplestore'
def validatenode(node): def validatenode(node):
if isinstance(node, int): if isinstance(node, int):
raise ValueError('expected node; got int') raise ValueError('expected node; got int')
if len(node) != 20: if len(node) != 20:
raise ValueError('expected 20 byte node') raise ValueError('expected 20 byte node')
def validaterev(rev): def validaterev(rev):
if not isinstance(rev, int): if not isinstance(rev, int):
raise ValueError('expected int') raise ValueError('expected int')
@zi.implementer(repository.ifilestorage)
class filestorage(object): class filestorage(object):
"""Implements storage for a tracked path. """Implements storage for a tracked path.
Data is stored in the VFS in a directory corresponding to the tracked Data is stored in the VFS in a directory corresponding to the tracked
path. path.
Index data is stored in an ``index`` file using CBOR. Index data is stored in an ``index`` file using CBOR.

tests/test-check-interfaces.py

# Test that certain objects conform to well-defined interfaces. # Test that certain objects conform to well-defined interfaces.
from __future__ import absolute_import, print_function from __future__ import absolute_import, print_function
import os import os
from mercurial.thirdparty.zope import ( from mercurial.thirdparty.zope import (
interface as zi, interface as zi,
) )
from mercurial.thirdparty.zope.interface import ( from mercurial.thirdparty.zope.interface import (
verify as ziverify, verify as ziverify,
) )
from mercurial import ( from mercurial import (
bundlerepo, bundlerepo,
filelog,
httppeer, httppeer,
localrepo, localrepo,
repository, repository,
sshpeer, sshpeer,
statichttprepo, statichttprepo,
ui as uimod, ui as uimod,
unionrepo, unionrepo,
vfs as vfsmod,
wireprotoserver, wireprotoserver,
wireprototypes, wireprototypes,
) )
rootdir = os.path.normpath(os.path.join(os.path.dirname(__file__), '..')) rootdir = os.path.normpath(os.path.join(os.path.dirname(__file__), '..'))
def checkzobject(o): def checkzobject(o, allowextra=False):
"""Verify an object with a zope interface.""" """Verify an object with a zope interface."""
ifaces = zi.providedBy(o) ifaces = zi.providedBy(o)
if not ifaces: if not ifaces:
print('%r does not provide any zope interfaces' % o) print('%r does not provide any zope interfaces' % o)
return return
# Run zope.interface's built-in verification routine. This verifies that # Run zope.interface's built-in verification routine. This verifies that
# everything that is supposed to be present is present. # everything that is supposed to be present is present.
for iface in ifaces: for iface in ifaces:
ziverify.verifyObject(iface, o) ziverify.verifyObject(iface, o)
if allowextra:
return
# Now verify that the object provides no extra public attributes that # Now verify that the object provides no extra public attributes that
# aren't declared as part of interfaces. # aren't declared as part of interfaces.
allowed = set() allowed = set()
for iface in ifaces: for iface in ifaces:
allowed |= set(iface.names(all=True)) allowed |= set(iface.names(all=True))
public = {a for a in dir(o) if not a.startswith('_')} public = {a for a in dir(o) if not a.startswith('_')}
sshv2 = wireprotoserver.sshv2protocolhandler(None, None, None) sshv2 = wireprotoserver.sshv2protocolhandler(None, None, None)
checkzobject(sshv2) checkzobject(sshv2)
httpv1 = wireprotoserver.httpv1protocolhandler(None, None, None) httpv1 = wireprotoserver.httpv1protocolhandler(None, None, None)
checkzobject(httpv1) checkzobject(httpv1)
httpv2 = wireprotoserver.httpv2protocolhandler(None, None) httpv2 = wireprotoserver.httpv2protocolhandler(None, None)
checkzobject(httpv2) checkzobject(httpv2)
ziverify.verifyClass(repository.ifilestorage, filelog.filelog)
vfs = vfsmod.vfs('.')
fl = filelog.filelog(vfs, 'dummy.i')
checkzobject(fl, allowextra=True)
main() main()