~bzr-pqm/bzr/bzr.dev

# Copyright (C) 2005-2011 Canonical Ltd

from bzrlib.i18n import gettext, ngettext

    lazy_regex,

    get_diff_header_encoding,

        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"

 

 

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

                branch, start_rev_id, end_rev_id, exclude_common_ancestry):

                    # 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

                    if (start_rev_id is not None

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

                    # 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

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)

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.

        :param who: Name of the default handler.

        :param short: Whether to shorten names to either name or address.

        :param sep: What separator to use for automatic concatenation.

        """

        if self._author_list_handler is not None:

            # The user did specify --authors, which overrides the default

            author_list_handler = self._author_list_handler

        else:

            # The user didn't specify --authors, so we use the caller's default

            author_list_handler = author_list_registry.get(who)

        names = author_list_handler(rev)

        if short:

            for i in range(len(names)):

                name, address = config.parse_username(names[i])

                if name:

                    names[i] = name

                else:

                    names[i] = address

        if sep is not None:

            names = sep.join(names)

        return names