# 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(b'limit')

    if limit:

        try:

            limit = int(limit)

        except ValueError:

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

        if limit <= 0:

            raise error.Abort(_(b'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=b'',

    root=b'',

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

    copysourcematch = None

    def compose(f, g):

        return lambda x: f(g(x))

    def pathfn(f):

        return posixpath.join(prefix, f)

    if relroot != b'':

        # 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 += b'/'

        for matchroot in match.files():

            if not matchroot.startswith(relroot):

                ui.warn(

                    _(b'warning: %s not inside relative root %s\n')

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

                )

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

        match = matchmod.intersectmatchers(match, relrootmatch)

        copysourcematch = relrootmatch

        checkroot = repo.ui.configbool(

            b'devel', b'all-warnings'

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

        def relrootpathfn(f):

            if checkroot and not f.startswith(relroot):

                raise AssertionError(

                    b"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 = [b'log.changeset', b'changeset.%s' % ctx.phasestr()]

    if ctx.obsolete():

        labels.append(b'changeset.obsolete')

    if ctx.isunstable():

        labels.append(b'changeset.unstable')

        for instability in ctx.instabilities():

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

    return b' '.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(b'stat')

        self._includediff = diffopts and diffopts.get(b'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(b'graphwidth', 0)

        if self.ui.quiet:

            self.ui.write(

                b"%s\n" % scmutil.formatchangeid(ctx), label=b'log.node'

            )

            return

        columns = self._columns

        self.ui.write(

            columns[b'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 != b'default':

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

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

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

            # skip it

            if nsname == b'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=b'log.%s' % ns.colorname)

        if self.ui.debugflag:

            self.ui.write(

                columns[b'phase'] % ctx.phasestr(), label=b'log.phase'

            )

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

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

            self.ui.write(

                columns[b'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[b'manifest']

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

                label=b'ui.debug log.manifest',

            )

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

        self.ui.write(

            columns[b'date'] % dateutil.datestr(ctx.date()), label=b'log.date'

        )

        if ctx.isunstable():

            instabilities = ctx.instabilities()

            self.ui.write(

                columns[b'instability'] % b', '.join(instabilities),

                label=b'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([b'files', b'files+', b'files-'], files):

                if value:

                    self.ui.write(

                        columns[key] % b" ".join(value),

                        label=b'ui.debug log.files',

                    )

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

            self.ui.write(

                columns[b'files'] % b" ".join(ctx.files()),

                label=b'ui.note log.files',

            )

        if copies and self.ui.verbose:

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

            self.ui.write(

                columns[b'copies'] % b' '.join(copies),

                label=b'ui.note log.copies',

            )

        extra = ctx.extra()

        if extra and self.ui.debugflag:

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

                self.ui.write(

                    columns[b'extra'] % (key, stringutil.escapestr(value)),