/brz/remove-bazaar

# Copyright (C) 2005-2011 Canonical Ltd

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

"""Code to show logs of changes.

Various flavors of log can be produced:

* for one file, or the whole tree, and (not done yet) for

  files in a given directory

* in "verbose" mode with a description of what changed from one

  version to the next

* with files and revision-ids shown

Logs are actually written out through an abstract LogFormatter

interface, which allows for different preferred formats.  Plugins can

register formats too.

Logs can be produced in either forward (oldest->newest) or reverse

(newest->oldest) order.

Logs can be filtered to show only revisions matching a particular

search string, or within a particular range of revisions.  The range

can be given as date/times, which are reduced to revisions before

calling in here.

In verbose mode we show a summary of what changed in each particular

revision.  Note that this is the delta for changes in that revision

relative to its left-most parent, not the delta relative to the last

logged revision.  So for example if you ask for a verbose log of

changes touching hello.c you will get a list of those revisions also

listing other things that were changed in the same revision, but not

all the changes since the previous revision that touched hello.c.

"""

import codecs

from io import BytesIO

import itertools

import re

import sys

from warnings import (

    warn,

    )

from .lazy_import import lazy_import

lazy_import(globals(), """

from breezy import (

    config,

    controldir,

    diff,

    foreign,

    lazy_regex,

    revision as _mod_revision,

    )

from breezy.i18n import gettext, ngettext

""")

from . import (

    errors,

    registry,

    revisionspec,

    trace,

    )

from .osutils import (

    format_date,

    format_date_with_offset_in_original_timezone,

    get_diff_header_encoding,

    get_terminal_encoding,

    is_inside,

    terminal_width,

    )

from .tree import (

    find_previous_path,

    InterTree,

    )

def find_touching_revisions(repository, last_revision, last_tree, last_path):

    """Yield a description of revisions which affect the file.

    Each returned element is (revno, revision_id, description)

    This is the list of revisions where the file is either added,

    modified, renamed or deleted.

    TODO: Perhaps some way to limit this to only particular revisions,

    or to traverse a non-mainline set of revisions?

    """

    last_verifier = last_tree.get_file_verifier(last_path)

    graph = repository.get_graph()

    history = list(graph.iter_lefthand_ancestry(last_revision, []))

    revno = len(history)

    for revision_id in history:

        this_tree = repository.revision_tree(revision_id)

        this_intertree = InterTree.get(this_tree, last_tree)

        this_path = this_intertree.find_source_path(last_path)

        # now we know how it was last time, and how it is in this revision.

        # are those two states effectively the same or not?

        if this_path is not None and last_path is None:

            yield revno, revision_id, "deleted " + this_path

            this_verifier = this_tree.get_file_verifier(this_path)

        elif this_path is None and last_path is not None:

            yield revno, revision_id, "added " + last_path

        elif this_path != last_path:

            yield revno, revision_id, ("renamed %s => %s" % (this_path, last_path))

            this_verifier = this_tree.get_file_verifier(this_path)

        else:

            this_verifier = this_tree.get_file_verifier(this_path)

            if (this_verifier != last_verifier):

                yield revno, revision_id, "modified " + this_path

        last_verifier = this_verifier

        last_path = this_path

        last_tree = this_tree

        if last_path is None:

            return

        revno -= 1

def show_log(branch,

             lf,

             verbose=False,

             direction='reverse',

             start_revision=None,

             end_revision=None,

             limit=None,

             show_diff=False,

             match=None):

    """Write out human-readable log of commits to this branch.

    This function is being retained for backwards compatibility but

    should not be extended with new parameters. Use the new Logger class

    instead, eg. Logger(branch, rqst).show(lf), adding parameters to the

    make_log_request_dict function.

    :param lf: The LogFormatter object showing the output.

    :param verbose: If True show added/changed/deleted/renamed files.

    :param direction: 'reverse' (default) is latest to earliest; 'forward' is

        earliest to latest.

    :param start_revision: If not None, only show revisions >= start_revision

    :param end_revision: If not None, only show revisions <= end_revision

    :param limit: If set, shows only 'limit' revisions, all revisions are shown

        if None or 0.

    :param show_diff: If True, output a diff after each revision.

    :param match: Dictionary of search lists to use when matching revision

      properties.

    """

    if verbose:

        delta_type = 'full'

    else:

        delta_type = None

    if show_diff:

        diff_type = 'full'

    else:

        diff_type = None

    if isinstance(start_revision, int):

        try:

            start_revision = revisionspec.RevisionInfo(branch, start_revision)

        except (errors.NoSuchRevision, errors.RevnoOutOfBounds):

            raise errors.InvalidRevisionNumber(start_revision)

    if isinstance(end_revision, int):

        try:

            end_revision = revisionspec.RevisionInfo(branch, end_revision)

        except (errors.NoSuchRevision, errors.RevnoOutOfBounds):

            raise errors.InvalidRevisionNumber(end_revision)

    if end_revision is not None and end_revision.revno == 0:

        raise errors.InvalidRevisionNumber(end_revision.revno)

    # Build the request and execute it

    rqst = make_log_request_dict(

        direction=direction,

        start_revision=start_revision, end_revision=end_revision,

        limit=limit, delta_type=delta_type, diff_type=diff_type)

    Logger(branch, rqst).show(lf)

# Note: This needs to be kept in sync with the defaults in

# make_log_request_dict() below

_DEFAULT_REQUEST_PARAMS = {

    'direction': 'reverse',

    'levels': None,

    'generate_tags': True,

    'exclude_common_ancestry': False,

    '_match_using_deltas': True,

    }

def make_log_request_dict(direction='reverse', specific_files=None,

                          start_revision=None, end_revision=None, limit=None,

                          message_search=None, levels=None, generate_tags=True,

                          delta_type=None,

                          diff_type=None, _match_using_deltas=True,

                          exclude_common_ancestry=False, match=None,

                          signature=False, omit_merges=False,

                          ):

    """Convenience function for making a logging request dictionary.

    Using this function may make code slightly safer by ensuring

    parameters have the correct names. It also provides a reference

    point for documenting the supported parameters.

    :param direction: 'reverse' (default) is latest to earliest;

      'forward' is earliest to latest.

    :param specific_files: If not None, only include revisions

      affecting the specified files, rather than all revisions.

    :param start_revision: If not None, only generate

      revisions >= start_revision

    :param end_revision: If not None, only generate

      revisions <= end_revision

    :param limit: If set, generate only 'limit' revisions, all revisions

      are shown if None or 0.

    :param message_search: If not None, only include revisions with

      matching commit messages

    :param levels: the number of levels of revisions to

      generate; 1 for just the mainline; 0 for all levels, or None for

      a sensible default.

    :param generate_tags: If True, include tags for matched revisions.

`

    :param delta_type: Either 'full', 'partial' or None.

      'full' means generate the complete delta - adds/deletes/modifies/etc;

      'partial' means filter the delta using specific_files;

      None means do not generate any delta.

    :param diff_type: Either 'full', 'partial' or None.

      'full' means generate the complete diff - adds/deletes/modifies/etc;

      'partial' means filter the diff using specific_files;

      None means do not generate any diff.

    :param _match_using_deltas: a private parameter controlling the

      algorithm used for matching specific_files. This parameter

      may be removed in the future so breezy client code should NOT

      use it.

    :param exclude_common_ancestry: Whether -rX..Y should be interpreted as a

      range operator or as a graph difference.

    :param signature: show digital signature information

    :param match: Dictionary of list of search strings to use when filtering

      revisions. Keys can be 'message', 'author', 'committer', 'bugs' or

      the empty string to match any of the preceding properties.

    :param omit_merges: If True, commits with more than one parent are

      omitted.

    """

    # Take care of old style message_search parameter

    if message_search:

        if match:

            if 'message' in match:

                match['message'].append(message_search)

            else:

                match['message'] = [message_search]

        else:

            match = {'message': [message_search]}

    return {

        'direction': direction,

        'specific_files': specific_files,

        'start_revision': start_revision,

        'end_revision': end_revision,

        'limit': limit,

        'levels': levels,

        'generate_tags': generate_tags,

        'delta_type': delta_type,

        'diff_type': diff_type,

        'exclude_common_ancestry': exclude_common_ancestry,

        'signature': signature,

        'match': match,

        'omit_merges': omit_merges,

        # Add 'private' attributes for features that may be deprecated

        '_match_using_deltas': _match_using_deltas,

    }

def _apply_log_request_defaults(rqst):

    """Apply default values to a request dictionary."""

    result = _DEFAULT_REQUEST_PARAMS.copy()

    if rqst:

        result.update(rqst)

    return result

def format_signature_validity(rev_id, branch):

    """get the signature validity

    :param rev_id: revision id to validate

    :param branch: branch of revision

    :return: human readable string to print to log

    """

    from breezy import gpg

    gpg_strategy = gpg.GPGStrategy(branch.get_config_stack())

    result = branch.repository.verify_revision_signature(rev_id, gpg_strategy)

    if result[0] == gpg.SIGNATURE_VALID:

        return u"valid signature from {0}".format(result[1])

    if result[0] == gpg.SIGNATURE_KEY_MISSING:

        return "unknown key {0}".format(result[1])

    if result[0] == gpg.SIGNATURE_NOT_VALID:

        return "invalid signature!"

    if result[0] == gpg.SIGNATURE_NOT_SIGNED:

        return "no signature"

class LogGenerator(object):

    """A generator of log revisions."""

    def iter_log_revisions(self):

        """Iterate over LogRevision objects.

        :return: An iterator yielding LogRevision objects.

        """

        raise NotImplementedError(self.iter_log_revisions)

class Logger(object):

    """An object that generates, formats and displays a log."""

    def __init__(self, branch, rqst):

        """Create a Logger.

        :param branch: the branch to log

        :param rqst: A dictionary specifying the query parameters.

          See make_log_request_dict() for supported values.

        """

        self.branch = branch

        self.rqst = _apply_log_request_defaults(rqst)

    def show(self, lf):

        """Display the log.

        :param lf: The LogFormatter object to send the output to.

        """

        if not isinstance(lf, LogFormatter):

            warn("not a LogFormatter instance: %r" % lf)

        with self.branch.lock_read():

            if getattr(lf, 'begin_log', None):

                lf.begin_log()

            self._show_body(lf)

            if getattr(lf, 'end_log', None):

                lf.end_log()

    def _show_body(self, lf):

        """Show the main log output.

        Subclasses may wish to override this.

        """

        # Tweak the LogRequest based on what the LogFormatter can handle.

        # (There's no point generating stuff if the formatter can't display it.)

        rqst = self.rqst

        if rqst['levels'] is None or lf.get_levels() > rqst['levels']:

            # user didn't specify levels, use whatever the LF can handle:

            rqst['levels'] = lf.get_levels()

        if not getattr(lf, 'supports_tags', False):

            rqst['generate_tags'] = False

        if not getattr(lf, 'supports_delta', False):

            rqst['delta_type'] = None

        if not getattr(lf, 'supports_diff', False):

            rqst['diff_type'] = None

        if not getattr(lf, 'supports_signatures', False):

            rqst['signature'] = False

        # Find and print the interesting revisions

        generator = self._generator_factory(self.branch, rqst)

        try:

            for lr in generator.iter_log_revisions():

                lf.log_revision(lr)

        except errors.GhostRevisionUnusableHere:

            raise errors.CommandError(

                gettext('Further revision history missing.'))

        lf.show_advice()

    def _generator_factory(self, branch, rqst):

        """Make the LogGenerator object to use.

        Subclasses may wish to override this.

        """

        return _DefaultLogGenerator(branch, **rqst)

def _log_revision_iterator_using_per_file_graph(

        branch, delta_type, match, levels, path, start_rev_id, end_rev_id,

        direction, exclude_common_ancestry):

    # Get the base revisions, filtering by the revision range.

    # Note that we always generate the merge revisions because

    # filter_revisions_touching_path() requires them ...

    view_revisions = _calc_view_revisions(

        branch, start_rev_id, end_rev_id,

        direction, generate_merge_revisions=True,

        exclude_common_ancestry=exclude_common_ancestry)

    if not isinstance(view_revisions, list):

        view_revisions = list(view_revisions)

    view_revisions = _filter_revisions_touching_path(

        branch, path, view_revisions,

        include_merges=levels != 1)

    return make_log_rev_iterator(

        branch, view_revisions, delta_type, match)

def _log_revision_iterator_using_delta_matching(

        branch, delta_type, match, levels, specific_files, start_rev_id, end_rev_id,

        direction, exclude_common_ancestry, limit):

    # Get the base revisions, filtering by the revision range

    generate_merge_revisions = levels != 1

    delayed_graph_generation = not specific_files and (

        limit or start_rev_id or end_rev_id)

    view_revisions = _calc_view_revisions(

        branch, start_rev_id, end_rev_id,

        direction,

        generate_merge_revisions=generate_merge_revisions,

        delayed_graph_generation=delayed_graph_generation,

        exclude_common_ancestry=exclude_common_ancestry)

    # Apply the other filters

    return make_log_rev_iterator(branch, view_revisions,

                                 delta_type, match,

                                 files=specific_files,

                                 direction=direction)

def _format_diff(branch, rev, diff_type, files=None):

    """Format a diff.

    :param branch: Branch object

    :param rev: Revision object

    :param diff_type: Type of diff to generate

    :param files: List of files to generate diff for (or None for all)

    """

    repo = branch.repository

    if len(rev.parent_ids) == 0:

        ancestor_id = _mod_revision.NULL_REVISION

    else:

        ancestor_id = rev.parent_ids[0]

    tree_1 = repo.revision_tree(ancestor_id)

    tree_2 = repo.revision_tree(rev.revision_id)

    if diff_type == 'partial' and files is not None:

        specific_files = files

    else:

        specific_files = None

    s = BytesIO()

    path_encoding = get_diff_header_encoding()

    diff.show_diff_trees(tree_1, tree_2, s, specific_files, old_label='',

                         new_label='', path_encoding=path_encoding)

    return s.getvalue()

class _StartNotLinearAncestor(Exception):

    """Raised when a start revision is not found walking left-hand history."""

class _DefaultLogGenerator(LogGenerator):

    """The default generator of log revisions."""

    def __init__(

            self, branch, levels=None, limit=None, diff_type=None,

            delta_type=None, show_signature=None, omit_merges=None,

            generate_tags=None, specific_files=None, match=None,

            start_revision=None, end_revision=None, direction=None,

            exclude_common_ancestry=None, _match_using_deltas=None,

            signature=None):

        self.branch = branch

        self.levels = levels

        self.limit = limit

        self.diff_type = diff_type

        self.delta_type = delta_type

        self.show_signature = signature

        self.omit_merges = omit_merges

        self.specific_files = specific_files

        self.match = match

        self.start_revision = start_revision

        self.end_revision = end_revision

        self.direction = direction

        self.exclude_common_ancestry = exclude_common_ancestry

        self._match_using_deltas = _match_using_deltas

        if generate_tags and branch.supports_tags():

            self.rev_tag_dict = branch.tags.get_reverse_tag_dict()

        else:

            self.rev_tag_dict = {}

    def iter_log_revisions(self):

        """Iterate over LogRevision objects.

        :return: An iterator yielding LogRevision objects.

        """

        log_count = 0

        revision_iterator = self._create_log_revision_iterator()

        for revs in revision_iterator:

            for (rev_id, revno, merge_depth), rev, delta in revs:

                # 0 levels means show everything; merge_depth counts from 0

                if (self.levels != 0 and merge_depth is not None and

                        merge_depth >= self.levels):

                    continue

                if self.omit_merges and len(rev.parent_ids) > 1:

                    continue

                if rev is None:

                    raise errors.GhostRevisionUnusableHere(rev_id)

                if self.diff_type is None:

                    diff = None

                else:

                    diff = _format_diff(

                        self.branch, rev, self.diff_type,

                        self.specific_files)

                if self.show_signature:

                    signature = format_signature_validity(rev_id, self.branch)

                else:

                    signature = None

                yield LogRevision(

                    rev, revno, merge_depth, delta,

                    self.rev_tag_dict.get(rev_id), diff, signature)

                if self.limit:

                    log_count += 1

                    if log_count >= self.limit:

                        return

    def _create_log_revision_iterator(self):

        """Create a revision iterator for log.

        :return: An iterator over lists of ((rev_id, revno, merge_depth), rev,

            delta).

        """

        start_rev_id, end_rev_id = _get_revision_limits(

            self.branch, self.start_revision, self.end_revision)

        if self._match_using_deltas:

            return _log_revision_iterator_using_delta_matching(

                self.branch,

                delta_type=self.delta_type,

                match=self.match,

                levels=self.levels,

                specific_files=self.specific_files,

                start_rev_id=start_rev_id, end_rev_id=end_rev_id,

                direction=self.direction,

                exclude_common_ancestry=self.exclude_common_ancestry,

                limit=self.limit)

        else:

            # We're using the per-file-graph algorithm. This scales really

            # well but only makes sense if there is a single file and it's

            # not a directory

            file_count = len(self.specific_files)

            if file_count != 1:

                raise errors.BzrError(

                    "illegal LogRequest: must match-using-deltas "

                    "when logging %d files" % file_count)

            return _log_revision_iterator_using_per_file_graph(

                self.branch,

                delta_type=self.delta_type,

                match=self.match,

                levels=self.levels,

                path=self.specific_files[0],

                start_rev_id=start_rev_id, end_rev_id=end_rev_id,

                direction=self.direction,

                exclude_common_ancestry=self.exclude_common_ancestry

                )

def _calc_view_revisions(branch, start_rev_id, end_rev_id, direction,

                         generate_merge_revisions,

                         delayed_graph_generation=False,

                         exclude_common_ancestry=False,

                         ):

    """Calculate the revisions to view.

    :return: An iterator of (revision_id, dotted_revno, merge_depth) tuples OR

             a list of the same tuples.

    """

    if (exclude_common_ancestry and start_rev_id == end_rev_id):

        raise errors.CommandError(gettext(

            '--exclude-common-ancestry requires two different revisions'))

    if direction not in ('reverse', 'forward'):

        raise ValueError(gettext('invalid direction %r') % direction)

    br_rev_id = branch.last_revision()

    if br_rev_id == _mod_revision.NULL_REVISION:

        return []

    if (end_rev_id and start_rev_id == end_rev_id

        and (not generate_merge_revisions

             or not _has_merges(branch, end_rev_id))):

        # If a single revision is requested, check we can handle it

        return _generate_one_revision(branch, end_rev_id, br_rev_id,

                                      branch.revno())

    if not generate_merge_revisions:

        try:

            # If we only want to see linear revisions, we can iterate ...

            iter_revs = _linear_view_revisions(

                branch, start_rev_id, end_rev_id,

                exclude_common_ancestry=exclude_common_ancestry)

            # If a start limit was given and it's not obviously an

            # ancestor of the end limit, check it before outputting anything

            if (direction == 'forward'

                or (start_rev_id and not _is_obvious_ancestor(

                    branch, start_rev_id, end_rev_id))):

                iter_revs = list(iter_revs)

            if direction == 'forward':

                iter_revs = reversed(iter_revs)

            return iter_revs

        except _StartNotLinearAncestor:

            # Switch to the slower implementation that may be able to find a

            # non-obvious ancestor out of the left-hand history.

            pass

    iter_revs = _generate_all_revisions(branch, start_rev_id, end_rev_id,

                                        direction, delayed_graph_generation,

                                        exclude_common_ancestry)

    if direction == 'forward':

        iter_revs = _rebase_merge_depth(reverse_by_depth(list(iter_revs)))

    return iter_revs

def _generate_one_revision(branch, rev_id, br_rev_id, br_revno):

    if rev_id == br_rev_id:

        # It's the tip

        return [(br_rev_id, br_revno, 0)]

    else:

        revno_str = _compute_revno_str(branch, rev_id)

        return [(rev_id, revno_str, 0)]

def _generate_all_revisions(branch, start_rev_id, end_rev_id, direction,

                            delayed_graph_generation,

                            exclude_common_ancestry=False):

    # On large trees, generating the merge graph can take 30-60 seconds

    # so we delay doing it until a merge is detected, incrementally

    # returning initial (non-merge) revisions while we can.

    # The above is only true for old formats (<= 0.92), for newer formats, a

    # couple of seconds only should be needed to load the whole graph and the

    # other graph operations needed are even faster than that -- vila 100201

    initial_revisions = []

    if delayed_graph_generation:

        try:

            for rev_id, revno, depth in _linear_view_revisions(

                    branch, start_rev_id, end_rev_id, exclude_common_ancestry):

                if _has_merges(branch, rev_id):

                    # The end_rev_id can be nested down somewhere. We need an

                    # explicit ancestry check. There is an ambiguity here as we

                    # may not raise _StartNotLinearAncestor for a revision that

                    # is an ancestor but not a *linear* one. But since we have

                    # loaded the graph to do the check (or calculate a dotted

                    # revno), we may as well accept to show the log...  We need

                    # the check only if start_rev_id is not None as all

                    # revisions have _mod_revision.NULL_REVISION as an ancestor

                    # -- vila 20100319

                    graph = branch.repository.get_graph()

                    if (start_rev_id is not None

                            and not graph.is_ancestor(start_rev_id, end_rev_id)):

                        raise _StartNotLinearAncestor()

                    # Since we collected the revisions so far, we need to

                    # adjust end_rev_id.

                    end_rev_id = rev_id

                    break

                else:

                    initial_revisions.append((rev_id, revno, depth))

            else:

                # No merged revisions found

                return initial_revisions

        except _StartNotLinearAncestor: