statichttp: use store class

This lets us nix store.encodefn.

mercurial/statichttprepo.py

@@ -1,82 +1,78
 # statichttprepo.py - simple http repository class for mercurial
 #
 # This provides read-only repo access to repositories exported via static http
 #
 # Copyright 2005-2007 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms
 # of the GNU General Public License, incorporated herein by reference.
 
 from i18n import _
 import changelog, httprangereader
 import repo, localrepo, manifest, util, store
 import urllib, urllib2, errno
 
 class rangereader(httprangereader.httprangereader):
     def read(self, size=None):
         try:
             return httprangereader.httprangereader.read(self, size)
         except urllib2.HTTPError, inst:
             num = inst.code == 404 and errno.ENOENT or None
             raise IOError(num, inst)
         except urllib2.URLError, inst:
             raise IOError(None, inst.reason[1])
 
 def opener(base):
     """return a function that opens files over http"""
     p = base
     def o(path, mode="r"):
         f = "/".join((p, urllib.quote(path)))
         return rangereader(f)
     return o
 
 class statichttprepository(localrepo.localrepository):
     def __init__(self, ui, path):
         self._url = path
         self.ui = ui
 
         self.path = path.rstrip('/') + "/.hg"
         self.opener = opener(self.path)
 
         # find requirements
         try:
             requirements = self.opener("requires").read().splitlines()
         except IOError, inst:
             if inst.errno == errno.ENOENT:
                 msg = _("'%s' does not appear to be an hg repository") % path
                 raise repo.RepoError(msg)
             else:
                 requirements = []
 
         # check them
         for r in requirements:
             if r not in self.supported:
                 raise repo.RepoError(_("requirement '%s' not supported") % r)
 
         # setup store
-        if "store" in requirements:
-            self.spath = self.path + "/store"
-        else:
-            self.spath = self.path
-        self.encodefn = store.encodefn(requirements)
-        so = opener(self.spath)
-        self.sopener = lambda path, *args, **kw: so(
-            self.encodefn(path), *args, **kw)
+        self.store = store.store(requirements, self.path, opener)
+        self.spath = self.store.path
+        self.sopener = self.store.opener
+        self.sjoin = self.store.join
 
         self.manifest = manifest.manifest(self.sopener)
         self.changelog = changelog.changelog(self.sopener)
         self.tagscache = None
         self.nodetagscache = None
         self.encodepats = None
         self.decodepats = None
 
     def url(self):
         return 'static-' + self._url
 
     def local(self):
         return False
 
 def instance(ui, path, create):
     if create:
         raise util.Abort(_('cannot create new static-http repository'))
     return statichttprepository(ui, path[7:])

mercurial/store.py

@@ -1,132 +1,126
 # store.py - repository store handling for Mercurial
 #
 # Copyright 2008 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms
 # of the GNU General Public License, incorporated herein by reference.
 
 from i18n import _
 import os, stat, osutil, util
 
 def _buildencodefun():
     e = '_'
     win_reserved = [ord(x) for x in '\\:*?"<>|']
     cmap = dict([ (chr(x), chr(x)) for x in xrange(127) ])
     for x in (range(32) + range(126, 256) + win_reserved):
         cmap[chr(x)] = "~%02x" % x
     for x in range(ord("A"), ord("Z")+1) + [ord(e)]:
         cmap[chr(x)] = e + chr(x).lower()
     dmap = {}
     for k, v in cmap.iteritems():
         dmap[v] = k
     def decode(s):
         i = 0
         while i < len(s):
             for l in xrange(1, 4):
                 try:
                     yield dmap[s[i:i+l]]
                     i += l
                     break
                 except KeyError:
                     pass
             else:
                 raise KeyError
     return (lambda s: "".join([cmap[c] for c in s]),
             lambda s: "".join(list(decode(s))))
 
 encodefilename, decodefilename = _buildencodefun()
 
 def _dirwalk(path, recurse):
     '''yields (filename, size)'''
     for e, kind, st in osutil.listdir(path, stat=True):
         pe = os.path.join(path, e)
         if kind == stat.S_IFDIR:
             if recurse:
                 for x in _dirwalk(pe, True):
                     yield x
         elif kind == stat.S_IFREG:
             yield pe, st.st_size
 
 class _store:
     '''base class for local repository stores'''
     def __init__(self, path):
         self.path = path
         try:
             # files in .hg/ will be created using this mode
             mode = os.stat(self.path).st_mode
             # avoid some useless chmods
             if (0777 & ~util._umask) == (0777 & mode):
                 mode = None
         except OSError:
             mode = None
         self.createmode = mode
 
     def join(self, f):
         return os.path.join(self.path, f)
 
     def _revlogfiles(self, relpath='', recurse=False):
         '''yields (filename, size)'''
         if relpath:
             path = os.path.join(self.path, relpath)
         else:
             path = self.path
         if not os.path.isdir(path):
             return
         striplen = len(self.path) + len(os.sep)
         filetypes = ('.d', '.i')
         for f, size in _dirwalk(path, recurse):
             if (len(f) > 2) and f[-2:] in filetypes:
                 yield util.pconvert(f[striplen:]), size
 
     def datafiles(self, reporterror=None):
         for x in self._revlogfiles('data', True):
             yield x
 
     def walk(self):
         '''yields (direncoded filename, size)'''
         # yield data files first
         for x in self.datafiles():
             yield x
         # yield manifest before changelog
         meta = util.sort(self._revlogfiles())
         meta.reverse()
         for x in meta:
             yield x
 
 class directstore(_store):
     def __init__(self, path, opener):
         _store.__init__(self, path)
         self.opener = opener(self.path)
         self.opener.createmode = self.createmode
 
 class encodedstore(_store):
     def __init__(self, path, opener):
         _store.__init__(self, os.path.join(path, 'store'))
         self.encodefn = encodefilename
         op = opener(self.path)
         op.createmode = self.createmode
         self.opener = lambda f, *args, **kw: op(self.encodefn(f), *args, **kw)
 
     def datafiles(self, reporterror=None):
         for f, size in self._revlogfiles('data', True):
             try:
                 yield decodefilename(f), size
             except KeyError:
                 if not reporterror:
                     raise
                 reporterror(_("cannot decode filename '%s'") % f)
 
     def join(self, f):
         return os.path.join(self.path, self.encodefn(f))
 
-def encodefn(requirements):
-    if 'store' not in requirements:
-        return lambda x: x
-    else:
-        return encodefilename
-
 def store(requirements, path, opener):
     if 'store' not in requirements:
         return directstore(path, opener)
     else:
         return encodedstore(path, opener)