~bzr-pqm/bzr/bzr.dev

# Copyright (C) 2005-2011 Canonical Ltd

from bzrlib.i18n import gettext, ngettext

    lazy_regex,

    get_diff_header_encoding,

        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

 

        show_signature = rqst.get('signature')

        omit_merges = rqst.get('omit_merges')

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

                    continue

                if show_signature:

                    signature = format_signature_validity(rev_id,

                                                self.branch.repository)

                else:

                    signature = None

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

        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

                 tags=None, diff=None, signature=None):

        if revno is None:

            self.revno = None

        else:

            self.revno = str(revno)

        self.signature = signature

      Otherwise the delta attribute may not be populated.  The 'delta_format'

      attribute describes whether the 'short_status' format (1) or the long

      one (2) should be used.

      merge revisions.  If not, then only mainline revisions will be passed

      to the formatter.

      The default value is zero meaning display all levels.

      This value is only relevant if supports_merge_revisions is True.

      Otherwise the tags attribute may not be populated.

      Otherwise the diff attribute may not be populated.

 

    - supports_signatures must be True if this log formatter supports GPG

      signatures.

    must respect the following interface description::

 

                 delta_format=None, levels=None, show_advice=False,

                 to_exact_file=None, author_list_handler=None):

        :param to_exact_file: if set, gives an output stream to which

        :param author_list_handler: callable generating a list of

          authors to display for a given revision