~bzr-pqm/bzr/bzr.dev

#

# 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

from cStringIO import StringIO

from itertools import (

lazy_import(globals(), """

 

from bzrlib import (

    config,

    diff,

    errors,

    foreign,

    repository as _mod_repository,

    revision as _mod_revision,

    revisionspec,

    tsort,

    )

""")

 

from bzrlib import (

    registry,

    )

from bzrlib.osutils import (

    format_date,

    format_date_with_offset_in_original_timezone,

    get_terminal_encoding,

    terminal_width,

    )

 

 

def find_touching_revisions(branch, file_id):

    last_ie = None

    last_path = None

    revno = 1

        this_inv = branch.repository.get_inventory(revision_id)

            this_ie = this_inv[file_id]

            this_path = this_inv.id2path(file_id)

        else:

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

 

    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:

        else:

            specific_files = None

        s = StringIO()

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

            new_label='', path_encoding=path_encoding)

        return s.getvalue()

 

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

        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.

    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]

    """

    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

            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

            if not found_start and revision_id == start_rev_id:

                if not exclude_common_ancestry:

                    yield revision_id, revno_str, 0

            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

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

    """

        return log_rev_iterator

    for revs in log_rev_iterator:

 

def _make_delta_filter(branch, generate_delta, search, log_rev_iterator,

    fileids=None, direction='reverse'):

 

def _update_fileids(delta, fileids, stop_on):

    """Update the set of file-ids to search based on file lifecycle events.

    :param fileids: a set of fileids to update

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

      fileids set once their add or remove entry is detected respectively

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

        delta).

    """

    num = 9

    for batch in log_rev_iterator:

        batch = iter(batch)

    if branch_revno != 0:

        if (start_rev_id == _mod_revision.NULL_REVISION

            or end_rev_id == _mod_revision.NULL_REVISION):

        if start_revno > end_revno:

    return (start_rev_id, end_rev_id)

 

 

 

    if ((start_rev_id == _mod_revision.NULL_REVISION)

        or (end_rev_id == _mod_revision.NULL_REVISION)):

    if start_revno > end_revno:

 

    if end_revno < start_revno:

        return None, None, None, None

    cur_revno = branch_revno

    rev_nos = {}

    mainline_revs = []

        if cur_revno < start_revno:

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

            rev_nos[revision_id] = cur_revno

    return mainline_revs, rev_nos, start_rev_id, end_rev_id

 

 

def _filter_revisions_touching_file_id(branch, file_id, view_revisions,

    include_merges=True):

    r"""Return the list of revision ids which touch a given file id.

    This includes the revisions which directly change the file id,

    and the revisions which merge these changes. So if the

    revision graph is::

        A-.

        |\ \

        B C E

    """

    # Lookup all possible text keys to determine which ones actually modified

    # the file.

    text_keys = [(file_id, rev_id) for rev_id, revno, depth in view_revisions]

    next_keys = None

    # Looking up keys in batches of 1000 can cut the time in half, as well as

    #       indexing layer. We might consider passing in hints as to the known

    #       access pattern (sparse/clustered, high success rate/low success

    #       rate). This particular access is clustered with a low success rate.

    modified_text_revisions = set()

    chunk_size = 1000

    for start in xrange(0, len(text_keys), chunk_size):

    return result

 

 

def reverse_by_depth(merge_sorted_revisions, _depth=0):

    """Reverse revisions by depth.

 

    """

 

    def __init__(self, rev=None, revno=None, merge_depth=0, delta=None,

        self.rev = rev

        self.merge_depth = merge_depth

        self.delta = delta

        self.tags = tags

        self.diff = diff

 

 

class LogFormatter(object):

    to indicate which LogRevision attributes it supports:

 

    - supports_delta must be True if this log formatter supports delta.

 

    - supports_merge_revisions must be True if this log formatter supports

 

    - preferred_levels is the number of levels this formatter defaults to.

 

    - supports_tags must be True if this log formatter supports tags.

 

    - supports_diff must be True if this log formatter supports diffs.

 

    Plugins can register functions to show custom revision properties using

    the properties_handler_registry. The registered function

        def my_show_properties(properties_dict):

            # code that returns a dict {'name':'value'} of the properties

            # to be shown

        """Create a LogFormatter.

 

        :param to_file: the file to output to

             non-Unicode diffs are written.

        :param show_ids: if True, revision-ids are to be displayed

        :param show_timezone: the timezone to use

            if advice_sep:

                self.to_file.write(advice_sep)

            self.to_file.write(

 

    def get_advice_separator(self):

        """Get the text separating the log from the closing advice."""

    supports_delta = True

    supports_tags = True

    supports_diff = True

 

    def __init__(self, *args, **kwargs):

        super(LongLogFormatter, self).__init__(*args, **kwargs)

                self.merge_marker(revision)))

        if revision.tags:

            lines.append('tags: %s' % (', '.join(revision.tags)))

            lines.append('revision-id: %s' % (revision.rev.revision_id,))

            for parent_id in revision.rev.parent_ids:

                lines.append('parent: %s' % (parent_id,))

        lines.extend(self.custom_properties(revision.rev))

 

        lines.append('timestamp: %s' % (self.date_string(revision.rev),))

 

        lines.append('message:')

        if not revision.rev.message:

            lines.append('  (no message)')

        if revision.delta is not None:

            # Use the standard status output to display changes

            from bzrlib.delta import report_delta

                         show_ids=self.show_ids, indent=indent)

        if revision.diff is not None:

            to_file.write(indent + 'diff:\n')

        indent = '    ' * depth

        revno_width = self.revno_width_by_depth.get(depth)

        if revno_width is None:

                # mainline revno, e.g. 12345

                revno_width = 5

            else:

        if revision.tags:

            tags = ' {%s}' % (', '.join(revision.tags))

        to_file.write(indent + "%*s %s\t%s%s%s\n" % (revno_width,

                format_date(revision.rev.timestamp,

                            revision.rev.timezone or 0,

                            self.show_timezone, date_fmt="%Y-%m-%d",

                            show_offset=False),

                tags, self.merge_marker(revision)))

        self.show_properties(revision.rev, indent+offset)

            to_file.write(indent + offset + 'revision-id:%s\n'

                          % (revision.rev.revision_id,))

        if not revision.rev.message:

        if revision.delta is not None:

            # Use the standard status output to display changes

            from bzrlib.delta import report_delta

                         show_ids=self.show_ids, indent=indent + offset)

        if revision.diff is not None:

            self.show_diff(self.to_exact_file, revision.diff, '      ')

 

    def log_string(self, revno, rev, max_chars, tags=None, prefix=''):

        """Format log info into one string. Truncate tail of string

        """

        out = []

        if revno:

            # show revno only when is not None

            out.append("%s:" % revno)

        out.append(self.date_string(rev))

        if len(rev.parent_ids) > 1:

            out.append('[merge]')

        return self.get(name)(*args, **kwargs)

 

    def get_default(self, branch):

 

 

log_formatter_registry = LogFormatterRegistry()

 

 

log_formatter_registry.register('short', ShortLogFormatter,

log_formatter_registry.register('long', LongLogFormatter,

log_formatter_registry.register('line', LineLogFormatter,

log_formatter_registry.register('gnu-changelog', GnuChangelogLogFormatter,

 

 

def register_formatter(name, formatter):

    try:

        return log_formatter_registry.make_formatter(name, *args, **kwargs)

    except KeyError:

 

 

def author_list_all(rev):

                              'The committer')

 

 

def show_changed_revisions(branch, old_rh, new_rh, to_file=None,

                           log_format='long'):

    """Show the change in revision history comparing the old revision history to the new one.

    old_revisions = set()

    new_history = []

    new_revisions = set()