~bzr-pqm/bzr/bzr.dev

# Copyright (C) 2005, 2006, 2007, 2009 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 file-ids 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 cStringIO import StringIO

from itertools import (

    chain,

    izip,

    )

import re

import sys

from warnings import (

    warn,

    )

from bzrlib.lazy_import import lazy_import

lazy_import(globals(), """

from bzrlib import (

    bzrdir,

    config,

    diff,

    errors,

    repository as _mod_repository,

    revision as _mod_revision,

    revisionspec,

    trace,

    tsort,

    )

""")

from bzrlib import (

    registry,

    )

from bzrlib.osutils import (

    format_date,

    get_terminal_encoding,

    re_compile_checked,

    terminal_width,

    )

def find_touching_revisions(branch, file_id):

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

    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_ie = None

    last_path = None

    revno = 1

    for revision_id in branch.revision_history():

        this_inv = branch.repository.get_revision_inventory(revision_id)

        if file_id in this_inv:

            this_ie = this_inv[file_id]

            this_path = this_inv.id2path(file_id)

        else:

            this_ie = this_path = None

        # 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 not this_ie and not last_ie:

            # not present in either

            pass

        elif this_ie and not last_ie:

            yield revno, revision_id, "added " + this_path

        elif not this_ie and last_ie:

            # deleted here

            yield revno, revision_id, "deleted " + last_path

        elif this_path != last_path:

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

        elif (this_ie.text_size != last_ie.text_size

              or this_ie.text_sha1 != last_ie.text_sha1):

            yield revno, revision_id, "modified " + this_path

        last_ie = this_ie

        last_path = this_path

        revno += 1

def _enumerate_history(branch):

    rh = []

    revno = 1

    for rev_id in branch.revision_history():

        rh.append((revno, rev_id))

        revno += 1

    return rh

def show_log(branch,

             lf,

             specific_fileid=None,

             verbose=False,

             direction='reverse',

             start_revision=None,

             end_revision=None,

             search=None,

             limit=None,

             show_diff=False):

    """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 specific_fileid: If not None, list only the commits affecting the

        specified file, rather than all commits.

    :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 search: If not None, only show revisions with matching commit

        messages

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

    """

    # Convert old-style parameters to new-style parameters

    if specific_fileid is not None:

        file_ids = [specific_fileid]

    else:

        file_ids = None

    if verbose:

        if file_ids:

            delta_type = 'partial'

        else:

            delta_type = 'full'

    else:

        delta_type = None

    if show_diff:

        if file_ids:

            diff_type = 'partial'

        else:

            diff_type = 'full'

    else:

        diff_type = None

    # Build the request and execute it

    rqst = make_log_request_dict(direction=direction, specific_fileids=file_ids,

        start_revision=start_revision, end_revision=end_revision,

        limit=limit, message_search=search,

        delta_type=delta_type, diff_type=diff_type)

    Logger(branch, rqst).show(lf)

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

# make_log_request_dict() below

_DEFAULT_REQUEST_PARAMS = {

    'direction': 'reverse',

    'levels': 1,

    'generate_tags': True,

    '_match_using_deltas': True,

    }

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

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

    message_search=None, levels=1, generate_tags=True, delta_type=None,

    diff_type=None, _match_using_deltas=True):

    """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_fileids: 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.

    :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_fileids;

      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_fileids;

      None means do not generate any diff.

    :param _match_using_deltas: a private parameter controlling the

      algorithm used for matching specific_fileids. This parameter

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

      use it.

    """

    return {

        'direction': direction,

        'specific_fileids': specific_fileids,

        'start_revision': start_revision,

        'end_revision': end_revision,

        'limit': limit,

        'message_search': message_search,

        'levels': levels,

        'generate_tags': generate_tags,

        'delta_type': delta_type,

        'diff_type': diff_type,

        # 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

    if rqst:

        result.update(rqst)

    return result

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

        self.branch.lock_read()

        try:

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

                lf.begin_log()

            self._show_body(lf)

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

                lf.end_log()

        finally:

            self.branch.unlock()

    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

        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

        # Find and print the interesting revisions

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

        for lr in generator.iter_log_revisions():

            lf.log_revision(lr)

        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)

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

        self.branch = branch

        self.rqst = rqst

        if rqst.get('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.

        """

        rqst = self.rqst

        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

                levels = rqst.get('levels')

                if levels != 0 and merge_depth >= levels:

                    continue

                diff = self._format_diff(rev, rev_id)

                yield LogRevision(rev, revno, merge_depth, delta,

                    self.rev_tag_dict.get(rev_id), diff)

                limit = rqst.get('limit')

                if limit:

                    log_count += 1

                    if log_count >= limit:

                        return

    def _format_diff(self, rev, rev_id):

        diff_type = self.rqst.get('diff_type')

        if diff_type is None:

            return None

        repo = self.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_id)

        file_ids = self.rqst.get('specific_fileids')

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

            specific_files = [tree_2.id2path(id) for id in file_ids]

        else:

            specific_files = None

        s = StringIO()

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

            new_label='')

        return s.getvalue()

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

        """

        self.start_rev_id, self.end_rev_id = _get_revision_limits(

            self.branch, self.rqst.get('start_revision'),

            self.rqst.get('end_revision'))

        if self.rqst.get('_match_using_deltas'):

            return self._log_revision_iterator_using_delta_matching()

        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.rqst.get('specific_fileids'))

            if file_count != 1:

                raise BzrError("illegal LogRequest: must match-using-deltas "

                    "when logging %d files" % file_count)

            return self._log_revision_iterator_using_per_file_graph()

    def _log_revision_iterator_using_delta_matching(self):

        # Get the base revisions, filtering by the revision range

        rqst = self.rqst

        generate_merge_revisions = rqst.get('levels') != 1

        delayed_graph_generation = not rqst.get('specific_fileids') and (

                rqst.get('limit') or self.start_rev_id or self.end_rev_id)

        view_revisions = _calc_view_revisions(self.branch, self.start_rev_id,

            self.end_rev_id, rqst.get('direction'), generate_merge_revisions,

            delayed_graph_generation=delayed_graph_generation)

        # Apply the other filters

        return make_log_rev_iterator(self.branch, view_revisions,

            rqst.get('delta_type'), rqst.get('message_search'),

            file_ids=rqst.get('specific_fileids'),

            direction=rqst.get('direction'))

    def _log_revision_iterator_using_per_file_graph(self):

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

        # Note that we always generate the merge revisions because

        # filter_revisions_touching_file_id() requires them ...

        rqst = self.rqst

        view_revisions = _calc_view_revisions(self.branch, self.start_rev_id,

            self.end_rev_id, rqst.get('direction'), True)

        if not isinstance(view_revisions, list):

            view_revisions = list(view_revisions)

        view_revisions = _filter_revisions_touching_file_id(self.branch,

            rqst.get('specific_fileids')[0], view_revisions,

            include_merges=rqst.get('levels') != 1)

        return make_log_rev_iterator(self.branch, view_revisions,

            rqst.get('delta_type'), rqst.get('message_search'))

def _calc_view_revisions(branch, start_rev_id, end_rev_id, direction,

    generate_merge_revisions, delayed_graph_generation=False):

    """Calculate the revisions to view.

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

             a list of the same tuples.

    """

    br_revno, br_rev_id = branch.last_revision_info()

    if br_revno == 0:

        return []

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

    generate_single_revision = (end_rev_id and start_rev_id == end_rev_id and

        (not generate_merge_revisions or not _has_merges(branch, end_rev_id)))

    if generate_single_revision:

        return _generate_one_revision(branch, end_rev_id, br_rev_id, br_revno)

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

    if not generate_merge_revisions:

        return _generate_flat_revisions(branch, start_rev_id, end_rev_id,

            direction)

    else:

        return _generate_all_revisions(branch, start_rev_id, end_rev_id,

            direction, delayed_graph_generation)

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 = branch.revision_id_to_dotted_revno(rev_id)

        revno_str = '.'.join(str(n) for n in revno)

        return [(rev_id, revno_str, 0)]

def _generate_flat_revisions(branch, start_rev_id, end_rev_id, direction):

    result = _linear_view_revisions(branch, start_rev_id, end_rev_id)

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

        try:

            result = list(result)

        except _StartNotLinearAncestor:

            raise errors.BzrCommandError('Start revision not found in'

                ' left-hand history of end revision.')

    if direction == 'forward':

        result = reversed(result)

    return result

def _generate_all_revisions(branch, start_rev_id, end_rev_id, direction,

    delayed_graph_generation):

    # 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.

    initial_revisions = []

    if delayed_graph_generation:

        try:

            for rev_id, revno, depth in \

                _linear_view_revisions(branch, start_rev_id, end_rev_id):

                if _has_merges(branch, rev_id):

                    end_rev_id = rev_id

                    break

                else:

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

            else:

                # No merged revisions found

                if direction == 'reverse':

                    return initial_revisions

                elif direction == 'forward':

                    return reversed(initial_revisions)

                else:

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

        except _StartNotLinearAncestor:

            # A merge was never detected so the lower revision limit can't

            # be nested down somewhere

            raise errors.BzrCommandError('Start revision not found in'

                ' history of end revision.')

    # A log including nested merges is required. If the direction is reverse,

    # we rebase the initial merge depths so that the development line is

    # shown naturally, i.e. just like it is for linear logging. We can easily

    # make forward the exact opposite display, but showing the merge revisions

    # indented at the end seems slightly nicer in that case.

    view_revisions = chain(iter(initial_revisions),

        _graph_view_revisions(branch, start_rev_id, end_rev_id,

        rebase_initial_depths=direction == 'reverse'))

    if direction == 'reverse':

        return view_revisions

    elif direction == 'forward':

        # Forward means oldest first, adjusting for depth.

        view_revisions = reverse_by_depth(list(view_revisions))

        return _rebase_merge_depth(view_revisions)

    else:

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

def _has_merges(branch, rev_id):

    """Does a revision have multiple parents or not?"""

    parents = branch.repository.get_parent_map([rev_id]).get(rev_id, [])

    return len(parents) > 1

def _is_obvious_ancestor(branch, start_rev_id, end_rev_id):

    """Is start_rev_id an obvious ancestor of end_rev_id?"""

    if start_rev_id and end_rev_id:

        start_dotted = branch.revision_id_to_dotted_revno(start_rev_id)

        end_dotted = branch.revision_id_to_dotted_revno(end_rev_id)

        if len(start_dotted) == 1 and len(end_dotted) == 1:

            # both on mainline

            return start_dotted[0] <= end_dotted[0]

        elif (len(start_dotted) == 3 and len(end_dotted) == 3 and

            start_dotted[0:1] == end_dotted[0:1]):

            # both on same development line

            return start_dotted[2] <= end_dotted[2]

        else:

            # not obvious

            return False

    return True

def _linear_view_revisions(branch, start_rev_id, end_rev_id):

    """Calculate a sequence of revisions to view, newest to oldest.

    :param start_rev_id: the lower revision-id

    :param end_rev_id: the upper revision-id

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

    :raises _StartNotLinearAncestor: if a start_rev_id is specified but

      is not found walking the left-hand history

    """

    br_revno, br_rev_id = branch.last_revision_info()

    repo = branch.repository

    if start_rev_id is None and end_rev_id is None:

        cur_revno = br_revno

        for revision_id in repo.iter_reverse_revision_history(br_rev_id):

            yield revision_id, str(cur_revno), 0

            cur_revno -= 1

    else:

        if end_rev_id is None:

            end_rev_id = br_rev_id

        found_start = start_rev_id is None

        for revision_id in repo.iter_reverse_revision_history(end_rev_id):

            revno = branch.revision_id_to_dotted_revno(revision_id)

            revno_str = '.'.join(str(n) for n in revno)

            if not found_start and revision_id == start_rev_id:

                yield revision_id, revno_str, 0

                found_start = True

                break

            else:

                yield revision_id, revno_str, 0

        else:

            if not found_start:

                raise _StartNotLinearAncestor()

def _graph_view_revisions(branch, start_rev_id, end_rev_id,

    rebase_initial_depths=True):

    """Calculate revisions to view including merges, newest to oldest.

    :param branch: the branch

    :param start_rev_id: the lower revision-id

    :param end_rev_id: the upper revision-id

    :param rebase_initial_depth: should depths be rebased until a mainline

      revision is found?

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

    """

    view_revisions = branch.iter_merge_sorted_revisions(

        start_revision_id=end_rev_id, stop_revision_id=start_rev_id,

        stop_rule="with-merges")

    if not rebase_initial_depths:

        for (rev_id, merge_depth, revno, end_of_merge

             ) in view_revisions:

            yield rev_id, '.'.join(map(str, revno)), merge_depth

    else:

        # We're following a development line starting at a merged revision.

        # We need to adjust depths down by the initial depth until we find

        # a depth less than it. Then we use that depth as the adjustment.

        # If and when we reach the mainline, depth adjustment ends.

        depth_adjustment = None

        for (rev_id, merge_depth, revno, end_of_merge

             ) in view_revisions:

            if depth_adjustment is None:

                depth_adjustment = merge_depth

            if depth_adjustment:

                if merge_depth < depth_adjustment:

                    depth_adjustment = merge_depth

                merge_depth -= depth_adjustment

            yield rev_id, '.'.join(map(str, revno)), merge_depth

def calculate_view_revisions(branch, start_revision, end_revision, direction,

        specific_fileid, generate_merge_revisions):

    """Calculate the revisions to view.

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

             a list of the same tuples.

    """

    # This method is no longer called by the main code path.

    # It is retained for API compatibility and may be deprecated

    # soon. IGC 20090116

    start_rev_id, end_rev_id = _get_revision_limits(branch, start_revision,

        end_revision)

    view_revisions = list(_calc_view_revisions(branch, start_rev_id, end_rev_id,

        direction, generate_merge_revisions or specific_fileid))

    if specific_fileid:

        view_revisions = _filter_revisions_touching_file_id(branch,

            specific_fileid, view_revisions,

            include_merges=generate_merge_revisions)

    return _rebase_merge_depth(view_revisions)

def _rebase_merge_depth(view_revisions):

    """Adjust depths upwards so the top level is 0."""

    # If either the first or last revision have a merge_depth of 0, we're done

    if view_revisions and view_revisions[0][2] and view_revisions[-1][2]:

        min_depth = min([d for r,n,d in view_revisions])

        if min_depth != 0:

            view_revisions = [(r,n,d-min_depth) for r,n,d in view_revisions]

    return view_revisions

def make_log_rev_iterator(branch, view_revisions, generate_delta, search,

        file_ids=None, direction='reverse'):

    """Create a revision iterator for log.

    :param branch: The branch being logged.

    :param view_revisions: The revisions being viewed.

    :param generate_delta: Whether to generate a delta for each revision.

      Permitted values are None, 'full' and 'partial'.

    :param search: A user text search string.

    :param file_ids: If non empty, only revisions matching one or more of

      the file-ids are to be kept.

    :param direction: the direction in which view_revisions is sorted

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

        delta).

    """

    # Convert view_revisions into (view, None, None) groups to fit with

    # the standard interface here.

    if type(view_revisions) == list:

        # A single batch conversion is faster than many incremental ones.

        # As we have all the data, do a batch conversion.

        nones = [None] * len(view_revisions)

        log_rev_iterator = iter([zip(view_revisions, nones, nones)])

    else:

        def _convert():

            for view in view_revisions:

                yield (view, None, None)

        log_rev_iterator = iter([_convert()])

    for adapter in log_adapters:

        # It would be nicer if log adapters were first class objects

        # with custom parameters. This will do for now. IGC 20090127

        if adapter == _make_delta_filter:

            log_rev_iterator = adapter(branch, generate_delta,

                search, log_rev_iterator, file_ids, direction)

        else:

            log_rev_iterator = adapter(branch, generate_delta,

                search, log_rev_iterator)

    return log_rev_iterator

def _make_search_filter(branch, generate_delta, search, log_rev_iterator):