~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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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 (

    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,

    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.

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

    """

    branch.lock_read()

    try:

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

            lf.begin_log()

        _show_log(branch, lf, specific_fileid, verbose, direction,

                  start_revision, end_revision, search, limit, show_diff)

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

            lf.end_log()

    finally:

        branch.unlock()

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

    """Worker function for show_log - see show_log."""

    if not isinstance(lf, LogFormatter):

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

    if specific_fileid:

        trace.mutter('get log for file_id %r', specific_fileid)

    # Consult the LogFormatter about what it needs and can handle

    levels_to_display = lf.get_levels()

    generate_merge_revisions = levels_to_display != 1

    allow_single_merge_revision = True

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

        allow_single_merge_revision = getattr(lf,

            'supports_single_merge_revision', False)

    generate_tags = getattr(lf, 'supports_tags', False)

    if generate_tags and branch.supports_tags():

        rev_tag_dict = branch.tags.get_reverse_tag_dict()

    else:

        rev_tag_dict = {}

    generate_delta = verbose and getattr(lf, 'supports_delta', False)

    generate_diff = show_diff and getattr(lf, 'supports_diff', False)

    # Find and print the interesting revisions

    repo = branch.repository

    log_count = 0

    revision_iterator = _create_log_revision_iterator(branch,

        start_revision, end_revision, direction, specific_fileid, search,

        generate_merge_revisions, allow_single_merge_revision,

        generate_delta, limited_output=limit > 0)

    for revs in revision_iterator:

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

            # Note: 0 levels means show everything; merge_depth counts from 0

            if levels_to_display != 0 and merge_depth >= levels_to_display:

                continue

            if generate_diff:

                diff = _format_diff(repo, rev, rev_id, specific_fileid)

            else:

                diff = None

            lr = LogRevision(rev, revno, merge_depth, delta,

                             rev_tag_dict.get(rev_id), diff)

            lf.log_revision(lr)

            if limit:

                log_count += 1

                if log_count >= limit:

                    return

def _format_diff(repo, rev, rev_id, specific_fileid):

    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)

    if specific_fileid:

        specific_files = [tree_2.id2path(specific_fileid)]

    else:

        specific_files = None

    s = StringIO()

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

        new_label='')

    return s.getvalue()

class _StartNotLinearAncestor(Exception):

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

def _create_log_revision_iterator(branch, start_revision, end_revision,

    direction, specific_fileid, search, generate_merge_revisions,

    allow_single_merge_revision, generate_delta, limited_output=False):

    """Create a revision iterator for log.

    :param branch: The branch being logged.

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

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

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

        earliest to latest.

    :param specific_fileid: If not None, list only the commits affecting the

        specified file.

    :param search: If not None, only show revisions with matching commit

        messages.

    :param generate_merge_revisions: If False, show only mainline revisions.

    :param allow_single_merge_revision: If True, logging of a single

        revision off the mainline is to be allowed

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

    :param limited_output: if True, the user only wants a limited result

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

        delta).

    """

    start_rev_id, end_rev_id = _get_revision_limits(branch, start_revision,

        end_revision)

    # Decide how file-ids are matched: delta-filtering vs per-file graph.

    # Delta filtering allows revisions to be displayed incrementally

    # though the total time is much slower for huge repositories: log -v

    # is the *lower* performance bound. At least until the split

    # inventory format arrives, per-file-graph needs to remain the

    # default except in verbose mode. Delta filtering should give more

    # accurate results (e.g. inclusion of FILE deletions) so arguably

    # it should always be used in the future.

    use_deltas_for_matching = specific_fileid and generate_delta

    delayed_graph_generation = not specific_fileid and (

            start_rev_id or end_rev_id or limited_output)

    generate_merges = generate_merge_revisions or (specific_fileid and

        not use_deltas_for_matching)

    view_revisions = _calc_view_revisions(branch, start_rev_id, end_rev_id,

        direction, generate_merges, allow_single_merge_revision,

        delayed_graph_generation=delayed_graph_generation)

    search_deltas_for_fileids = None

    if use_deltas_for_matching:

        search_deltas_for_fileids = set([specific_fileid])

    elif specific_fileid:

        if not isinstance(view_revisions, list):

            view_revisions = list(view_revisions)

        view_revisions = _filter_revisions_touching_file_id(branch,

            specific_fileid, view_revisions,

            include_merges=generate_merge_revisions)

    return make_log_rev_iterator(branch, view_revisions, generate_delta,

        search, file_ids=search_deltas_for_fileids, direction=direction)

def _calc_view_revisions(branch, start_rev_id, end_rev_id, direction,

    generate_merge_revisions, allow_single_merge_revision,

    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:

        if end_rev_id == br_rev_id:

            # It's the tip

            return [(br_rev_id, br_revno, 0)]

        else:

            revno = branch.revision_id_to_dotted_revno(end_rev_id)

            if len(revno) > 1 and not allow_single_merge_revision:

                # It's a merge revision and the log formatter is

                # completely brain dead. This "feature" of allowing

                # log formatters incapable of displaying dotted revnos

                # ought to be deprecated IMNSHO. IGC 20091022

                raise errors.BzrCommandError('Selected log formatter only'

                    ' supports mainline revisions.')

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

            return [(end_rev_id, revno_str, 0)]

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

    if not generate_merge_revisions:

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

        return result

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

    """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,

        allow_single_merge_revision))

    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.

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

    """Create a filtered iterator of log_rev_iterator matching on a regex.

    :param branch: The branch being logged.

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

    :param search: A user text search string.

    :param log_rev_iterator: An input iterator containing all revisions that

        could be displayed, in lists.

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

        delta).

    """

    if search is None:

        return log_rev_iterator

    # Compile the search now to get early errors.

    searchRE = re.compile(search, re.IGNORECASE)

    return _filter_message_re(searchRE, log_rev_iterator)

def _filter_message_re(searchRE, log_rev_iterator):

    for revs in log_rev_iterator:

        new_revs = []

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

            if searchRE.search(rev.message):

                new_revs.append(((rev_id, revno, merge_depth), rev, delta))

        yield new_revs

def _make_delta_filter(branch, generate_delta, search, log_rev_iterator,

    fileids=None, direction='reverse'):

    """Add revision deltas to a log iterator if needed.

    :param branch: The branch being logged.

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

    :param search: A user text search string.

    :param log_rev_iterator: An input iterator containing all revisions that

        could be displayed, in lists.

    :param fileids: 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).

    """

    if not generate_delta and not fileids:

        return log_rev_iterator

    return _generate_deltas(branch.repository, log_rev_iterator,

        generate_delta, fileids, direction)

def _generate_deltas(repository, log_rev_iterator, always_delta, fileids,

    direction):

    """Create deltas for each batch of revisions in log_rev_iterator.

    If we're only generating deltas for the sake of filtering against

    file-ids, we stop generating deltas once all file-ids reach the

    appropriate life-cycle point. If we're receiving data newest to

    oldest, then that life-cycle point is 'add', otherwise it's 'remove'.

    """

    check_fileids = fileids is not None and len(fileids) > 0

    if check_fileids:

        fileid_set = set(fileids)

        if direction == 'reverse':

            stop_on = 'add'

        else:

            stop_on = 'remove'

    else:

        fileid_set = None

    for revs in log_rev_iterator:

        # If we were matching against fileids and we've run out,

        # there's nothing left to do

        if check_fileids and not fileid_set:

            return

        revisions = [rev[1] for rev in revs]

        deltas = repository.get_deltas_for_revisions(revisions)

        new_revs = []

        for rev, delta in izip(revs, deltas):

            if check_fileids:

                if not _delta_matches_fileids(delta, fileid_set, stop_on):

                    continue

                elif not always_delta:

                    # Delta was created just for matching - ditch it

                    # Note: It would probably be a better UI to return

                    # a delta filtered by the file-ids, rather than

                    # None at all. That functional enhancement can

                    # come later ...

                    delta = None

            new_revs.append((rev[0], rev[1], delta))

        yield new_revs

def _delta_matches_fileids(delta, fileids, stop_on='add'):

    """Check is a delta matches one of more file-ids.

    :param fileids: a set of fileids to match against.

    :param stop_on: either 'add' or 'remove' - take file-ids out of the

      fileids set once their add or remove entry is detected respectively

    """

    if not fileids:

        return False

    result = False

    for item in delta.added:

        if item[1] in fileids:

            if stop_on == 'add':

                fileids.remove(item[1])

            result = True

    for item in delta.removed:

        if item[1] in fileids:

            if stop_on == 'delete':

                fileids.remove(item[1])

            result = True

    if result:

        return True

    for l in (delta.modified, delta.renamed, delta.kind_changed):

        for item in l:

            if item[1] in fileids:

                return True

    return False

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

    """Extract revision objects from the repository

    :param branch: The branch being logged.

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

    :param search: A user text search string.

    :param log_rev_iterator: An input iterator containing all revisions that

        could be displayed, in lists.

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

        delta).

    """

    repository = branch.repository