/brz/remove-bazaar

from __future__ import absolute_import

 

 

from .lazy_import import lazy_import

 

from breezy import (

    branch as _mod_branch,

    cache_utf8,

    osutils,

    revision,

    workingtree,

    )

from breezy.i18n import gettext

from . import (

    lazy_regex,

from .sixish import (

    text_type,

    )

    def __init__(self, branch, revno=None, rev_id=None):

        self._has_revno = (revno is not None)

        self._revno = revno

        self.rev_id = rev_id

        if self.rev_id is None and self._revno is not None:

            self.rev_id = branch.get_rev_id(self._revno)

 

    @property

    def revno(self):

        if not self._has_revno and self.rev_id is not None:

            try:

                self._revno = self.branch.revision_id_to_revno(self.rev_id)

            except errors.NoSuchRevision:

                self._revno = None

            self._has_revno = True

        return self._revno

 

    def __bool__(self):

    __nonzero__ = __bool__

 

        if isinstance(other, type(self)) and self.branch is not other.branch:

        return '<breezy.revisionspec.RevisionInfo object %s, %s for %r>' % (

    def from_revision_id(branch, revision_id):

        return RevisionInfo(branch, revno=None, rev_id=revision_id)

        if not isinstance(spec, (str, text_type)):

            raise TypeError("revision spec needs to be text")

            raise AssertionError(

                'Creating a RevisionSpec directly is not supported. '

                'Use RevisionSpec.from_string() instead.')

        return self._match_on_and_check(branch, revs=None)

 

    _revno_regex = lazy_regex.lazy_compile(r'^(?:(\d+(\.\d+)*)|-\d+)(:.*)?$')

 

    # The revspecs to try

    _possible_revspecs = []

        if self._revno_regex.match(self.spec) is not None:

        for objgetter in self._possible_revspecs:

            rs_class = objgetter.get_obj()

    @classmethod

    def append_possible_revspec(cls, revspec):

        """Append a possible DWIM revspec.

 

        :param revspec: Revision spec to try.

        """

        cls._possible_revspecs.append(registry._ObjectGetter(revspec))

 

    @classmethod

    def append_possible_lazy_revspec(cls, module_name, member_name):

        """Append a possible lazily loaded DWIM revspec.

 

        :param module_name: Name of the module with the revspec

        :param member_name: Name of the revspec within the module

        """

        cls._possible_revspecs.append(

            registry._LazyObjectGetter(module_name, member_name))

 

        branch, revno, revision_id = self._lookup(branch)

    def _lookup(self, branch):

                except ValueError as e:

            # the user has overriden the branch to look in.

            branch = _mod_branch.Branch.open(branch_spec)

                # so for API compatibility we return None.

                revision_id = branch.get_rev_id(revno)

        branch, revno, revision_id = self._lookup(context_branch)

class RevisionIDSpec(RevisionSpec):

 

    def _match_on(self, branch, revs):

        revision_id = self.as_revision_id(branch)

        return RevisionInfo.from_revision_id(branch, revision_id)

 

 

class RevisionSpec_revid(RevisionIDSpec):

    def _as_revision_id(self, context_branch):

        if isinstance(self.spec, text_type):

            return cache_utf8.encode(self.spec)

        return self.spec

        revno, revision_id = self._revno_and_revision_id(branch)

    def _revno_and_revision_id(self, context_branch):

        except ValueError as e:

            revision_id = context_branch.get_rev_id(revno)

        revno, revision_id = self._revno_and_revision_id(context_branch)

            revno = None

        base_revision_id = RevisionSpec.from_string(self.spec)._as_revision_id(context_branch)

            branch.tags.lookup_tag(self.spec))

    __slots__ = ['branch']

    def __init__(self, branch):

        r = self.branch.repository.get_revision(self.branch.get_rev_id(index))

        return self.branch.revno()

        brz log -r date:yesterday..

    _date_regex = lazy_regex.lazy_compile(

            m = self._date_regex.match(self.spec)

                    hour, minute, second = 0, 0, 0

        with branch.lock_read():

            rev = bisect.bisect(_RevListToTimestamps(branch), dt, 1)

        if rev == branch.revno():

        return RevisionInfo(branch, rev)

        return RevisionInfo(branch, None, revision_id)

        from .branch import Branch

        with branch.lock_read():

            with other_branch.lock_read():

        from .branch import Branch

        if branch is None:

            branch = other_branch

        else:

            try:

                # pull in the remote revisions so we can diff

                branch.fetch(other_branch, revision_b)

            except errors.ReadOnlyError:

                branch = other_branch

        return RevisionInfo(branch, None, revision_b)

        from .branch import Branch

        from .branch import Branch

    def needs_branch(self):

        return False

 

    def get_branch(self):

        return self.spec

 

        trace.note(gettext('Using {0} {1}').format(location_type,

                                                        submit_location))