/brz/remove-bazaar

# 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

class LogRequest(object):

    """Query parameters for logging a branch."""

    def __init__(self,

        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,

        ):

        """Create a logging request.

        Each of these parameter become a public attribute of the object.

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

        """

        self.direction = direction

        self.specific_fileids = specific_fileids

        self.start_revision = start_revision

        self.end_revision = end_revision

        self.limit = limit

        self.message_search = message_search

        self.levels = levels

        self.generate_tags = generate_tags

        self.delta_type = delta_type

        self.diff_type = diff_type

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

        self._match_using_deltas = _match_using_deltas

        self._allow_single_merge_revision = True

def show_log_request(branch, lf, rqst):

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

    :param lf: The LogFormatter object showing the output.

    :param rqst: The LogRequest object specifying the query parameters.

    """

    branch.lock_read()

    try:

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

            lf.begin_log()

        _show_log_request(branch, lf, rqst)

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

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

    Note: show_log_request() is now the preferred API to this one.

    This function is being retained for backwards compatibility but

    should not be extended with new parameters.

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

    show_log_request(branch, lf, rqst)

def _show_log_request(branch, lf, rqst):

    """Worker function for show_log_request - see show_log_request."""

    if not isinstance(lf, LogFormatter):

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

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

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

    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_merge_revisions', False):

        rqst._allow_single_merge_revision = getattr(lf,

            'supports_single_merge_revision', False)

    # Find and print the interesting revisions

    generator = _LogGenerator(branch, rqst)

    for lr in generator.iter_log_revisions():

        lf.log_revision(lr)

class _StartNotLinearAncestor(Exception):

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

class _LogGenerator(object):

    """A generator of log revisions given a branch and a LogRequest."""

    def __init__(self, branch, rqst):

        self.branch = branch

        self.rqst = rqst

        if rqst.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

                if rqst.levels != 0 and merge_depth >= rqst.levels:

                    continue

                diff = self._format_diff(rev, rev_id)

                yield LogRevision(rev, revno, merge_depth, delta,

                    self.rev_tag_dict.get(rev_id), diff)

                if rqst.limit:

                    log_count += 1

                    if log_count >= rqst.limit:

                        return

    def _format_diff(self, rev, rev_id):

        diff_type = self.rqst.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.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.start_revision, self.rqst.end_revision)

        if self.rqst._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.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.levels != 1

        delayed_graph_generation = not rqst.specific_fileids and (

                rqst.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.direction, generate_merge_revisions,

            rqst._allow_single_merge_revision,

            delayed_graph_generation=delayed_graph_generation)

        # Apply the other filters

        return make_log_rev_iterator(self.branch, view_revisions,

            rqst.delta_type, rqst.message_search,

            file_ids=rqst.specific_fileids, direction=rqst.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.direction, True,

            rqst._allow_single_merge_revision)

        if not isinstance(view_revisions, list):

            view_revisions = list(view_revisions)

        view_revisions = _filter_revisions_touching_file_id(self.branch,

            rqst.specific_fileids[0], view_revisions,

            include_merges=rqst.levels != 1)

        return make_log_rev_iterator(self.branch, view_revisions,

            rqst.delta_type, rqst.message_search)

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:

        return _generate_one_revision(branch, end_rev_id, br_rev_id, br_revno,

            allow_single_merge_revision)

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

    allow_single_merge_revision):

    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)

        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 [(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, 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.

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

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

    searchRE = re_compile_checked(search, re.IGNORECASE,

            'log message filter')

    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.

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

    :param search: A user text search string.

    :param log_rev_iterator: An input iterator containing all revisions that