~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

    repository as _mod_repository,

    revision as _mod_revision,

    revisionspec,

    tsort,

    )

""")

 

from bzrlib import (

    registry,

    )

from bzrlib.osutils import (

    format_date,

    get_terminal_encoding,

    terminal_width,

    )

 

    last_path = None

    revno = 1

    for revision_id in branch.revision_history():

            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:

# make_log_request_dict() below

_DEFAULT_REQUEST_PARAMS = {

    'direction': 'reverse',

    'generate_tags': True,

    '_match_using_deltas': True,

    }

 

 

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

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

 

    Using this function may make code slightly safer by ensuring

      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;

      algorithm used for matching specific_fileids. This parameter

      may be removed in the future so bzrlib client code should NOT

      use it.

    """

    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,

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

 

 

 

class Logger(object):

 

    def __init__(self, branch, rqst):

        """Create a Logger.

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

        :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 levels != 0 and merge_depth >= levels:

                    continue

                yield LogRevision(rev, revno, merge_depth, delta,

                if limit:

                    log_count += 1

                    if log_count >= limit:

                        return

 

        repo = self.branch.repository

        if len(rev.parent_ids) == 0:

            ancestor_id = _mod_revision.NULL_REVISION

        else:

            specific_files = None

        s = StringIO()

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

        return s.getvalue()

 

    def _create_log_revision_iterator(self):

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

        delayed_graph_generation = not rqst.get('specific_fileids') and (

                rqst.get('limit') or self.start_rev_id or self.end_rev_id)

 

        # Apply the other filters

        return make_log_rev_iterator(self.branch, view_revisions,

            file_ids=rqst.get('specific_fileids'),

            direction=rqst.get('direction'))

 

        # Note that we always generate the merge revisions because

        # filter_revisions_touching_file_id() requires them ...

        rqst = self.rqst

        if not isinstance(view_revisions, list):

            view_revisions = list(view_revisions)

        view_revisions = _filter_revisions_touching_file_id(self.branch,

            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,

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

 

    else:

 

 

def _generate_one_revision(branch, rev_id, br_rev_id, br_revno):

        # It's the tip

        return [(br_rev_id, br_revno, 0)]

    else:

        return [(rev_id, revno_str, 0)]

 

 

    # 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

        except _StartNotLinearAncestor:

            raise errors.BzrCommandError('Start revision not found in'

                ' left-hand history of end revision.')

    return result

 

 

def _generate_all_revisions(branch, start_rev_id, end_rev_id, direction,

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

                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

        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

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

 

 

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

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

            # both on mainline

            return start_dotted[0] <= end_dotted[0]

        else:

            # not obvious

            return False

    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

            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:

                found_start = True

                break

            else:

 

 

def _graph_view_revisions(branch, start_rev_id, end_rev_id,

    """Calculate revisions to view including merges, newest to oldest.

 

    :param branch: the branch

      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,

    if not rebase_initial_depths:

        for (rev_id, merge_depth, revno, end_of_merge

             ) in view_revisions:

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

    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.