# 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, time, re, difflib, sys, zlib

from mercurial.hg import *

from mercurial.ui 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(t):

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

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

    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 httphdr(type):

    print 'Content-type: %s\n' % type

def write(*things):

    for thing in things:

        if hasattr(thing, "__iter__"):

            for part in thing:

                write(part)

        else:

            sys.stdout.write(str(thing))

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

    while tmpl:

        m = re.search(r"#([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() or v

            fl = m.group(2)

            if fl:

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

                    v = filters[f](v)

            yield v

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

        else:

            yield tmpl

            return

class templater:

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

        self.cache = {}

        self.map = {}

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

        self.filters = filters

        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 "unknown map entry '%s'"  % l

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

        try:

            tmpl = self.cache[t]

        except KeyError:

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

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

class hgweb:

    maxchanges = 10

    maxfiles = 10

    def __init__(self, path, name, templates = ""):

        self.templates = templates or templatepath()

        self.reponame = name

        self.path = path

        self.mtime = -1

        self.viewonly = 0

        self.filters = {

            "escape": cgi.escape,

            "age": age,

            "date": (lambda x: time.asctime(time.gmtime(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--")

            }

    def refresh(self):

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

        if s.st_mtime != self.mtime:

            self.mtime = s.st_mtime

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

    def date(self, cs):

        return time.asctime(time.gmtime(float(cs[2].split(' ')[0])))

    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 parent(self, t1, node=nullid, rev=-1, **args):

        if node != hex(nullid):

            yield self.t(t1, node = node, rev = rev, **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 = self.date(change1)

        date2 = self.date(change2)

        c, a, d = r.diffrevs(node1, node2)

        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 header(self):

        yield self.t("header", repo = self.reponame)

    def footer(self):

        yield self.t("footer", repo = self.reponame)

    def changelog(self, pos):

        def changenav():

            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 self.t("naventry", rev = 0, label="(0)")

            for label, rev in l:

                yield self.t("naventry", label = label, rev = rev)

            yield self.t("naventry", label="tip")

        def changelist():

            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)

                p1, p2 = cl.parents(n)

                t = float(changes[2].split(' ')[0])

                l.insert(0, self.t(

                    'changelogentry',

                    parity = parity,

                    author = changes[1],

                    parent1 = self.parent("changelogparent",

                                          hex(p1), cl.rev(p1)),

                    parent2 = self.parent("changelogparent",

                                          hex(p2), cl.rev(p2)),

                    p1 = hex(p1), p2 = hex(p2),

                    p1rev = cl.rev(p1), p2rev = cl.rev(p2),

                    manifest = hex(changes[0]),

                    desc = changes[4],

                    date = t,

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

                    rev = i,

                    node = hn))

                parity = 1 - parity

            yield l

        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',

                     header = self.header(),

                     footer = self.footer(),

                     repo = self.reponame,

                     changenav = changenav,

                     manifest = hex(mf),

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

    def changeset(self, nodeid):

        n = bin(nodeid)

        cl = self.repo.changelog

        changes = cl.read(n)

        p1, p2 = cl.parents(n)

        p1rev, p2rev = cl.rev(p1), cl.rev(p2)

        t = float(changes[2].split(' ')[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():

            yield self.diff(p1, n, changes[3])

        yield self.t('changeset',

                     header = self.header(),

                     footer = self.footer(),

                     repo = self.reponame,

                     diff = diff,

                     rev = cl.rev(n),

                     node = nodeid,

                     parent1 = self.parent("changesetparent",

                                           hex(p1), cl.rev(p1)),

                     parent2 = self.parent("changesetparent",

                                           hex(p2), cl.rev(p2)),

                     p1 = hex(p1), p2 = hex(p2),

                     p1rev = cl.rev(p1), p2rev = cl.rev(p2),

                     manifest = hex(changes[0]),

                     author = changes[1],

                     desc = changes[4],

                     date = t,

                     files = files)

    def filelog(self, f, filenode):

        cl = self.repo.changelog

        fl = self.repo.file(f)

        count = fl.count()

        def entries():

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

                p1, p2 = fl.parents(n)

                t = float(cs[2].split(' ')[0])

                l.insert(0, self.t("filelogentry",

                                   parity = parity,

                                   filenode = hex(n),

                                   filerev = i,

                                   file = f,

                                   node = hex(cn),

                                   author = cs[1],

                                   date = t,

                                   desc = cs[4],

                                   p1 = hex(p1), p2 = hex(p2),

                                   p1rev = fl.rev(p1), p2rev = fl.rev(p2)))

                parity = 1 - parity

            yield l

        yield self.t("filelog",

                     header = self.header(),

                     footer = self.footer(),

                     repo = self.reponame,

                     file = f,

                     filenode = filenode,

                     entries = entries)

    def filerevision(self, f, node):

        fl = self.repo.file(f)

        n = bin(node)

        text = fl.read(n)

        changerev = fl.linkrev(n)

        cl = self.repo.changelog

        cn = cl.node(changerev)

        cs = cl.read(cn)

        p1, p2 = fl.parents(n)

        t = float(cs[2].split(' ')[0])

        mfn = cs[0]

        def lines():

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

                yield self.t("fileline", line = t,

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

                             parity = l & 1)

        yield self.t("filerevision", file = f,

                     header = self.header(),

                     footer = self.footer(),

                     repo = self.reponame,

                     filenode = node,

                     path = up(f),

                     text = lines(),

                     rev = changerev,

                     node = hex(cn),

                     manifest = hex(mfn),

                     author = cs[1],

                     date = t,

                     parent1 = self.parent("filerevparent",

                                           hex(p1), fl.rev(p1), file=f),

                     parent2 = self.parent("filerevparent",

                                           hex(p2), fl.rev(p2), file=f),

                     p1 = hex(p1), p2 = hex(p2),

                     permissions = self.repo.manifest.readflags(mfn)[f],

                     p1rev = fl.rev(p1), p2rev = fl.rev(p2))

    def fileannotate(self, f, node):

        bcache = {}

        ncache = {}

        fl = self.repo.file(f)

        n = bin(node)

        changerev = fl.linkrev(n)

        cl = self.repo.changelog

        cn = cl.node(changerev)

        cs = cl.read(cn)

        p1, p2 = fl.parents(n)

        t = float(cs[2].split(' ')[0])

        mfn = cs[0]

        def annotate():

            parity = 1

            last = None

            for r, l in fl.annotate(n):

                try:

                    cnode = ncache[r]

                except KeyError:

                    cnode = ncache[r] = self.repo.changelog.node(r)

                try:

                    name = bcache[r]

                except KeyError:

                    cl = self.repo.changelog.read(cnode)

                    name = cl[1]

                    f = name.find('@')

                    if f >= 0:

                        name = name[:f]

                    bcache[r] = name

                if last != cnode:

                    parity = 1 - parity

                    last = cnode

                yield self.t("annotateline",

                             parity = parity,

                             node = hex(cnode),

                             rev = r,

                             author = name,

                             file = f,

                             line = l)

        yield self.t("fileannotate",

                     header = self.header(),

                     footer = self.footer(),

                     repo = self.reponame,

                     file = f,

                     filenode = node,

                     annotate = annotate,

                     path = up(f),

                     rev = changerev,

                     node = hex(cn),

                     manifest = hex(mfn),

                     author = cs[1],

                     date = t,

                     parent1 = self.parent("fileannotateparent",

                                           hex(p1), fl.rev(p1), file=f),

                     parent2 = self.parent("fileannotateparent",

                                           hex(p2), fl.rev(p2), file=f),

                     p1 = hex(p1), p2 = hex(p2),

                     permissions = self.repo.manifest.readflags(mfn)[f],

                     p1rev = fl.rev(p1), p2rev = fl.rev(p2))

    def manifest(self, mnode, path):

        mf = self.repo.manifest.read(bin(mnode))

        rev = self.repo.manifest.rev(bin(mnode))

        node = self.repo.changelog.node(rev)

        mff=self.repo.manifest.readflags(bin(mnode))

        files = {}

        p = path[1:]

        l = len(p)

        for f,n in mf.items():

            if f[:l] != p:

                continue

            remain = f[l:]

            if "/" in remain: