/brz/remove-bazaar

# Copyright (C) 2005, 2006, 2007 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 itertools import (

    izip,

    )

import re

import sys

from warnings import (

    warn,

    )

from bzrlib.lazy_import import lazy_import

lazy_import(globals(), """

from bzrlib import (

    config,

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

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

    """

    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)

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

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

    generate_merge_revisions = getattr(lf, 'supports_merge_revisions', False)

    allow_single_merge_revision = getattr(lf,

        'supports_single_merge_revision', generate_merge_revisions)

    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)

    # Find and print the interesting revisions

    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)

    for revs in revision_iterator:

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

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

                             rev_tag_dict.get(rev_id))

            lf.log_revision(lr)

            if limit:

                log_count += 1

                if log_count >= limit:

                    return

def _create_log_revision_iterator(branch, start_revision, end_revision,

    direction, specific_fileid, search, generate_merge_revisions,

    allow_single_merge_revision, generate_delta,

    force_incremental_matching=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 force_incremental_matching: if there's a file_id, use deltas

        to match it unconditionally

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

        delta).

    """

    rev_limits = _get_revision_limits(branch, start_revision, end_revision)

    _, _, _, start_rev_id, _, end_rev_id = rev_limits

    # 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 when no limits are given. 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 (force_incremental_matching

        or generate_delta or start_rev_id or end_rev_id)

    if use_deltas_for_matching:

        view_revisions = _calc_view_revisions(branch, rev_limits,

            direction, generate_merge_revisions, allow_single_merge_revision)

        def only_the_file(path, file_id):

            return file_id == specific_fileid

        return make_log_rev_iterator(branch, view_revisions, generate_delta,

            search, delta_entry_filter=only_the_file)

    else:

        view_revisions = _calc_view_revisions(branch, rev_limits,

            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 make_log_rev_iterator(branch, view_revisions, generate_delta,

            search)

class _StartNotLinearAncestor(Exception):

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

def _calc_view_revisions(branch, rev_limits, direction,

        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.

    """

    br_revno, br_rev_id, start_revno, start_rev_id, end_revno, end_rev_id = \

        rev_limits

    if br_revno == 0:

        return []

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

    generate_single_revision = (start_rev_id and start_rev_id == end_rev_id)

    if generate_single_revision:

        if start_rev_id == br_rev_id:

            # It's the tip

            if (not generate_merge_revisions or

                not _has_merges(branch, br_rev_id)):

                return [(br_rev_id, br_revno, 0)]

            else:

                # We need the merge revisions as well

                generate_single_revision = False

        elif (not generate_merge_revisions or

            not _has_merges(branch, start_rev_id)):

            try:

                revno = branch.revision_id_to_revno(start_rev_id)

                # We found it on the mainline

                return [(start_rev_id, revno, 0)]

            except errors.NoSuchRevision:

                if allow_single_merge_revision:

                    # It's a merge revision and the log formatter isn't

                    # completely brain dead.

                    revnos = branch.get_revision_id_to_revno_map()

                    revno = revnos.get(start_rev_id)

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

                    return [(start_rev_id, revno_str, 0)]

                else:

                    raise errors.BzrCommandError('Selected log formatter only'

                        ' supports mainline revisions.')

        else:

            generate_single_revision = False

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

    if not generate_merge_revisions:

        result = _linear_view_revisions(branch, rev_limits)

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

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

        if start_rev_id and not (_on_mainline(branch, start_rev_id) and

            _on_mainline(branch, 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

    # If we're only looking at a limited linear range, we can skip

    # generating merge revisions if there aren't any merges

    if start_rev_id:

        result = []

        try:

            for rev_id, revno, depth in \

                _linear_view_revisions(branch, rev_limits):

                if _has_merges(branch, rev_id):

                    break

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

            else:

                # Success!

                if direction == 'forward':

                    result = reversed(result)

                return result

        except _StartNotLinearAncestor:

            # Abort - we need the smart filtering below

            pass

    # Otherwise, the algorithm is O(history) for now ...

    # Do the filtering

    mainline_revs, rev_nos = _get_mainline_revs(branch, rev_limits)

    view_revs_iter = get_view_revisions(mainline_revs, rev_nos, branch,

                          direction, include_merges=generate_merge_revisions)

    if direction == 'reverse':

        start_rev_id, end_rev_id = end_rev_id, start_rev_id

    view_revisions = _filter_revision_range(list(view_revs_iter),

                                            start_rev_id,

                                            end_rev_id)

    # Rebase merge_depth - unless there are no revisions or 

    # either the first or last revision have merge_depth = 0.

    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 _has_merges(branch, rev_id):

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

    return len(branch.repository.get_revision(rev_id).parent_ids) > 1

def _on_mainline(branch, rev_id):

    """Is rev_id on the mainline of a branch?"""

    if rev_id:

        try:

            branch.revision_id_to_revno(rev_id)

        except errors.NoSuchRevision:

            return False

    return True

def _linear_view_revisions(branch, revision_limits):

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

    :param revision_limits: a tuple as returned by _get_revision_limits()

    :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, start_revno, start_rev_id, end_revno, end_rev_id = \

        revision_limits

    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

        # If we're starting on the mainline, we can calculate revnos.

        # Otherwise, we need to look them up.

        try:

            cur_revno = branch.revision_id_to_revno(end_rev_id)

            lookup_revnos = False

        except errors.NoSuchRevision:

            lookup_revnos = True

        if lookup_revnos:

            revno_map = branch.get_revision_id_to_revno_map()

        found_start = start_rev_id is None

        for revision_id in repo.iter_reverse_revision_history(end_rev_id):

            if lookup_revnos:

                revno_str = revno_map.get(revision_id)

            else:

                revno_str = str(cur_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

                cur_revno -= 1

        else:

            if not found_start:

                raise _StartNotLinearAncestor()

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

    rev_limits = _get_revision_limits(branch, start_revision, end_revision)

    view_revisions = _calc_view_revisions(branch, rev_limits,

        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 view_revisions

def make_log_rev_iterator(branch, view_revisions, generate_delta, search,

        delta_entry_filter=None):

    """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 delta_entry_filter: If set, a delta is always generated and

      one of its entries must pass this filter for a revision to be kept.

      The generated delta is only retained if generate_delta is True.

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

        log_rev_iterator = adapter(branch, generate_delta or

            delta_entry_filter, search, log_rev_iterator)

    if delta_entry_filter:

        log_rev_iterator = _filter_delta_items(log_rev_iterator,

            delta_entry_filter, generate_delta)

    return log_rev_iterator

def _filter_delta_items(log_rev_iterator, filter, retain_delta):

    for revs in log_rev_iterator:

        new_revs = []

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

            if _delta_matches_filter(delta, filter):

                if not retain_delta:

                    delta = None

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

        yield new_revs

def _delta_matches_filter(delta, filter):

    """Check is a delta matches a filter."""

    for l in (delta.modified, delta.added, delta.removed, delta.kind_changed):

        for item in l:

            if filter(item[0], item[1]):

                return True

    for item in delta.renamed:

        if filter(item[0], item[2]) or filter(item[1], item[2]):

            return True

    return False

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

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

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

        delta).

    """

    if not generate_delta:

        return log_rev_iterator

    return _generate_deltas(branch.repository, log_rev_iterator)

def _generate_deltas(repository, log_rev_iterator):

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

    for revs in log_rev_iterator:

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

        deltas = repository.get_deltas_for_revisions(revisions)

        revs = [(rev[0], rev[1], delta) for rev, delta in izip(revs, deltas)]

        yield revs

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

    for revs in log_rev_iterator:

        # r = revision_id, n = revno, d = merge depth

        revision_ids = [view[0] for view, _, _ in revs]

        revisions = repository.get_revisions(revision_ids)

        revs = [(rev[0], revision, rev[2]) for rev, revision in

            izip(revs, revisions)]

        yield revs

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

    """Group up a single large batch into smaller ones.

    :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

    num = 9

    for batch in log_rev_iterator:

        batch = iter(batch)

        while True:

            step = [detail for _, detail in zip(range(num), batch)]

            if len(step) == 0:

                break

            yield step

            num = min(int(num * 1.5), 200)

def _get_revision_limits(branch, start_revision, end_revision):

    """Get and check revision limits.

    :param  branch: The branch containing the revisions. 

    :param  start_revision: The first revision to be logged.

            For backwards compatibility this may be a mainline integer revno,

            but for merge revision support a RevisionInfo is expected.

    :param  end_revision: The last revision to be logged.

            For backwards compatibility this may be a mainline integer revno,

            but for merge revision support a RevisionInfo is expected.

    :return: (br_revno, br_rev_id, start_revno, start_rev_id, end_revno,

        end_rev_id) tuple.

    """

    branch_revno, branch_rev_id = branch.last_revision_info()

    start_rev_id = None

    if start_revision is None:

        start_revno = 1

    else:

        if isinstance(start_revision, revisionspec.RevisionInfo):

            start_rev_id = start_revision.rev_id

            start_revno = start_revision.revno or 1

        else:

            branch.check_real_revno(start_revision)

            start_revno = start_revision

    end_rev_id = None

    if end_revision is None:

        end_revno = branch_revno

    else:

        if isinstance(end_revision, revisionspec.RevisionInfo):

            end_rev_id = end_revision.rev_id

            end_revno = end_revision.revno or branch_revno

        else:

            branch.check_real_revno(end_revision)

            end_revno = end_revision

    if branch_revno != 0:

        if (start_rev_id == _mod_revision.NULL_REVISION

            or end_rev_id == _mod_revision.NULL_REVISION):

            raise errors.BzrCommandError('Logging revision 0 is invalid.')

        if start_revno > end_revno:

            raise errors.BzrCommandError("Start revision must be older than "

                                         "the end revision.")

    return (branch_revno, branch_rev_id, start_revno, start_rev_id, end_revno,

        end_rev_id)

def _get_mainline_revs(branch, revision_limits):

    """Get the mainline revisions from the branch.

    Generates the list of mainline revisions for the branch. Also map the

    revisions to rev_ids, to be used in the later filtering stage.

    :param  branch: The branch containing the revisions. 

    :param revision_limits: a tuple as returned by _get_revision_limits()

    :return: A (mainline_revs, rev_nos) tuple.

    """

    (br_revno, br_rev_id, start_revno, start_rev_id, end_revno, end_rev_id) = \

        revision_limits

    cur_revno = br_revno

    rev_nos = {}

    mainline_revs = []

    for revision_id in branch.repository.iter_reverse_revision_history(

                        br_rev_id):

        if cur_revno < start_revno:

            # We have gone far enough, but we always add 1 more revision

            rev_nos[revision_id] = cur_revno

            mainline_revs.append(revision_id)

            break

        if cur_revno <= end_revno:

            rev_nos[revision_id] = cur_revno

            mainline_revs.append(revision_id)

        cur_revno -= 1

    else:

        # We walked off the edge of all revisions, so we add a 'None' marker

        mainline_revs.append(None)

    mainline_revs.reverse()

    # override the mainline to look like the revision history.

    return mainline_revs, rev_nos

def _filter_revision_range(view_revisions, start_rev_id, end_rev_id):

    """Filter view_revisions based on revision ranges.

    :param view_revisions: A list of (revision_id, dotted_revno, merge_depth) 

            tuples to be filtered.

    :param start_rev_id: If not NONE specifies the first revision to be logged.

            If NONE then all revisions up to the end_rev_id are logged.

    :param end_rev_id: If not NONE specifies the last revision to be logged.

            If NONE then all revisions up to the end of the log are logged.

    :return: The filtered view_revisions.

    """

    if start_rev_id or end_rev_id: