/brz/remove-bazaar

# along with this program; if not, write to the Free Software

# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 

from binascii import hexlify

from copy import deepcopy

import re

import time

 

from bzrlib import (

    osutils,

    transactions,

    xml6,

    )

from bzrlib.decorators import needs_read_lock, needs_write_lock

from bzrlib.inter import InterObject

from bzrlib.inventory import Inventory, InventoryDirectory, ROOT_ID

        )

from bzrlib.trace import mutter, note, warning

 

 

# Old formats display a warning, but only once

    remote) disk.

    """

 

    @needs_write_lock

    def add_inventory(self, revid, inv, parents):

        """Add the inventory inv to the repository as revid.

 

        returns the sha1 of the serialized inventory.

        """

        assert inv.revision_id is None or inv.revision_id == revid, \

            "Mismatch between inventory revision" \

            " id and insertion revid (%r, %r)" % (inv.revision_id, revid)

                       If supplied its signature_needed method will be used

                       to determine if a signature should be made.

        """

        if config is not None and config.signature_needed():

            if inv is None:

                inv = self.get_inventory(rev_id)

        or testing the revision graph.

        """

        if not revision_id or not isinstance(revision_id, basestring):

        return self._revision_store.get_revisions([revision_id],

                                                  self.get_transaction())[0]

    @needs_read_lock

        # revisions. We don't need to see all lines in the inventory because

        # only those added in an inventory in rev X can contain a revision=X

        # line.

        pb = ui.ui_factory.nested_progress_bar()

        try:

            for line in w.iter_lines_added_or_present_in_versions(

                if revision_id in selected_revision_ids:

        finally:

            pb.finished()

        return result

        :return: a dictionary of revision_id->revision_parents_list.

        """

        # special case NULL_REVISION

            return {}

                             node in all_revisions])

        if revision_id is None:

            return entire_graph

        :param revision_ids: an iterable of revisions to graph or None for all.

        :return: a Graph object with the graph reachable from revision_ids.

        """

        if not revision_ids:

            pending = set(self.all_revision_ids())

            required = set([])

        else:

            pending = set(revision_ids)

            # special case NULL_REVISION

            required = set(pending)

        done = set([])

        while len(pending):

        """

        # TODO: refactor this to use an existing revision object

        # so we don't need to read it in twice.

        else:

            inv = self.get_revision_inventory(revision_id)

            return RevisionTree(self, inv, revision_id)

 

        `revision_id` may not be None or 'null:'"""

        assert None not in revision_ids

        texts = self.get_inventory_weave().get_texts(revision_ids)

        for text, revision_id in zip(texts, revision_ids):

            inv = self.deserialise_inventory(revision_id, text)

    def supports_rich_root(self):

        return self._format.rich_root_data

 

 

class AllInOneRepository(Repository):

    """Legacy support - the repository behaviour for all-in-one branches."""

            text_store = get_store('text-store')

        super(AllInOneRepository, self).__init__(_format, a_bzrdir, a_bzrdir._control_files, _revision_store, control_store, text_store)

 

    @needs_read_lock

    def is_shared(self):

        """AllInOne repositories cannot be shared."""

        return not self.control_files._transport.has('no-working-trees')

 

 

class KnitRepository(MetaDirRepository):

    """Knit format repository."""

 

        :return: a dictionary of revision_id->revision_parents_list.

        """

        # special case NULL_REVISION

            return {}

        if revision_id is None:

            raise errors.NoSuchRevision(self, revision_id)

        else:

            # add what can be reached from revision_id

            pending = set([revision_id])

            while len(pending) > 0:

                node = pending.pop()

                for revision_id in result[node]:

                    if revision_id not in result:

                        pending.add(revision_id)

        :param revision_ids: an iterable of revisions to graph or None for all.

        :return: a Graph object with the graph reachable from revision_ids.

        """

        vf = self._get_revision_vf()

        versions = set(vf.versions())

        if not revision_ids:

        else:

            pending = set(revision_ids)

            # special case NULL_REVISION

            required = set(pending)

        done = set([])

        while len(pending):

                                  transport,

                                  control_files,

                                  prefixed=True,

                                  versionedfile_kwargs={},

                                  escaped=False):

        weave_transport = control_files._transport.clone(name)

        klass._formats[format.get_format_string()] = format

 

    @classmethod

    def set_default_format(klass, format):

        klass._default_format = format

 

    @classmethod

        TODO: when creating split out bzr branch formats, move this to a common

        base for Format5, Format6. or something like that.

        """

        if shared:

            raise errors.IncompatibleFormat(self, a_bzrdir._format)

 

        

        # Create an empty weave

        sio = StringIO()

        empty_weave = sio.getvalue()

 

        mutter('creating repository in %s.', a_bzrdir.transport.base)

        

        # FIXME: RBC 20060125 don't peek under the covers

        # NB: no need to escape relative paths that are url safe.

        control_files.create_lock()

        control_files.lock_write()

        control_files._transport.mkdir_multi(dirs,

        # FIXME: RBC 20060125 don't peek under the covers

        # NB: no need to escape relative paths that are url safe.

        repository_transport = a_bzrdir.get_repository_transport(self)

        control_files.create_lock()

        return control_files

 

        :param shared: If true the repository will be initialized as a shared

                       repository.

        """

        # Create an empty weave

        sio = StringIO()

        empty_weave = sio.getvalue()

 

        mutter('creating repository in %s.', a_bzrdir.transport.base)

            repo_transport = _override_transport

        else:

            repo_transport = a_bzrdir.get_repository_transport(None)

        text_store = self._get_text_store(repo_transport, control_files)

        control_store = self._get_control_store(repo_transport, control_files)

        _revision_store = self._get_revision_store(repo_transport, control_files)

 

 

class RepositoryFormatKnit(MetaDirRepositoryFormat):

            repo_transport,

            prefixed=False,

            file_mode=control_files._file_mode,

            )

 

    def _get_revision_store(self, repo_transport, control_files):

            file_mode=control_files._file_mode,

            prefixed=False,

            precious=True,

            escaped=True,

            )

        return KnitRevisionStore(versioned_file_store)

    def _get_text_store(self, transport, control_files):

        """See RepositoryFormat._get_text_store()."""

        return self._get_versioned_file_store('knits',

 

    def initialize(self, a_bzrdir, shared=False):

        """Create a knit format 1 repository.

        

        self._upload_blank_content(a_bzrdir, dirs, files, utf8_files, shared)

        repo_transport = a_bzrdir.get_repository_transport(None)

        control_store = self._get_control_store(repo_transport, control_files)

        transaction = transactions.WriteTransaction()

        # trigger a write of the inventory store.

        control_store.get_weave_or_empty('inventory', transaction)

        _revision_store = self._get_revision_store(repo_transport, control_files)

        _revision_store.has_revision_id('A', transaction)

        _revision_store.get_signature_file(transaction)

        return self.open(a_bzrdir=a_bzrdir, _found=True)

            repo_transport = _override_transport

        else:

            repo_transport = a_bzrdir.get_repository_transport(None)

        text_store = self._get_text_store(repo_transport, control_files)

        control_store = self._get_control_store(repo_transport, control_files)

        _revision_store = self._get_revision_store(repo_transport, control_files)

            repo_transport = _override_transport

        else:

            repo_transport = a_bzrdir.get_repository_transport(None)

        text_store = self._get_text_store(repo_transport, control_files)

        control_store = self._get_control_store(repo_transport, control_files)

        _revision_store = self._get_revision_store(repo_transport, control_files)

# formats which have no format string are not discoverable

# and not independently creatable, so are not registered.

RepositoryFormat.register_format(RepositoryFormat7())

_default_format = RepositoryFormatKnit1()

RepositoryFormat.register_format(_default_format)

RepositoryFormat.register_format(RepositoryFormatKnit2())

_legacy_formats = [RepositoryFormat4(),

                   RepositoryFormat5(),

                   RepositoryFormat6()]

        if basis is not None:

            self.target.fetch(basis, revision_id=revision_id)

        # but don't bother fetching if we have the needed data now.

            self.target.has_revision(revision_id)):

            return

        self.target.fetch(self.source, revision_id=revision_id)

        if basis is not None:

            self.target.fetch(basis, revision_id=revision_id)

        # but don't bother fetching if we have the needed data now.

            self.target.has_revision(revision_id)):

            return

        self.target.fetch(self.source, revision_id=revision_id)

        self._formats = formats

    

    def adapt(self, test):

        for repository_format, bzrdir_format in self._formats:

            new_test = deepcopy(test)

            new_test.transport_server = self._transport_server

        self._formats = formats

    

    def adapt(self, test):

        for interrepo_class, repository_format, repository_format_to in self._formats:

            new_test = deepcopy(test)

            new_test.transport_server = self._transport_server

 

        :return: The revision id of the recorded revision.

        """

                       timezone=self._timezone,

                       committer=self._committer,

                       message=message,

 

    def _gen_revision_id(self):

        """Return new revision-id."""

 

    def _generate_revision_if_needed(self):

        """Create a revision id if None was supplied.

        

        If the repository can not support user-specified revision ids

        if _new_revision_id is not None.

 

        """

        if self._new_revision_id is None:

            self._new_revision_id = self._gen_revision_id()

    """Unescape predefined XML entities in a string of data."""

    global _unescape_re

    if _unescape_re is None:

    return _unescape_re.sub(_unescaper, data)