~bzr-pqm/bzr/bzr.dev

# Copyright (C) 2005-2011 Canonical Ltd

    controldir,

from bzrlib.i18n import gettext, ngettext

    lazy_regex,

    format_date_with_offset_in_original_timezone,

    get_diff_header_encoding,

    graph = branch.repository.get_graph()

    history = list(graph.iter_lefthand_ancestry(branch.last_revision(),

        [_mod_revision.NULL_REVISION]))

    for revision_id in reversed(history):

        this_inv = branch.repository.get_inventory(revision_id)

        if this_inv.has_id(file_id):

             show_diff=False,

             match=None):

 

    :param match: Dictionary of search lists to use when matching revision

      properties.

# Note: This needs to be kept in sync with the defaults in

    'levels': None,

    'exclude_common_ancestry': False,

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

                          message_search=None, levels=None, generate_tags=True,

                          delta_type=None,

                          diff_type=None, _match_using_deltas=True,

                          exclude_common_ancestry=False, match=None,

                          signature=False, omit_merges=False,

                          ):

      generate; 1 for just the mainline; 0 for all levels, or None for

      a sensible default.

`

 

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

      range operator or as a graph difference.

 

    :param signature: show digital signature information

 

    :param match: Dictionary of list of search strings to use when filtering

      revisions. Keys can be 'message', 'author', 'committer', 'bugs' or

      the empty string to match any of the preceding properties.

 

    :param omit_merges: If True, commits with more than one parent are

      omitted.

 

    # Take care of old style message_search parameter

    if message_search:

        if match:

            if 'message' in match:

                match['message'].append(message_search)

            else:

                match['message'] = [message_search]

        else:

            match={ 'message': [message_search] }

        'exclude_common_ancestry': exclude_common_ancestry,

        'signature': signature,

        'match': match,

        'omit_merges': omit_merges,

    result = _DEFAULT_REQUEST_PARAMS.copy()

def format_signature_validity(rev_id, repo):

    """get the signature validity

 

    :param rev_id: revision id to validate

    :param repo: repository of revision

    :return: human readable string to print to log

    """

    from bzrlib import gpg

 

    gpg_strategy = gpg.GPGStrategy(None)

    result = repo.verify_revision(rev_id, gpg_strategy)

    if result[0] == gpg.SIGNATURE_VALID:

        return "valid signature from {0}".format(result[1])

    if result[0] == gpg.SIGNATURE_KEY_MISSING:

        return "unknown key {0}".format(result[1])

    if result[0] == gpg.SIGNATURE_NOT_VALID:

        return "invalid signature!"

    if result[0] == gpg.SIGNATURE_NOT_SIGNED:

        return "no signature"

 

 

    """An object that generates, formats and displays a log."""

        if rqst['levels'] is None or lf.get_levels() > rqst['levels']:

            # user didn't specify levels, use whatever the LF can handle:

            rqst['levels'] = lf.get_levels()

 

        if not getattr(lf, 'supports_signatures', False):

            rqst['signature'] = False

 

        levels = rqst.get('levels')

        limit = rqst.get('limit')

        diff_type = rqst.get('diff_type')

        show_signature = rqst.get('signature')

        omit_merges = rqst.get('omit_merges')

                if omit_merges and len(rev.parent_ids) > 1:

                    continue

                if diff_type is None:

                    diff = None

                else:

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

                if show_signature:

                    signature = format_signature_validity(rev_id,

                                                self.branch.repository)

                else:

                    signature = None

                    self.rev_tag_dict.get(rev_id), diff, signature)

    def _format_diff(self, rev, rev_id, diff_type):

        path_encoding = get_diff_header_encoding()

            new_label='', path_encoding=path_encoding)

        view_revisions = _calc_view_revisions(

            self.branch, self.start_rev_id, self.end_rev_id,

            rqst.get('direction'),

            generate_merge_revisions=generate_merge_revisions,

            delayed_graph_generation=delayed_graph_generation,

            exclude_common_ancestry=rqst.get('exclude_common_ancestry'))

            rqst.get('delta_type'), rqst.get('match'),

        view_revisions = _calc_view_revisions(

            self.branch, self.start_rev_id, self.end_rev_id,

            rqst.get('direction'), generate_merge_revisions=True,

            exclude_common_ancestry=rqst.get('exclude_common_ancestry'))

            rqst.get('delta_type'), rqst.get('match'))

                         generate_merge_revisions,

                         delayed_graph_generation=False,

                         exclude_common_ancestry=False,

                         ):

    if (exclude_common_ancestry and start_rev_id == end_rev_id):

        raise errors.BzrCommandError(gettext(

            '--exclude-common-ancestry requires two different revisions'))

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

        raise ValueError(gettext('invalid direction %r') % direction)

    if (end_rev_id and start_rev_id == end_rev_id

        and (not generate_merge_revisions

             or not _has_merges(branch, end_rev_id))):

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

        iter_revs = _generate_one_revision(branch, end_rev_id, br_rev_id,

                                           br_revno)

    elif not generate_merge_revisions:

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

        iter_revs = _generate_flat_revisions(branch, start_rev_id, end_rev_id,

                                             direction, exclude_common_ancestry)

        if direction == 'forward':

            iter_revs = reversed(iter_revs)

        iter_revs = _generate_all_revisions(branch, start_rev_id, end_rev_id,

                                            direction, delayed_graph_generation,

                                            exclude_common_ancestry)

        if direction == 'forward':

            iter_revs = _rebase_merge_depth(reverse_by_depth(list(iter_revs)))

    return iter_revs

        revno_str = _compute_revno_str(branch, rev_id)

def _generate_flat_revisions(branch, start_rev_id, end_rev_id, direction,

                             exclude_common_ancestry=False):

    result = _linear_view_revisions(

        branch, start_rev_id, end_rev_id,

        exclude_common_ancestry=exclude_common_ancestry)

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

                ' left-hand history of end revision.'))

                            delayed_graph_generation,

                            exclude_common_ancestry=False):

 

    # The above is only true for old formats (<= 0.92), for newer formats, a

    # couple of seconds only should be needed to load the whole graph and the

    # other graph operations needed are even faster than that -- vila 100201

            for rev_id, revno, depth in  _linear_view_revisions(

                branch, start_rev_id, end_rev_id, exclude_common_ancestry):

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

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

                    # may not raise _StartNotLinearAncestor for a revision that

                    # is an ancestor but not a *linear* one. But since we have

                    # loaded the graph to do the check (or calculate a dotted

                    # revno), we may as well accept to show the log...  We need

                    # the check only if start_rev_id is not None as all

                    # revisions have _mod_revision.NULL_REVISION as an ancestor

                    # -- vila 20100319

                    graph = branch.repository.get_graph()

                    if (start_rev_id is not None

                        and not graph.is_ancestor(start_rev_id, end_rev_id)):

                        raise _StartNotLinearAncestor()

                    # Since we collected the revisions so far, we need to

                    # adjust end_rev_id.

                return initial_revisions

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

                ' history of end revision.'))

 

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

    # this revision, we need to switch to _graph_view_revisions.

                              rebase_initial_depths=(direction == 'reverse'),

                              exclude_common_ancestry=exclude_common_ancestry))

    return view_revisions

def _compute_revno_str(branch, rev_id):

    """Compute the revno string from a rev_id.

 

    :return: The revno string, or None if the revision is not in the supplied

        branch.

    """

    try:

        revno = branch.revision_id_to_dotted_revno(rev_id)

    except errors.NoSuchRevision:

        # The revision must be outside of this branch

        return None

    else:

        return '.'.join(str(n) for n in revno)

 

 

        try:

            start_dotted = branch.revision_id_to_dotted_revno(start_rev_id)

            end_dotted = branch.revision_id_to_dotted_revno(end_rev_id)

        except errors.NoSuchRevision:

            # one or both is not in the branch; not obvious

            return False

    # if either start or end is not specified then we use either the first or

    # the last revision and *they* are obvious ancestors.

def _linear_view_revisions(branch, start_rev_id, end_rev_id,

                           exclude_common_ancestry=False):

    :param exclude_common_ancestry: Whether the start_rev_id should be part of

        the iterated revisions.

        is not found walking the left-hand history

    graph = repo.get_graph()

        for revision_id in graph.iter_lefthand_ancestry(br_rev_id,

            (_mod_revision.NULL_REVISION,)):

        for revision_id in graph.iter_lefthand_ancestry(end_rev_id,

                (_mod_revision.NULL_REVISION,)):

            revno_str = _compute_revno_str(branch, revision_id)

                if not exclude_common_ancestry:

                    yield revision_id, revno_str, 0

                          rebase_initial_depths=True,

                          exclude_common_ancestry=False):

    if exclude_common_ancestry:

        stop_rule = 'with-merges-without-common-ancestry'

    else:

        stop_rule = 'with-merges'

        stop_rule=stop_rule)

                    # From now on we reduce the depth adjustement, this can be

                    # surprising for users. The alternative requires two passes

                    # which breaks the fast display of the first revision

                    # though.

def _make_search_filter(branch, generate_delta, match, log_rev_iterator):

    :param match: A dictionary with properties as keys and lists of strings

        as values. To match, a revision may match any of the supplied strings

        within a single property but must match at least one string for each

        property.

    if match is None:

    searchRE = [(k, [re.compile(x, re.IGNORECASE) for x in v])

                for (k,v) in match.iteritems()]

    return _filter_re(searchRE, log_rev_iterator)

 

 

def _filter_re(searchRE, log_rev_iterator):

        new_revs = [rev for rev in revs if _match_filter(searchRE, rev[1])]

        if new_revs:

            yield new_revs

 

def _match_filter(searchRE, rev):

    strings = {

               'message': (rev.message,),

               'committer': (rev.committer,),

               'author': (rev.get_apparent_authors()),

               'bugs': list(rev.iter_bugs())

               }

    strings[''] = [item for inner_list in strings.itervalues()

                   for item in inner_list]

    for (k,v) in searchRE:

        if k in strings and not _match_any_filter(strings[k], v):

            return False

    return True

 

def _match_any_filter(strings, res):

    return any([filter(None, map(re.search, strings)) for re in res])

 

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

            raise errors.BzrCommandError(gettext("Start revision must be "

                                         "older than the end revision."))

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

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

                                     "than the end revision."))

    graph = branch.repository.get_graph()

    for revision_id in graph.iter_lefthand_ancestry(

            branch_last_revision, (_mod_revision.NULL_REVISION,)):

 

    graph = branch.repository.get_file_graph()

    get_parent_map = graph.get_parent_map