# hgweb.py - web interface to a mercurial repository

#

# Copyright 21 May 2005 - (c) 2005 Jake Edge <jake@edge2.net>

# Copyright 2005 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 demandload import demandload

demandload(globals(), "mdiff time re socket zlib errno ui hg ConfigParser")

demandload(globals(), "zipfile tempfile StringIO tarfile BaseHTTPServer util")

demandload(globals(), "mimetypes")

from node import *

from i18n import gettext as _

def templatepath():

    for f in "templates", "../templates":

        p = os.path.join(os.path.dirname(__file__), f)

        if os.path.isdir(p):

            return p

def age(x):

    def plural(t, c):

        if c == 1:

            return t

        return t + "s"

    def fmt(t, c):

        return "%d %s" % (c, plural(t, c))

    now = time.time()

    then = x[0]

    delta = max(1, int(now - then))

    scales = [["second", 1],

              ["minute", 60],

              ["hour", 3600],

              ["day", 3600 * 24],

              ["week", 3600 * 24 * 7],

              ["month", 3600 * 24 * 30],

              ["year", 3600 * 24 * 365]]

    scales.reverse()

    for t, s in scales:

        n = delta / s

        if n >= 2 or s == 1:

            return fmt(t, n)

def nl2br(text):

    return text.replace('\n', '<br/>\n')

def obfuscate(text):

    return ''.join(['&#%d;' % ord(c) for c in text])

def up(p):

    if p[0] != "/":

        p = "/" + p

    if p[-1] == "/":

        p = p[:-1]

    up = os.path.dirname(p)

    if up == "/":

        return "/"

    return up + "/"

def get_mtime(repo_path):

    hg_path = os.path.join(repo_path, ".hg")

    cl_path = os.path.join(hg_path, "00changelog.i")

    if os.path.exists(os.path.join(cl_path)):

        return os.stat(cl_path).st_mtime

    else:

        return os.stat(hg_path).st_mtime

class hgrequest(object):

    def __init__(self, inp=None, out=None, env=None):

        self.inp = inp or sys.stdin

        self.out = out or sys.stdout

        self.env = env or os.environ

        self.form = cgi.parse(self.inp, self.env, keep_blank_values=1)

    def write(self, *things):

        for thing in things:

            if hasattr(thing, "__iter__"):

                for part in thing:

                    self.write(part)

            else:

                try:

                    self.out.write(str(thing))

                except socket.error, inst:

                    if inst[0] != errno.ECONNRESET:

                        raise

    def header(self, headers=[('Content-type','text/html')]):

        for header in headers:

            self.out.write("%s: %s\r\n" % header)

        self.out.write("\r\n")

    def httphdr(self, type, file="", size=0):

        headers = [('Content-type', type)]

        if file:

            headers.append(('Content-disposition', 'attachment; filename=%s' % file))

        if size > 0:

            headers.append(('Content-length', str(size)))

        self.header(headers)

class templater(object):

    def __init__(self, mapfile, filters={}, defaults={}):

        self.cache = {}

        self.map = {}

        self.base = os.path.dirname(mapfile)

        self.filters = filters

        self.defaults = defaults

        for l in file(mapfile):

            m = re.match(r'(\S+)\s*=\s*"(.*)"$', l)

            if m:

                self.cache[m.group(1)] = m.group(2)

            else:

                m = re.match(r'(\S+)\s*=\s*(\S+)', l)

                if m:

                    self.map[m.group(1)] = os.path.join(self.base, m.group(2))

                else:

                    raise LookupError(_("unknown map entry '%s'") % l)

    def __call__(self, t, **map):

        m = self.defaults.copy()

        m.update(map)

        try:

            tmpl = self.cache[t]

        except KeyError:

            tmpl = self.cache[t] = file(self.map[t]).read()

        return self.template(tmpl, self.filters, **m)

    def template(self, tmpl, filters={}, **map):

        while tmpl:

            m = re.search(r"#([a-zA-Z0-9]+)((%[a-zA-Z0-9]+)*)((\|[a-zA-Z0-9]+)*)#", tmpl)

            if m:

                yield tmpl[:m.start(0)]

                v = map.get(m.group(1), "")

                v = callable(v) and v(**map) or v

                format = m.group(2)

                fl = m.group(4)

                if format:

                    q = v.__iter__

                    for i in q():

                        lm = map.copy()

                        lm.update(i)

                        yield self(format[1:], **lm)

                    v = ""

                elif fl:

                    for f in fl.split("|")[1:]:

                        v = filters[f](v)

                yield v

                tmpl = tmpl[m.end(0):]

            else:

                yield tmpl

                return

common_filters = {

    "strip": lambda x: x.strip(),

    "age": age,

    "date": lambda x: util.datestr(x),

    "addbreaks": nl2br,

    "obfuscate": obfuscate,

    "short": (lambda x: x[:12]),

    "firstline": (lambda x: x.splitlines(1)[0]),

    "permissions": (lambda x: x and "-rwxr-xr-x" or "-rw-r--r--"),

    "rfc822date": lambda x: util.datestr(x, "%a, %d %b %Y %H:%M:%S"),

    }

class hgweb(object):

    def __init__(self, repo, name=None):

        if type(repo) == type(""):

            self.repo = hg.repository(ui.ui(), repo)

        else:

            self.repo = repo

        self.mtime = -1

        self.reponame = name

        self.archives = 'zip', 'gz', 'bz2'

    def refresh(self):

        mtime = get_mtime(self.repo.root)

        if mtime != self.mtime:

            self.mtime = mtime

            self.repo = hg.repository(self.repo.ui, self.repo.root)

            self.maxchanges = int(self.repo.ui.config("web", "maxchanges", 10))

            self.maxfiles = int(self.repo.ui.config("web", "maxfiles", 10))

            self.allowpull = self.repo.ui.configbool("web", "allowpull", True)

    def archivelist(self, nodeid):

        for i in self.archives:

            if self.repo.ui.configbool("web", "allow" + i, False):

                yield {"type" : i, "node" : nodeid}

    def listfiles(self, files, mf):

        for f in files[:self.maxfiles]:

            yield self.t("filenodelink", node=hex(mf[f]), file=f)

        if len(files) > self.maxfiles:

            yield self.t("fileellipses")

    def listfilediffs(self, files, changeset):

        for f in files[:self.maxfiles]:

            yield self.t("filedifflink", node=hex(changeset), file=f)

        if len(files) > self.maxfiles:

            yield self.t("fileellipses")

    def siblings(self, siblings=[], rev=None, hiderev=None, **args):

        if not rev:

            rev = lambda x: ""

        siblings = [s for s in siblings if s != nullid]

        if len(siblings) == 1 and rev(siblings[0]) == hiderev:

            return

        for s in siblings:

            yield dict(node=hex(s), rev=rev(s), **args)

    def showtag(self, t1, node=nullid, **args):

        for t in self.repo.nodetags(node):

             yield self.t(t1, tag=t, **args)

    def diff(self, node1, node2, files):

        def filterfiles(filters, files):

            l = [x for x in files if x in filters]

            for t in filters:

                if t and t[-1] != os.sep:

                    t += os.sep

                l += [x for x in files if x.startswith(t)]

            return l

        parity = [0]

        def diffblock(diff, f, fn):

            yield self.t("diffblock",

                         lines=prettyprintlines(diff),

                         parity=parity[0],

                         file=f,

                         filenode=hex(fn or nullid))

            parity[0] = 1 - parity[0]

        def prettyprintlines(diff):

            for l in diff.splitlines(1):

                if l.startswith('+'):

                    yield self.t("difflineplus", line=l)

                elif l.startswith('-'):

                    yield self.t("difflineminus", line=l)

                elif l.startswith('@'):

                    yield self.t("difflineat", line=l)

                else:

                    yield self.t("diffline", line=l)

        r = self.repo

        cl = r.changelog

        mf = r.manifest

        change1 = cl.read(node1)

        change2 = cl.read(node2)

        mmap1 = mf.read(change1[0])

        mmap2 = mf.read(change2[0])

        date1 = util.datestr(change1[2])

        date2 = util.datestr(change2[2])

        modified, added, removed, deleted, unknown = r.changes(node1, node2)

        if files:

            modified, added, removed = map(lambda x: filterfiles(files, x),

                                           (modified, added, removed))

        diffopts = self.repo.ui.diffopts()

        showfunc = diffopts['showfunc']

        ignorews = diffopts['ignorews']

        for f in modified:

            to = r.file(f).read(mmap1[f])

            tn = r.file(f).read(mmap2[f])

            yield diffblock(mdiff.unidiff(to, date1, tn, date2, f,

                            showfunc=showfunc, ignorews=ignorews), f, tn)

        for f in added:

            to = None

            tn = r.file(f).read(mmap2[f])

            yield diffblock(mdiff.unidiff(to, date1, tn, date2, f,

                            showfunc=showfunc, ignorews=ignorews), f, tn)

        for f in removed:

            to = r.file(f).read(mmap1[f])

            tn = None

            yield diffblock(mdiff.unidiff(to, date1, tn, date2, f,

                            showfunc=showfunc, ignorews=ignorews), f, tn)

    def changelog(self, pos):

        def changenav(**map):

            def seq(factor=1):

                yield 1 * factor

                yield 3 * factor

                #yield 5 * factor

                for f in seq(factor * 10):

                    yield f

            l = []

            for f in seq():

                if f < self.maxchanges / 2:

                    continue

                if f > count:

                    break

                r = "%d" % f

                if pos + f < count:

                    l.append(("+" + r, pos + f))

                if pos - f >= 0:

                    l.insert(0, ("-" + r, pos - f))

            yield {"rev": 0, "label": "(0)"}

            for label, rev in l:

                yield {"label": label, "rev": rev}

            yield {"label": "tip", "rev": "tip"}

        def changelist(**map):

            parity = (start - end) & 1

            cl = self.repo.changelog

            l = [] # build a list in forward order for efficiency

            for i in range(start, end):

                n = cl.node(i)

                changes = cl.read(n)

                hn = hex(n)

                l.insert(0, {"parity": parity,

                             "author": changes[1],

                             "parent": self.siblings(cl.parents(n), cl.rev,

                                                     cl.rev(n) - 1),

                             "child": self.siblings(cl.children(n), cl.rev,

                                                    cl.rev(n) + 1),

                             "changelogtag": self.showtag("changelogtag",n),

                             "manifest": hex(changes[0]),

                             "desc": changes[4],