# logcmdutil.py - utility for log-like commands

#

# 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 version 2 or any later version.

from __future__ import absolute_import

import itertools

import os

import posixpath

from .i18n import _

from .node import (

    nullid,

    wdirid,

    wdirrev,

)

from . import (

    dagop,

    error,

    formatter,

    graphmod,

    match as matchmod,

    mdiff,

    patch,

    pathutil,

    pycompat,

    revset,

    revsetlang,

    scmutil,

    smartset,

    templatekw,

    templater,

    util,

)

from .utils import (

    dateutil,

    stringutil,

)

def getlimit(opts):

    """get the log limit according to option -l/--limit"""

    limit = opts.get('limit')

    if limit:

        try:

            limit = int(limit)

        except ValueError:

            raise error.Abort(_('limit must be a positive integer'))

        if limit <= 0:

            raise error.Abort(_('limit must be positive'))

    else:

        limit = None

    return limit

def diffordiffstat(ui, repo, diffopts, node1, node2, match,

                   changes=None, stat=False, fp=None, graphwidth=0,

                   prefix='', root='', listsubrepos=False, hunksfilterfn=None):

    '''show diff or diffstat.'''

    ctx1 = repo[node1]

    ctx2 = repo[node2]

    if root:

        relroot = pathutil.canonpath(repo.root, repo.getcwd(), root)

    else:

        relroot = ''

    copysourcematch = None

    def compose(f, g):

        return lambda x: f(g(x))

    def pathfn(f):

        return posixpath.join(prefix, f)

    if relroot != '':

        # XXX relative roots currently don't work if the root is within a

        # subrepo

        uipathfn = scmutil.getuipathfn(repo, legacyrelativevalue=True)

        uirelroot = uipathfn(pathfn(relroot))

        relroot += '/'

        for matchroot in match.files():

            if not matchroot.startswith(relroot):

                ui.warn(_('warning: %s not inside relative root %s\n') %

                        (uipathfn(pathfn(matchroot)), uirelroot))

        relrootmatch = scmutil.match(ctx2, pats=[relroot], default='path')

        match = matchmod.intersectmatchers(match, relrootmatch)

        copysourcematch = relrootmatch

        checkroot = (repo.ui.configbool('devel', 'all-warnings') or

                     repo.ui.configbool('devel', 'check-relroot'))

        def relrootpathfn(f):

            if checkroot and not f.startswith(relroot):

                raise AssertionError(

                    "file %s doesn't start with relroot %s" % (f, relroot))

            return f[len(relroot):]

        pathfn = compose(relrootpathfn, pathfn)

    if stat:

        diffopts = diffopts.copy(context=0, noprefix=False)

        width = 80

        if not ui.plain():

            width = ui.termwidth() - graphwidth

        # If an explicit --root was given, don't respect ui.relative-paths

        if not relroot:

            pathfn = compose(scmutil.getuipathfn(repo), pathfn)

    chunks = ctx2.diff(ctx1, match, changes, opts=diffopts, pathfn=pathfn,

                       copysourcematch=copysourcematch,

                       hunksfilterfn=hunksfilterfn)

    if fp is not None or ui.canwritewithoutlabels():

        out = fp or ui

        if stat:

            chunks = [patch.diffstat(util.iterlines(chunks), width=width)]

        for chunk in util.filechunkiter(util.chunkbuffer(chunks)):

            out.write(chunk)

    else:

        if stat:

            chunks = patch.diffstatui(util.iterlines(chunks), width=width)

        else:

            chunks = patch.difflabel(lambda chunks, **kwargs: chunks, chunks,

                                     opts=diffopts)

        if ui.canbatchlabeledwrites():

            def gen():

                for chunk, label in chunks:

                    yield ui.label(chunk, label=label)

            for chunk in util.filechunkiter(util.chunkbuffer(gen())):

                ui.write(chunk)

        else:

            for chunk, label in chunks:

                ui.write(chunk, label=label)

    for subpath, sub in scmutil.itersubrepos(ctx1, ctx2):

        tempnode2 = node2

        try:

            if node2 is not None:

                tempnode2 = ctx2.substate[subpath][1]

        except KeyError:

            # A subrepo that existed in node1 was deleted between node1 and

            # node2 (inclusive). Thus, ctx2's substate won't contain that

            # subpath. The best we can do is to ignore it.

            tempnode2 = None

        submatch = matchmod.subdirmatcher(subpath, match)

        subprefix = repo.wvfs.reljoin(prefix, subpath)

        if listsubrepos or match.exact(subpath) or any(submatch.files()):

            sub.diff(ui, diffopts, tempnode2, submatch, changes=changes,

                     stat=stat, fp=fp, prefix=subprefix)

class changesetdiffer(object):

    """Generate diff of changeset with pre-configured filtering functions"""

    def _makefilematcher(self, ctx):

        return scmutil.matchall(ctx.repo())

    def _makehunksfilter(self, ctx):

        return None

    def showdiff(self, ui, ctx, diffopts, graphwidth=0, stat=False):

        repo = ctx.repo()

        node = ctx.node()

        prev = ctx.p1().node()

        diffordiffstat(ui, repo, diffopts, prev, node,

                       match=self._makefilematcher(ctx), stat=stat,

                       graphwidth=graphwidth,

                       hunksfilterfn=self._makehunksfilter(ctx))

def changesetlabels(ctx):

    labels = ['log.changeset', 'changeset.%s' % ctx.phasestr()]

    if ctx.obsolete():

        labels.append('changeset.obsolete')

    if ctx.isunstable():

        labels.append('changeset.unstable')

        for instability in ctx.instabilities():

            labels.append('instability.%s' % instability)

    return ' '.join(labels)

class changesetprinter(object):

    '''show changeset information when templating not requested.'''

    def __init__(self, ui, repo, differ=None, diffopts=None, buffered=False):

        self.ui = ui

        self.repo = repo

        self.buffered = buffered

        self._differ = differ or changesetdiffer()

        self._diffopts = patch.diffallopts(ui, diffopts)

        self._includestat = diffopts and diffopts.get('stat')

        self._includediff = diffopts and diffopts.get('patch')

        self.header = {}

        self.hunk = {}

        self.lastheader = None

        self.footer = None

        self._columns = templatekw.getlogcolumns()

    def flush(self, ctx):

        rev = ctx.rev()

        if rev in self.header:

            h = self.header[rev]

            if h != self.lastheader:

                self.lastheader = h

                self.ui.write(h)

            del self.header[rev]

        if rev in self.hunk:

            self.ui.write(self.hunk[rev])

            del self.hunk[rev]

    def close(self):

        if self.footer:

            self.ui.write(self.footer)

    def show(self, ctx, copies=None, **props):

        props = pycompat.byteskwargs(props)

        if self.buffered:

            self.ui.pushbuffer(labeled=True)

            self._show(ctx, copies, props)

            self.hunk[ctx.rev()] = self.ui.popbuffer()

        else:

            self._show(ctx, copies, props)

    def _show(self, ctx, copies, props):

        '''show a single changeset or file revision'''

        changenode = ctx.node()

        graphwidth = props.get('graphwidth', 0)

        if self.ui.quiet:

            self.ui.write("%s\n" % scmutil.formatchangeid(ctx),

                          label='log.node')

            return

        columns = self._columns

        self.ui.write(columns['changeset'] % scmutil.formatchangeid(ctx),

                      label=changesetlabels(ctx))

        # branches are shown first before any other names due to backwards

        # compatibility

        branch = ctx.branch()

        # don't show the default branch name

        if branch != 'default':

            self.ui.write(columns['branch'] % branch, label='log.branch')

        for nsname, ns in self.repo.names.iteritems():

            # branches has special logic already handled above, so here we just

            # skip it

            if nsname == 'branches':

                continue

            # we will use the templatename as the color name since those two

            # should be the same

            for name in ns.names(self.repo, changenode):

                self.ui.write(ns.logfmt % name,

                              label='log.%s' % ns.colorname)

        if self.ui.debugflag:

            self.ui.write(columns['phase'] % ctx.phasestr(), label='log.phase')

        for pctx in scmutil.meaningfulparents(self.repo, ctx):

            label = 'log.parent changeset.%s' % pctx.phasestr()

            self.ui.write(columns['parent'] % scmutil.formatchangeid(pctx),

                          label=label)

        if self.ui.debugflag:

            mnode = ctx.manifestnode()

            if mnode is None:

                mnode = wdirid

                mrev = wdirrev

            else:

                mrev = self.repo.manifestlog.rev(mnode)

            self.ui.write(columns['manifest']

                          % scmutil.formatrevnode(self.ui, mrev, mnode),

                          label='ui.debug log.manifest')

        self.ui.write(columns['user'] % ctx.user(), label='log.user')

        self.ui.write(columns['date'] % dateutil.datestr(ctx.date()),

                      label='log.date')

        if ctx.isunstable():

            instabilities = ctx.instabilities()

            self.ui.write(columns['instability'] % ', '.join(instabilities),

                          label='log.instability')

        elif ctx.obsolete():

            self._showobsfate(ctx)

        self._exthook(ctx)

        if self.ui.debugflag:

            files = ctx.p1().status(ctx)[:3]

            for key, value in zip(['files', 'files+', 'files-'], files):

                if value:

                    self.ui.write(columns[key] % " ".join(value),

                                  label='ui.debug log.files')

        elif ctx.files() and self.ui.verbose:

            self.ui.write(columns['files'] % " ".join(ctx.files()),

                          label='ui.note log.files')

        if copies and self.ui.verbose:

            copies = ['%s (%s)' % c for c in copies]

            self.ui.write(columns['copies'] % ' '.join(copies),

                          label='ui.note log.copies')

        extra = ctx.extra()

        if extra and self.ui.debugflag:

            for key, value in sorted(extra.items()):

                self.ui.write(columns['extra']

                              % (key, stringutil.escapestr(value)),

                              label='ui.debug log.extra')

        description = ctx.description().strip()

        if description:

            if self.ui.verbose:

                self.ui.write(_("description:\n"),

                              label='ui.note log.description')

                self.ui.write(description,

                              label='ui.note log.description')

                self.ui.write("\n\n")

            else:

                self.ui.write(columns['summary'] % description.splitlines()[0],

                              label='log.summary')

        self.ui.write("\n")

        self._showpatch(ctx, graphwidth)

    def _showobsfate(self, ctx):

        # TODO: do not depend on templater

        tres = formatter.templateresources(self.repo.ui, self.repo)

        t = formatter.maketemplater(self.repo.ui, '{join(obsfate, "\n")}',

                                    defaults=templatekw.keywords,

                                    resources=tres)

        obsfate = t.renderdefault({'ctx': ctx}).splitlines()

        if obsfate:

            for obsfateline in obsfate:

                self.ui.write(self._columns['obsolete'] % obsfateline,

                              label='log.obsfate')

    def _exthook(self, ctx):

        '''empty method used by extension as a hook point

        '''

    def _showpatch(self, ctx, graphwidth=0):

        if self._includestat:

            self._differ.showdiff(self.ui, ctx, self._diffopts,

                                  graphwidth, stat=True)

        if self._includestat and self._includediff:

            self.ui.write("\n")

        if self._includediff:

            self._differ.showdiff(self.ui, ctx, self._diffopts,

                                  graphwidth, stat=False)

        if self._includestat or self._includediff:

            self.ui.write("\n")

class changesetformatter(changesetprinter):

    """Format changeset information by generic formatter"""

    def __init__(self, ui, repo, fm, differ=None, diffopts=None,

                 buffered=False):