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

#

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

# Copyright 2005, 2006 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

import os.path

import mimetypes

from mercurial.demandload import demandload

demandload(globals(), "re zlib ConfigParser mimetools cStringIO sys tempfile")

demandload(globals(), 'urllib')

demandload(globals(), "mercurial:mdiff,ui,hg,util,archival,streamclone,patch")

demandload(globals(), "mercurial:templater")

demandload(globals(), "mercurial.hgweb.common:get_mtime,staticfile,style_map")

from mercurial.node import *

from mercurial.i18n import gettext as _

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

        self.stripecount = 1

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

                                                templater.templatepath())

    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.stripecount = int(self.repo.ui.config("web", "stripes", 1))

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

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

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

    def archivelist(self, nodeid):

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

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

            if i in allowed or self.repo.ui.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:

            yield dict(node=hex(s.node()), rev=s.rev(), **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.status(node1, node2)[:5]

        if files:

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

                                           (modified, added, removed))

        diffopts = patch.diffopts(self.repo.ui)

        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,

                                          opts=diffopts), f, tn)

        for f in added:

            to = None

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

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

                                          opts=diffopts), f, tn)

        for f in removed:

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

            tn = None

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

                                          opts=diffopts), f, tn)

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

        pos = ctx.rev()

        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

            maxchanges = shortlog and self.maxshortchanges or self.maxchanges

            for f in seq(1, maxchanges):

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

                ctx = self.repo.changectx(i)

                n = ctx.node()

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

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

                parity = 1 - parity

            for e in l:

                yield e

        maxchanges = shortlog and self.maxshortchanges or self.maxchanges

        cl = self.repo.changelog

        count = cl.count()

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

        end = min(count, start + maxchanges)

        pos = end - 1

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

                     changenav=changenav,

                     node=hex(cl.tip()),

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

                     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 range(cl.count() - 1, 0, -100):

                    l = []

                    for j in range(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()[:20]).lower()):

                        miss = 1

                        break

                if miss:

                    continue

                count += 1

                n = ctx.node()

                yield self.t('searchentry',

                             parity=self.stripes(count),

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

                if count >= self.maxchanges:

                    break

        cl = self.repo.changelog

        yield self.t('search',

                     query=query,

                     node=hex(cl.tip()),

                     entries=changelist)

    def changeset(self, ctx):

        n = ctx.node()

        parents = ctx.parents()

        p1 = parents[0].node()

        files = []

        parity = 0

        for f in ctx.files():

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

                                node=hex(n), file=f,

                                parity=parity))

            parity = 1 - parity

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

    def filelog(self, fctx):

        f = fctx.path()

        fl = fctx.filelog()

        count = fl.count()

        def entries(**map):

            l = []

            parity = (count - 1) & 1

            for i in range(count):

                ctx = fctx.filectx(i)

                n = fl.node(i)

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

                             "filerev": i,

                             "file": f,

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

                             "author": ctx.user(),

                             "date": ctx.date(),

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

                             "parent": self.siblings(fctx.parents(), file=f),

                             "child": self.siblings(fctx.children(), file=f),

                             "desc": ctx.description()})

                parity = 1 - parity

            for e in l:

                yield e

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

    def filerevision(self, fctx):

        f = fctx.path()

        text = fctx.data()

        fl = fctx.filelog()

        n = fctx.filenode()

        mt = mimetypes.guess_type(f)[0]

        rawtext = text

        if util.binary(text):

            mt = mt or 'application/octet-stream'

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