/brz/remove-bazaar

# Copyright (C) 2005-2011 Canonical Ltd

from __future__ import absolute_import

 

import itertools

from .lazy_import import lazy_import

from breezy import (

    controldir,

from breezy.i18n import gettext, ngettext

from . import (

    errors,

    revisionspec,

from .osutils import (

    get_diff_header_encoding,

from .sixish import (

    BytesIO,

    range,

    zip,

from .tree import find_previous_path

 

 

def find_touching_revisions(repository, last_revision, last_tree, last_path):

    last_verifier = last_tree.get_file_verifier(last_path)

    graph = repository.get_graph()

    history = list(graph.iter_lefthand_ancestry(last_revision, []))

    revno = len(history)

    for revision_id in history:

        this_tree = repository.revision_tree(revision_id)

        this_path = find_previous_path(last_tree, this_tree, last_path)

        if this_path is not None and last_path is None:

            yield revno, revision_id, "deleted " + this_path

            this_verifier = this_tree.get_file_verifier(this_path)

        elif this_path is None and last_path is not None:

            yield revno, revision_id, "added " + last_path

            yield revno, revision_id, ("renamed %s => %s" % (this_path, last_path))

            this_verifier = this_tree.get_file_verifier(this_path)

        else:

            this_verifier = this_tree.get_file_verifier(this_path)

            if (this_verifier != last_verifier):

                yield revno, revision_id, "modified " + this_path

        last_verifier = this_verifier

        last_tree = this_tree

        if last_path is None:

            return

        revno -= 1

             show_diff=False,

             match=None):

 

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

      properties.

    if isinstance(start_revision, int):

        try:

            start_revision = revisionspec.RevisionInfo(branch, start_revision)

        except errors.NoSuchRevision:

            raise errors.InvalidRevisionNumber(start_revision)

 

    if isinstance(end_revision, int):

        try:

            end_revision = revisionspec.RevisionInfo(branch, end_revision)

        except errors.NoSuchRevision:

            raise errors.InvalidRevisionNumber(end_revision)

 

    if end_revision is not None and end_revision.revno == 0:

        raise errors.InvalidRevisionNumber(end_revision.revno)

 

                                 start_revision=start_revision, end_revision=end_revision,

                                 limit=limit, message_search=search,

                                 delta_type=delta_type, diff_type=diff_type)

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

`

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

 

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

    """get the signature validity

 

    :param rev_id: revision id to validate

    :param branch: branch of revision

    :return: human readable string to print to log

    """

    from breezy import gpg

 

    gpg_strategy = gpg.GPGStrategy(branch.get_config_stack())

    result = branch.repository.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"

 

 

        with self.branch.lock_read():

        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

        try:

            for lr in generator.iter_log_revisions():

                lf.log_revision(lr)

        except errors.GhostRevisionUnusableHere:

            raise errors.BzrCommandError(

                gettext('Further revision history missing.'))

 

        show_signature = rqst.get('signature')

        omit_merges = rqst.get('omit_merges')

                if levels != 0 and merge_depth is not None and merge_depth >= levels:

                    continue

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

                    continue

                if rev is None:

                    raise errors.GhostRevisionUnusableHere(rev_id)

                if show_signature:

                    signature = format_signature_validity(rev_id, self.branch)

                else:

                    signature = None

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

        s = BytesIO()

        path_encoding = get_diff_header_encoding()

                             new_label='', path_encoding=path_encoding)

                               "when logging %d files" % file_count)

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

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

                                     file_ids=rqst.get('specific_fileids'),

                                     direction=rqst.get('direction'))

                                                            rqst.get('specific_fileids')[

                                                                0], view_revisions,

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

                                     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)

    br_rev_id = branch.last_revision()

    if br_rev_id == _mod_revision.NULL_REVISION:

         or not _has_merges(branch, end_rev_id))):

        return _generate_one_revision(branch, end_rev_id, br_rev_id,

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

            for rev_id, revno, depth in _linear_view_revisions(

                    branch, start_rev_id, end_rev_id, exclude_common_ancestry):

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

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

                                                 ' history of end revision.'))

    view_revisions = itertools.chain(iter(initial_revisions),

                                     _graph_view_revisions(branch, start_rev_id, end_rev_id,

                                                           rebase_initial_depths=(

                                                               direction == 'reverse'),

                                                           exclude_common_ancestry=exclude_common_ancestry))

def _compute_revno_str(branch, rev_id):

    """Compute the revno string from a rev_id.