# 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 <mpm@selenic.com>

#

# 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:

                raise

            # check if it is a non-empty old-style repository

            try:

                self.opener("00changelog.i").read(1)

            except IOError, inst:

                if inst.errno != errno.ENOENT:

                    raise

                # we do not care about empty old-style repositories here

                msg = _("'%s' does not appear to be an hg repository") % path

                raise repo.RepoError(msg)

            requirements = []

        # check them

        for r in requirements:

            if r not in self.supported:

                raise repo.RepoError(_("requirement '%s' not supported") % r)

        # setup store

        def pjoin(a, b):

            return a + '/' + b

        self.store = store.store(requirements, self.path, opener, pjoin)

        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):

    def local(self):

        return False

    def lock(self, wait=True):

        raise util.Abort(_('cannot lock static-http repository'))

def instance(ui, path, create):

    if create:

        raise util.Abort(_('cannot create new static-http repository'))

    return statichttprepository(ui, path[7:])