# hgweb/hgweb_mod.py - Web interface for a repository.

#

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

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

import os, mimetypes, re, zlib, mimetools, cStringIO, sys

import tempfile, urllib, bz2

from mercurial.node import *

from mercurial.i18n import gettext as _

from mercurial import mdiff, ui, hg, util, archival, streamclone, patch

from mercurial import revlog, templater

from common import get_mtime, staticfile, style_map, paritygen

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 revnavgen(pos, pagelen, limit, nodefunc):

    def seq(factor, limit=None):

        if limit:

            yield limit

            if limit >= 20 and limit <= 40:

                yield 50

        else:

            yield 1 * factor

            yield 3 * factor

        for f in seq(factor * 10):

            yield f

    def nav(**map):

        l = []

        last = 0

        for f in seq(1, pagelen):

            if f < pagelen or f <= last:

                continue

            if f > limit:

                break

            last = f

            if pos + f < limit:

                l.append(("+%d" % f, hex(nodefunc(pos + f).node())))

            if pos - f >= 0:

                l.insert(0, ("-%d" % f, hex(nodefunc(pos - f).node())))

        try:

            yield {"label": "(0)", "node": hex(nodefunc('0').node())}

            for label, node in l:

                yield {"label": label, "node": node}

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

        except hg.RepoError:

            pass

    return nav

class hgweb(object):

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

        if isinstance(repo, str):

            parentui = ui.ui(report_untrusted=False, interactive=False)

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

        else:

            self.repo = repo

        self.mtime = -1

        self.reponame = name

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

        self.stripecount = 1

        # a repo owner may set web.templates in .hg/hgrc to get any file

        # readable by the user running the CGI script

        self.templatepath = self.config("web", "templates",

                                        templater.templatepath(),

                                        untrusted=False)

    # The CGI scripts are often run by a user different from the repo owner.

    # Trust the settings from the .hg/hgrc files by default.

    def config(self, section, name, default=None, untrusted=True):

        return self.repo.ui.config(section, name, default,

                                   untrusted=untrusted)

    def configbool(self, section, name, default=False, untrusted=True):

        return self.repo.ui.configbool(section, name, default,

                                       untrusted=untrusted)

    def configlist(self, section, name, default=None, untrusted=True):

        return self.repo.ui.configlist(section, name, default,

                                       untrusted=untrusted)

    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.config("web", "maxchanges", 10))

            self.stripecount = int(self.config("web", "stripes", 1))

            self.maxshortchanges = int(self.config("web", "maxshortchanges", 60))

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

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

            self.encoding = self.config("web", "encoding", util._encoding)

    def archivelist(self, nodeid):

        allowed = self.configlist("web", "allow_archive")

        for i, spec in self.archive_specs.iteritems():

            if i in allowed or self.configbool("web", "allow" + i):

                yield {"type" : i, "extension" : spec[2], "node" : nodeid}

    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=[], hiderev=None, **args):

        siblings = [s for s in siblings if s.node() != nullid]

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

            return

        for s in siblings:

            d = {'node': hex(s.node()), 'rev': s.rev()}

            if hasattr(s, 'path'):

                d['file'] = s.path()

            d.update(args)

            yield d

    def renamelink(self, fl, node):

        r = fl.renamed(node)

        if r:

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

        return []

    def nodetagsdict(self, node):

        return [{"name": i} for i in self.repo.nodetags(node)]

    def nodebranchdict(self, ctx):

        branches = []

        branch = ctx.branch()

        # If this is an empty repo, ctx.node() == nullid,

        # ctx.branch() == 'default', but branchtags() is

        # an empty dict. Using dict.get avoids a traceback.

        if self.repo.branchtags().get(branch) == ctx.node():

            branches.append({"name": branch})

        return branches

    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 = paritygen(self.stripecount)

        def diffblock(diff, f, fn):

            yield self.t("diffblock",

                         lines=prettyprintlines(diff),

                         parity=parity.next(),

                         file=f,

                         filenode=hex(fn or nullid))

        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

        c1 = r.changectx(node1)

        c2 = r.changectx(node2)

        date1 = util.datestr(c1.date())

        date2 = util.datestr(c2.date())

        modified, added, removed, deleted, unknown = r.status(node1, node2)[:5]

        if files:

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

                                           (modified, added, removed))

        diffopts = patch.diffopts(self.repo.ui, untrusted=True)

        for f in modified:

            to = c1.filectx(f).data()

            tn = c2.filectx(f).data()

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

                                          opts=diffopts), f, tn)

        for f in added:

            to = None

            tn = c2.filectx(f).data()

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

                                          opts=diffopts), f, tn)

        for f in removed:

            to = c1.filectx(f).data()

            tn = None

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

                                          opts=diffopts), f, tn)

    def changelog(self, ctx, shortlog=False):

        def changelist(limit=0,**map):

            cl = self.repo.changelog

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

            for i in xrange(start, end):

                ctx = self.repo.changectx(i)

                n = ctx.node()

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

                             "author": ctx.user(),

                             "parent": self.siblings(ctx.parents(), i - 1),

                             "child": self.siblings(ctx.children(), i + 1),

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

                             "desc": ctx.description(),

                             "date": ctx.date(),

                             "files": self.listfilediffs(ctx.files(), n),

                             "rev": i,

                             "node": hex(n),

                             "tags": self.nodetagsdict(n),

                             "branches": self.nodebranchdict(ctx)})

            if limit > 0:

                l = l[:limit]

            for e in l:

                yield e

        maxchanges = shortlog and self.maxshortchanges or self.maxchanges

        cl = self.repo.changelog

        count = cl.count()

        pos = ctx.rev()

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

        end = min(count, start + maxchanges)

        pos = end - 1

        parity = paritygen(self.stripecount, offset=start-end)

        changenav = revnavgen(pos, maxchanges, count, self.repo.changectx)

        yield self.t(shortlog and 'shortlog' or 'changelog',

                     changenav=changenav,

                     node=hex(cl.tip()),

                     rev=pos, changesets=count,

                     entries=lambda **x: changelist(limit=0,**x),

                     latestentry=lambda **x: changelist(limit=1,**x),

                     archives=self.archivelist("tip"))

    def search(self, query):

        def changelist(**map):

            cl = self.repo.changelog

            count = 0

            qw = query.lower().split()

            def revgen():

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

                    l = []

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

                        ctx = self.repo.changectx(j)

                        l.append(ctx)

                    l.reverse()

                    for e in l:

                        yield e

            for ctx in revgen():

                miss = 0

                for q in qw:

                    if not (q in ctx.user().lower() or

                            q in ctx.description().lower() or

                            q in " ".join(ctx.files()).lower()):

                        miss = 1

                        break

                if miss:

                    continue

                count += 1

                n = ctx.node()

                yield self.t('searchentry',

                             parity=parity.next(),

                             author=ctx.user(),

                             parent=self.siblings(ctx.parents()),

                             child=self.siblings(ctx.children()),

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

                             desc=ctx.description(),

                             date=ctx.date(),

                             files=self.listfilediffs(ctx.files(), n),

                             rev=ctx.rev(),

                             node=hex(n),

                             tags=self.nodetagsdict(n),

                             branches=self.nodebranchdict(ctx))

                if count >= self.maxchanges:

                    break

        cl = self.repo.changelog

        parity = paritygen(self.stripecount)

        yield self.t('search',

                     query=query,

                     node=hex(cl.tip()),

                     entries=changelist,

                     archives=self.archivelist("tip"))

    def changeset(self, ctx):

        n = ctx.node()

        parents = ctx.parents()

        p1 = parents[0].node()

        files = []

        parity = paritygen(self.stripecount)

        for f in ctx.files():

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

                                node=hex(n), file=f,

                                parity=parity.next()))

        def diff(**map):

            yield self.diff(p1, n, None)

        yield self.t('changeset',

                     diff=diff,

                     rev=ctx.rev(),

                     node=hex(n),

                     parent=self.siblings(parents),

                     child=self.siblings(ctx.children()),

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

                     author=ctx.user(),

                     desc=ctx.description(),

                     date=ctx.date(),

                     files=files,

                     archives=self.archivelist(hex(n)),

                     tags=self.nodetagsdict(n),

                     branches=self.nodebranchdict(ctx))

    def filelog(self, fctx):

        f = fctx.path()

        fl = fctx.filelog()

        count = fl.count()

        pagelen = self.maxshortchanges

        pos = fctx.filerev()

        start = max(0, pos - pagelen + 1)

        end = min(count, start + pagelen)

        pos = end - 1

        parity = paritygen(self.stripecount, offset=start-end)

        def entries(limit=0, **map):

            l = []

            for i in xrange(start, end):

                ctx = fctx.filectx(i)

                n = fl.node(i)

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

                             "filerev": i,

                             "file": f,

                             "node": hex(ctx.node()),

                             "author": ctx.user(),

                             "date": ctx.date(),

                             "rename": self.renamelink(fl, n),

                             "parent": self.siblings(fctx.parents()),

                             "child": self.siblings(fctx.children()),

                             "desc": ctx.description()})

            if limit > 0:

                l = l[:limit]

            for e in l:

                yield e

        nodefunc = lambda x: fctx.filectx(fileid=x)

        nav = revnavgen(pos, pagelen, count, nodefunc)

        yield self.t("filelog", file=f, node=hex(fctx.node()), nav=nav,

                     entries=lambda **x: entries(limit=0, **x),

                     latestentry=lambda **x: entries(limit=1, **x))

    def filerevision(self, fctx):

        f = fctx.path()

        text = fctx.data()

        fl = fctx.filelog()

        n = fctx.filenode()

        parity = paritygen(self.stripecount)

        mt = mimetypes.guess_type(f)[0]

        rawtext = text

        if util.binary(text):

            mt = mt or 'application/octet-stream'

            text = "(binary:%s)" % mt

        mt = mt or 'text/plain'

        def lines():

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

                yield {"line": t,

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

                       "parity": parity.next()}

        yield self.t("filerevision",

                     file=f,

                     path=_up(f),

                     text=lines(),

                     raw=rawtext,

                     mimetype=mt,

                     rev=fctx.rev(),

                     node=hex(fctx.node()),

                     author=fctx.user(),

                     date=fctx.date(),

                     desc=fctx.description(),

                     parent=self.siblings(fctx.parents()),

                     child=self.siblings(fctx.children()),

                     rename=self.renamelink(fl, n),

                     permissions=fctx.manifest().flags(f))

    def fileannotate(self, fctx):

        f = fctx.path()

        n = fctx.filenode()

        fl = fctx.filelog()

        parity = paritygen(self.stripecount)

        def annotate(**map):

            last = None

            for f, l in fctx.annotate(follow=True):

                fnode = f.filenode()

                name = self.repo.ui.shortuser(f.user())

                if last != fnode:

                    last = fnode

                yield {"parity": parity.next(),

                       "node": hex(f.node()),

                       "rev": f.rev(),

                       "author": name,

                       "file": f.path(),

                       "line": l}

        yield self.t("fileannotate",

                     file=f,

                     annotate=annotate,

                     path=_up(f),

                     rev=fctx.rev(),

                     node=hex(fctx.node()),

                     author=fctx.user(),

                     date=fctx.date(),

                     desc=fctx.description(),

                     rename=self.renamelink(fl, n),

                     parent=self.siblings(fctx.parents()),

                     child=self.siblings(fctx.children()),

                     permissions=fctx.manifest().flags(f))

    def manifest(self, ctx, path):

        mf = ctx.manifest()

        node = ctx.node()

        files = {}

        parity = paritygen(self.stripecount)

        if path and path[-1] != "/":

            path += "/"

        l = len(path)

        abspath = "/" + path

        for f, n in mf.items():

            if f[:l] != path:

                continue

            remain = f[l:]

            if "/" in remain:

                short = remain[:remain.index("/") + 1] # bleah

                files[short] = (f, None)

            else:

                short = os.path.basename(remain)