~bzr-pqm/bzr/bzr.dev

# Copyright (C) 2005-2010 Canonical Ltd

        controldir,

from bzrlib.repofmt.pack_repo import RepositoryFormatKnitPack5RichRoot

from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises

from bzrlib.hooks import HookPoint, Hooks

 

    hooks: An instance of BranchHooks.

        return self._transport.get_bytes('tags')

    def fetch(self, from_branch, last_revision=None, pb=None):

        :param pb: An optional progress bar to use.

        if self.base == from_branch.base:

            return (0, [])

        if pb is not None:

            symbol_versioning.warn(

                symbol_versioning.deprecated_in((1, 14, 0))

                % "pb parameter to fetch()")

        from_branch.lock_read()

        try:

            if last_revision is None:

                last_revision = from_branch.last_revision()

                last_revision = _mod_revision.ensure_null(last_revision)

            return self.repository.fetch(from_branch.repository,

                                         revision_id=last_revision,

                                         pb=pb)

        finally:

            from_branch.unlock()

        

                    "of %r" % (self.repository,))

                #

                # XXX: This only fetches up to the tip of the repository; it

                # doesn't bring across any tags.  That's fairly consistent

                # with how branch works, but perhaps not ideal.

                self.repository.fetch(old_repository,

                    revision_id=self.last_revision(),

                    find_ghosts=True)

        return _run_with_write_locked_target(self, self._transport.put_bytes,

            'tags', bytes)

    @deprecated_method(deprecated_in((1, 6, 0)))

    def missing_revisions(self, other, stop_revision=None):

        """Return a list of new revisions that would perfectly fit.

 

        If self and other have not diverged, return a list of the revisions

        present in other, but missing from self.

        """

        self_history = self.revision_history()

        self_len = len(self_history)

        other_history = other.revision_history()

        other_len = len(other_history)

        common_index = min(self_len, other_len) -1

        if common_index >= 0 and \

            self_history[common_index] != other_history[common_index]:

            raise errors.DivergedBranches(self, other)

 

        if stop_revision is None:

            stop_revision = other_len

        else:

            if stop_revision > other_len:

                raise errors.NoSuchRevision(self, stop_revision)

        return other_history[self_len:stop_revision]

 

                         graph=None):

            overwrite, graph)

        This is used by the bound branch code to upload a revision to

        the master branch first before updating the tip of the local branch.

 

    def sprout(self, to_bzrdir, revision_id=None, repository_policy=None):

        result = to_bzrdir.create_branch()

        if isinstance(self.bzrdir, bzrdir.BzrDirPreSplitOut):

            from bzrlib.repofmt import weaverepo

            format = bzrdir.BzrDirMetaFormat1()

            format.repository_format = weaverepo.RepositoryFormat7()

        else:

            format = self.repository.bzrdir.checkout_metadir()

            format.set_branch_format(self._format)

 

class BranchFormat(object):

    _default_format = None

    """The default format used for new branches."""

 

    _formats = {}

    """The known formats."""

 

            format = klass._formats[format_string]

            if isinstance(format, MetaDirBranchFormatFactory):

                return format()

            return format

        return klass._default_format

        result = []

        for fmt in klass._formats.values():

            if isinstance(fmt, MetaDirBranchFormatFactory):

                fmt = fmt()

            result.append(fmt)

        return result

    def _initialize_helper(self, a_bzrdir, utf8_files, name=None,

                           lock_type='metadir', set_format=True):

        """Initialize a branch in a bzrdir, with specified files

 

        :param a_bzrdir: The bzrdir to initialize the branch in

        :param utf8_files: The files to create as a list of

            (filename, content) tuples

        :param name: Name of colocated branch to create, if any

        :param set_format: If True, set the format with

            self.get_format_string.  (BzrBranch4 has its format set

            elsewhere)

        :return: a branch in this format

        """

        mutter('creating branch %r in %s', self, a_bzrdir.user_url)

        branch_transport = a_bzrdir.get_branch_transport(self, name=name)

        lock_map = {

            'metadir': ('lock', lockdir.LockDir),

            'branch4': ('branch-lock', lockable_files.TransportLock),

        }

        lock_name, lock_class = lock_map[lock_type]

        control_files = lockable_files.LockableFiles(branch_transport,

            lock_name, lock_class)

        control_files.create_lock()

        try:

            control_files.lock_write()

        except errors.LockContention:

            if lock_type != 'branch4':

                raise

            lock_taken = False

        else:

            lock_taken = True

        if set_format:

            utf8_files += [('format', self.get_format_string())]

        try:

            for (filename, content) in utf8_files:

                branch_transport.put_bytes(

                    filename, content,

                    mode=a_bzrdir._get_file_mode())

        finally:

            if lock_taken:

                control_files.unlock()

        branch = self.open(a_bzrdir, name, _found=True)

        self._run_post_branch_init_hooks(a_bzrdir, name, branch)

        return branch

 

    def initialize(self, a_bzrdir, name=None):

    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):

        

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

        # Metadir formats have a network name of their format string, and get

        # registered as factories.

        if isinstance(format, MetaDirBranchFormatFactory):

            network_format_registry.register(format.get_format_string(), format)

        else:

            network_format_registry.register(format.get_format_string(),

                format.__class__)

        klass._default_format = format

        del klass._formats[format.get_format_string()]

        Hooks.__init__(self)

        self.create_hook(HookPoint('set_rh',

            "hook to use is Branch.post_change_branch_tip.", (0, 15), None))

        self.create_hook(HookPoint('open',

            "branch is opened.", (1, 8), None))

        self.create_hook(HookPoint('post_push',

            "bzr client.", (0, 15), None))

        self.create_hook(HookPoint('post_pull',

            "bzr client.", (0, 15), None))

        self.create_hook(HookPoint('pre_commit',

            "tree.", (0,91), None))

        self.create_hook(HookPoint('post_commit',

            "commit to a branch.", (0, 15), None))

        self.create_hook(HookPoint('post_uncommit',

            "receives new_revno of 0, new_revid of None.", (0, 15), None))

        self.create_hook(HookPoint('pre_change_branch_tip',

            "commit, uncommit will all trigger this hook.", (1, 6), None))

        self.create_hook(HookPoint('post_change_branch_tip',

            "commit, uncommit will all trigger this hook.", (1, 4), None))

        self.create_hook(HookPoint('transform_fallback_location',

            "The order is however undefined.", (1, 9), None))

        self.create_hook(HookPoint('automatic_tag_name',

            (2, 2), None))

        self.create_hook(HookPoint('post_branch_init',

            "lightweight) will all trigger this hook.", (2, 2), None))

        self.create_hook(HookPoint('post_switch',

            "bzrlib.branch.SwitchHookParams.", (2, 2), None))

class BzrBranchFormat4(BranchFormat):

    """Bzr branch format 4.

 

    This format has:

     - a revision-history file.

     - a branch-lock lock file [ to be shared with the bzrdir ]

    """

 

    def get_format_description(self):

        """See BranchFormat.get_format_description()."""

        return "Branch format 4"

 

    def initialize(self, a_bzrdir, name=None):

        """Create a branch of this format in a_bzrdir."""

        utf8_files = [('revision-history', ''),

                      ('branch-name', ''),

                      ]

        return self._initialize_helper(a_bzrdir, utf8_files, name=name,

                                       lock_type='branch4', set_format=False)

 

    def __init__(self):

        super(BzrBranchFormat4, self).__init__()

        self._matchingbzrdir = bzrdir.BzrDirFormat6()

 

    def network_name(self):

        """The network name for this format is the control dirs disk label."""

        return self._matchingbzrdir.get_format_string()

 

    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):

        """See BranchFormat.open()."""

        if not _found:

            # we are being called directly and must probe.

            raise NotImplementedError

        return BzrBranch(_format=self,

                         _control_files=a_bzrdir._control_files,

                         a_bzrdir=a_bzrdir,

                         name=name,

                         _repository=a_bzrdir.open_repository())

 

    def __str__(self):

        return "Bazaar-NG branch format 4"

 

 

    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):

                              _repository=a_bzrdir.find_repository(),

    def initialize(self, a_bzrdir, name=None):

        return self._initialize_helper(a_bzrdir, utf8_files, name)

    def initialize(self, a_bzrdir, name=None):

        return self._initialize_helper(a_bzrdir, utf8_files, name)

    def initialize(self, a_bzrdir, name=None):

        return self._initialize_helper(a_bzrdir, utf8_files, name)

 

    def __init__(self):

        super(BzrBranchFormat8, self).__init__()

        self._matchingbzrdir.repository_format = \

            RepositoryFormatKnitPack5RichRoot()

class BzrBranchFormat7(BzrBranchFormat8):

    def initialize(self, a_bzrdir, name=None):

        return self._initialize_helper(a_bzrdir, utf8_files, name)

    def initialize(self, a_bzrdir, name=None, target_branch=None):

             possible_transports=None, ignore_fallbacks=False):

BranchFormat.register_format(__format5)

BranchFormat.register_format(BranchReferenceFormat())

BranchFormat.register_format(__format6)

BranchFormat.register_format(__format7)

BranchFormat.register_format(__format8)

BranchFormat.set_default_format(__format7)

_legacy_formats = [BzrBranchFormat4(),

    ]

network_format_registry.register(

    _legacy_formats[0].network_name(), _legacy_formats[0].__class__)

        if result.old_revid != self.last_revision():

            result.tag_conflicts = self.tags.merge_to(target.tags,

                overwrite)

 

        This could memoise the branch, but if thats done

        it must be revalidated on each new lock.

        So for now we just don't memoise it.

        # RBC 20060304 review this decision.

            self._extend_partial_history(stop_revision=revision_id)

                         graph=None):

        return [(BranchFormat._default_format, BranchFormat._default_format)]

        return format                                                                                                  

        graph=None):

        self.target.fetch(self.source, stop_revision)

        if not local and bound_location and self.source.user_url != bound_location:

                _override_hook_target=_override_hook_target)

             _override_hook_target=None, local=False):

                overwrite)