/brz/remove-bazaar

#

# 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

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

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

"""

 

import codecs

import re

import sys

from warnings import (

    warn,

    )

 

lazy_import(globals(), """

 

    config,

    diff,

    errors,

    foreign,

    repository as _mod_repository,

    revision as _mod_revision,

    tsort,

    )

""")

 

    registry,

    )

    format_date,

    format_date_with_offset_in_original_timezone,

    get_terminal_encoding,

    terminal_width,

    )

    )

 

 

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

    or to traverse a non-mainline set of revisions?

    """

    last_path = None

    revno = 1

        else:

 

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

        # are those two states effectively the same or not?

 

            # not present in either

            pass

            yield revno, revision_id, "added " + this_path

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

            yield revno, revision_id, "modified " + this_path

 

        last_path = this_path

        revno += 1

 

 

def show_log(branch,

             lf,

             specific_fileid=None,

             end_revision=None,

             search=None,

             limit=None,

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

 

    This function is being retained for backwards compatibility but

        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:

    Logger(branch, rqst).show(lf)

 

 

# make_log_request_dict() below

_DEFAULT_REQUEST_PARAMS = {

    'direction': 'reverse',

    'generate_tags': True,

    'exclude_common_ancestry': False,

    '_match_using_deltas': True,

 

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

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

                          delta_type=None,

                          diff_type=None, _match_using_deltas=True,

                          ):

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

 

      matching commit messages

 

    :param levels: the number of levels of revisions to

 

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

 

    :param _match_using_deltas: a private parameter controlling the

      algorithm used for matching specific_fileids. This parameter

      use it.

 

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

      range operator or as a graph difference.

    """

    return {

        'direction': direction,

        'specific_fileids': specific_fileids,

        'start_revision': start_revision,

        'end_revision': end_revision,

        'limit': limit,

        'levels': levels,

        'generate_tags': generate_tags,

        'delta_type': delta_type,

        'diff_type': diff_type,

        'exclude_common_ancestry': exclude_common_ancestry,

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

    if rqst:

        result.update(rqst)

    return result

 

 

class LogGenerator(object):

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

 

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

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

        rqst = self.rqst

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

        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)

        levels = rqst.get('levels')

        limit = rqst.get('limit')

        diff_type = rqst.get('diff_type')

        log_count = 0

        revision_iterator = self._create_log_revision_iterator()

        for revs in revision_iterator:

                # 0 levels means show everything; merge_depth counts from 0

                if levels != 0 and merge_depth >= levels:

                    continue

                if diff_type is None:

                    diff = None

                else:

                    diff = self._format_diff(rev, rev_id, diff_type)

                yield LogRevision(rev, revno, merge_depth, delta,

                if limit:

                    log_count += 1

                    if log_count >= limit:

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

        else:

            specific_files = None

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

        return s.getvalue()

 

    def _create_log_revision_iterator(self):

 

        # Apply the other filters

        return make_log_rev_iterator(self.branch, view_revisions,

            file_ids=rqst.get('specific_fileids'),

            direction=rqst.get('direction'))

 

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

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

        return make_log_rev_iterator(self.branch, view_revisions,

 

 

def _calc_view_revisions(branch, start_rev_id, end_rev_id, direction,

             a list of the same tuples.

    """

    if (exclude_common_ancestry and start_rev_id == end_rev_id):

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

    br_revno, br_rev_id = branch.last_revision_info()

    if br_revno == 0:

        return []

        and (not generate_merge_revisions

             or not _has_merges(branch, end_rev_id))):

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

    return iter_revs

 

 

        # It's the tip

        return [(br_rev_id, br_revno, 0)]

    else:

        return [(rev_id, revno_str, 0)]

 

 

def _generate_all_revisions(branch, start_rev_id, end_rev_id, direction,

                            delayed_graph_generation,

                            exclude_common_ancestry=False):

    if delayed_graph_generation:

        try:

            for rev_id, revno, depth in  _linear_view_revisions(

                if _has_merges(branch, rev_id):

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

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

        except _StartNotLinearAncestor:

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

            # be nested down somewhere

 

    # We exit the loop above because we encounter a revision with merges, from

    # this revision, we need to switch to _graph_view_revisions.

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

        _graph_view_revisions(branch, start_rev_id, end_rev_id,

                              rebase_initial_depths=(direction == 'reverse'),

                              exclude_common_ancestry=exclude_common_ancestry))

    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:

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

            # both on mainline

            return start_dotted[0] <= end_dotted[0]

    return True

 

 

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

    """

    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

    else:

        if end_rev_id is None:

            end_rev_id = br_rev_id

        found_start = start_rev_id is None

                break

            else:

 

 

def _graph_view_revisions(branch, start_rev_id, end_rev_id,

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

 

 

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

        if min_depth != 0:

    return view_revisions

 

 

    """

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

    # the standard interface here.

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

    else:

        def _convert():

            for view in view_revisions:

    return log_rev_iterator