# 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:revlog,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 + "/"

def revnavgen(pos, pagelen, limit):

    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, pos + f))

            if pos - f >= 0:

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

        yield {"label": "(0)", "rev": 0}

        for label, rev in l:

            yield {"label": label, "rev": rev}

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

    return nav

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:

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

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

        pos = ctx.rev()

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

        end = min(count, start + maxchanges)

        pos = end - 1

        changenav = revnavgen(pos, maxchanges, count)

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

        pagelen = self.maxshortchanges

        def entries(**map):

            l = []

            parity = (count - 1) & 1

            for i in range(start, end):

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

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

                             "desc": ctx.description()})

                parity = 1 - parity

            for e in l:

                yield e

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

                     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

        mt = mt or 'text/plain'

        def lines():

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

                yield {"line": t,

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

                       "parity": self.stripes(l)}

        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().execf(f))

    def fileannotate(self, fctx):

        f = fctx.path()

        n = fctx.filenode()

        fl = fctx.filelog()

        def annotate(**map):

            parity = 0

            last = None

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

                fnode = f.filenode()

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

                if last != fnode:

                    parity = 1 - parity

                    last = fnode

                yield {"parity": parity,

                       "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().execf(f))

    def manifest(self, ctx, path):

        mf = ctx.manifest()

        node = ctx.node()

        files = {}

        p = path[1:]

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

            p += "/"

        l = len(p)

        for f,n in mf.items():

            if f[:l] != p:

                continue

            remain = f[l:]

            if "/" in remain:

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

                files[short] = (f, None)

            else:

                short = os.path.basename(remain)

                files[short] = (f, n)

        def filelist(**map):

            parity = 0

            fl = files.keys()

            fl.sort()

            for f in fl:

                full, fnode = files[f]

                if not fnode:

                    continue

                yield {"file": full,

                       "parity": self.stripes(parity),

                       "basename": f,

                       "size": ctx.filectx(full).size(),

                       "permissions": mf.execf(full)}

                parity += 1

        def dirlist(**map):

            parity = 0

            fl = files.keys()

            fl.sort()

            for f in fl:

                full, fnode = files[f]

                if fnode:

                    continue

                yield {"parity": self.stripes(parity),

                       "path": os.path.join(path, f),

                       "basename": f[:-1]}

                parity += 1

        yield self.t("manifest",

                     rev=ctx.rev(),

                     node=hex(node),

                     path=path,

                     up=_up(path),

                     fentries=filelist,

                     dentries=dirlist,

                     archives=self.archivelist(hex(node)))

    def tags(self):