# 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

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

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

        match = matchmod.intersectmatchers(match, relrootmatch)

        copysourcematch = relrootmatch

        def relrootpathfn(f):

            if checkroot and not f.startswith(relroot):

                raise AssertionError(

        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)

    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:

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

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

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:

            return

        columns = self._columns

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

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

        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['user'] % ctx.user(), label='log.user')

        if ctx.isunstable():

            instabilities = ctx.instabilities()

        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:

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

        if copies and self.ui.verbose:

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

        extra = ctx.extra()

        if extra and self.ui.debugflag:

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

        description = ctx.description().strip()

        if description:

            if self.ui.verbose: