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

import os, cgi, sys

from demandload import demandload

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

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

from node import *

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 + "/"

class hgrequest:

    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)

    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:

    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 = {

    "escape": cgi.escape,

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

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

        s = os.stat(os.path.join(self.repo.root, ".hg", "00changelog.i"))

        if s.st_mtime != self.mtime:

            self.mtime = s.st_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 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 parents(self, t1, nodes=[], rev=None,**args):

        if not rev:

            rev = lambda x: ""

        for node in nodes:

            if node != nullid:

                yield self.t(t1, node=hex(node), rev=rev(node), **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(list, files):

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

            for f in files:

                if f[-1] != os.sep:

                    f += os.sep

                l += [x for x in list if x.startswith(f)]

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

        c, a, d, u = r.changes(node1, node2)

        if files:

            c, a, d = map(lambda x: filterfiles(x, files), (c, a, d))

        for f in c:

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

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

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

        for f in a:

            to = None

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

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

        for f in d:

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

            tn = None

            yield diffblock(mdiff.unidiff(to, date1, tn, date2, f), 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": ""}

        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.parents("changelogparent",

                                                    cl.parents(n), cl.rev),

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

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

                             "desc": changes[4],

                             "date": changes[2],

                             "files": self.listfilediffs(changes[3], n),

                             "rev": i,

                             "node": hn})

                parity = 1 - parity

            for e in l:

                yield e

        cl = self.repo.changelog

        mf = cl.read(cl.tip())[0]

        count = cl.count()

        start = max(0, pos - self.maxchanges + 1)

        end = min(count, start + self.maxchanges)

        pos = end - 1

        yield self.t('changelog',

                     changenav=changenav,

                     manifest=hex(mf),

                     rev=pos, changesets=count, entries=changelist)

    def search(self, query):

        def changelist(**map):

            cl = self.repo.changelog

            count = 0

            qw = query.lower().split()

            def revgen():

                for i in range(cl.count() - 1, 0, -100):

                    l = []

                    for j in range(max(0, i - 100), i):

                        n = cl.node(j)

                        changes = cl.read(n)

                        l.append((n, j, changes))

                    l.reverse()

                    for e in l:

                        yield e

            for n, i, changes in revgen():

                miss = 0

                for q in qw:

                    if not (q in changes[1].lower() or

                            q in changes[4].lower() or

                            q in " ".join(changes[3][:20]).lower()):

                        miss = 1

                        break

                if miss:

                    continue

                count += 1

                hn = hex(n)

                yield self.t('searchentry',

                             parity=count & 1,

                             author=changes[1],

                             parent=self.parents("changelogparent",

                                                 cl.parents(n), cl.rev),

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

                             manifest=hex(changes[0]),

                             desc=changes[4],

                             date=changes[2],

                             files=self.listfilediffs(changes[3], n),

                             rev=i,

                             node=hn)

                if count >= self.maxchanges:

                    break

        cl = self.repo.changelog

        mf = cl.read(cl.tip())[0]

        yield self.t('search',

                     query=query,

                     manifest=hex(mf),

                     entries=changelist)

    def changeset(self, nodeid):

        cl = self.repo.changelog

        n = self.repo.lookup(nodeid)

        nodeid = hex(n)

        changes = cl.read(n)

        p1 = cl.parents(n)[0]

        files = []

        mf = self.repo.manifest.read(changes[0])

        for f in changes[3]:

            files.append(self.t("filenodelink",

                                filenode=hex(mf.get(f, nullid)), file=f))

        def diff(**map):

            yield self.diff(p1, n, None)

        def archivelist():

            for i in self.archives:

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

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

        yield self.t('changeset',

                     diff=diff,

                     rev=cl.rev(n),

                     node=nodeid,

                     parent=self.parents("changesetparent",

                                         cl.parents(n), cl.rev),

                     changesettag=self.showtag("changesettag",n),

                     manifest=hex(changes[0]),

                     author=changes[1],

                     desc=changes[4],

                     date=changes[2],

                     files=files,

                     archives=archivelist())

    def filelog(self, f, filenode):

        cl = self.repo.changelog

        fl = self.repo.file(f)

        filenode = hex(fl.lookup(filenode))

        count = fl.count()

        def entries(**map):

            l = []

            parity = (count - 1) & 1

            for i in range(count):

                n = fl.node(i)

                lr = fl.linkrev(n)

                cn = cl.node(lr)

                cs = cl.read(cl.node(lr))

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

                             "filenode": hex(n),

                             "filerev": i,

                             "file": f,

                             "node": hex(cn),

                             "author": cs[1],

                             "date": cs[2],

                             "parent": self.parents("filelogparent",

                                                    fl.parents(n),

                                                    fl.rev, file=f),

                             "desc": cs[4]})

                parity = 1 - parity

            for e in l:

                yield e

        yield self.t("filelog", file=f, filenode=filenode, entries=entries)

    def filerevision(self, f, node):

        fl = self.repo.file(f)

        n = fl.lookup(node)

        node = hex(n)

        text = fl.read(n)

        changerev = fl.linkrev(n)

        cl = self.repo.changelog

        cn = cl.node(changerev)

        cs = cl.read(cn)

        mfn = cs[0]

        def lines():

            for l, t in enumerate(text.splitlines(1)):

                yield {"line": t,

                       "linenumber": "% 6d" % (l + 1),

                       "parity": l & 1}

        yield self.t("filerevision",

                     file=f,

                     filenode=node,

                     path=up(f),

                     text=lines(),

                     rev=changerev,

                     node=hex(cn),

                     manifest=hex(mfn),

                     author=cs[1],