# 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, urllib

import mimetypes

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 os.path.normpath(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

def staticfile(directory, fname):

    fname = os.path.realpath(os.path.join(directory, fname))

    try:

        # the static dir should be a substring in the real

        # file path, if it is not, we have something strange

        # going on => security breach attempt?

        #

        # This will either:

        #   1) find the `static' path at index 0  =  success

        #   2) find the `static' path at other index  =  error

        #   3) not find the `static' path  =  ValueError generated

        if fname.index(directory) != 0:

            # generate ValueError manually

            raise ValueError()

        os.stat(fname)

        ct = mimetypes.guess_type(fname)[0] or "text/plain"

        return "Content-type: %s\n\n%s" % (ct, file(fname).read())

    except ValueError:

        # security breach attempt

        return ""

    except OSError, e:

        if e.errno == errno.ENOENT:

            return ""

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

    "escape": lambda x: cgi.escape(x, True),

    "urlescape": urllib.quote,

    "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 renamelink(self, fl, node):

        r = fl.renamed(node)

        if r:

            return [dict(file=r[0], node=hex(r[1]))]

        return []

    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, maxchanges=None):

                if maxchanges:

                    yield maxchanges

                    if maxchanges >= 20 and maxchanges <= 40:

                        yield 50

                else:

                    yield 1 * factor

                    yield 3 * factor

                for f in seq(factor * 10):

                    yield f

            l = []

            last = 0

            for f in seq(1, self.maxchanges):

                if f < self.maxchanges or f <= last:

                    continue

                if f > count:

                    break

                last = f

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

                             "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.siblings(cl.parents(n), cl.rev),

                             child=self.siblings(cl.children(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)

        yield self.t('changeset',

                     diff=diff,

                     rev=cl.rev(n),

                     node=nodeid,

                     parent=self.siblings(cl.parents(n), cl.rev),

                     child=self.siblings(cl.children(n), cl.rev),

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

                     manifest=hex(changes[0]),

                     author=changes[1],

                     desc=changes[4],

                     date=changes[2],