~bzr-pqm/bzr/bzr.dev

# Copyright (C) 2005-2011 Canonical Ltd

from __future__ import absolute_import

 

    controldir,

from bzrlib.i18n import gettext, ngettext

    lazy_regex,

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

        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,

                          message_search=None, levels=None, generate_tags=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 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] }

        '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_signature(rev_id, gpg_strategy)

    if result[0] == gpg.SIGNATURE_VALID:

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

 

 

        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)

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

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

        raise errors.BzrCommandError(gettext(

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

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

        return  _generate_one_revision(branch, end_rev_id, br_rev_id,

                                       br_revno)

    if not generate_merge_revisions:

        try:

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

            iter_revs = _linear_view_revisions(

                branch, start_rev_id, end_rev_id,

                exclude_common_ancestry=exclude_common_ancestry)

            # 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 and not _is_obvious_ancestor(

                        branch, start_rev_id, end_rev_id))):

                    iter_revs = list(iter_revs)

            if direction == 'forward':

                iter_revs = reversed(iter_revs)

            return iter_revs

        except _StartNotLinearAncestor:

            # Switch to the slower implementation that may be able to find a

            # non-obvious ancestor out of the left-hand history.

            pass

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

        revno_str = _compute_revno_str(branch, rev_id)

                branch, start_rev_id, end_rev_id, exclude_common_ancestry):

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

                ' history of end revision.'))

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

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

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

 

                 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

        self._author_list_handler = author_list_handler

                "Use --include-merged or -n0 to see merged revisions.\n")

        return self.authors(rev, 'first', short=True, sep=', ')

 

    def authors(self, rev, who, short=False, sep=None):

        """Generate list of authors, taking --authors option into account.

 

        The caller has to specify the name of a author list handler,

        as provided by the author list registry, using the ``who``

        argument.  That name only sets a default, though: when the

        user selected a different author list generation using the

        ``--authors`` command line switch, as represented by the

        ``author_list_handler`` constructor argument, that value takes

        precedence.

 

        :param rev: The revision for which to generate the list of authors.