/brz/remove-bazaar

# Copyright (C) 2005, 2006, 2007, 2008 Canonical Ltd

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

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

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

import sys

from bzrlib.lazy_import import lazy_import

lazy_import(globals(), """

from itertools import chain

from bzrlib import (

        bzrdir,

        cache_utf8,

        config as _mod_config,

        debug,

        errors,

        lockdir,

        lockable_files,

        repository,

        revision as _mod_revision,

        transport,

        tsort,

        ui,

        urlutils,

        )

from bzrlib.config import BranchConfig

from bzrlib.repofmt.pack_repo import RepositoryFormatKnitPack5RichRoot

from bzrlib.tag import (

    BasicTags,

    DisabledTags,

    )

""")

from bzrlib.decorators import needs_read_lock, needs_write_lock

from bzrlib.hooks import Hooks

from bzrlib.symbol_versioning import (

    deprecated_in,

    deprecated_method,

    )

from bzrlib.trace import mutter, mutter_callsite, note, is_quiet

BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"

BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"

BZR_BRANCH_FORMAT_6 = "Bazaar Branch Format 6 (bzr 0.15)\n"

# TODO: Maybe include checks for common corruption of newlines, etc?

# TODO: Some operations like log might retrieve the same revisions

# repeatedly to calculate deltas.  We could perhaps have a weakref

# cache in memory to make this faster.  In general anything can be

# cached in memory between lock and unlock operations. .. nb thats

# what the transaction identity map provides

######################################################################

# branch objects

class Branch(object):

    """Branch holding a history of revisions.

    base

        Base directory/url of the branch.

    hooks: An instance of BranchHooks.

    """

    # this is really an instance variable - FIXME move it there

    # - RBC 20060112

    base = None

    # override this to set the strategy for storing tags

    def _make_tags(self):

        return DisabledTags(self)

    def __init__(self, *ignored, **ignored_too):

        self.tags = self._make_tags()

        self._revision_history_cache = None

        self._revision_id_to_revno_cache = None

        self._last_revision_info_cache = None

        self._open_hook()

        hooks = Branch.hooks['open']

        for hook in hooks:

            hook(self)

    def _open_hook(self):

        """Called by init to allow simpler extension of the base class."""

    def break_lock(self):

        """Break a lock if one is present from another instance.

        Uses the ui factory to ask for confirmation if the lock may be from

        an active process.

        This will probe the repository for its lock as well.

        """

        self.control_files.break_lock()

        self.repository.break_lock()

        master = self.get_master_branch()

        if master is not None:

            master.break_lock()

    @staticmethod

    def open(base, _unsupported=False, possible_transports=None):

        """Open the branch rooted at base.

        For instance, if the branch is at URL/.bzr/branch,

        Branch.open(URL) -> a Branch instance.

        """

        control = bzrdir.BzrDir.open(base, _unsupported,

                                     possible_transports=possible_transports)

        return control.open_branch(_unsupported)

    @staticmethod

    def open_from_transport(transport, _unsupported=False):

        """Open the branch rooted at transport"""

        control = bzrdir.BzrDir.open_from_transport(transport, _unsupported)

        return control.open_branch(_unsupported)

    @staticmethod

    def open_containing(url, possible_transports=None):

        """Open an existing branch which contains url.

        This probes for a branch at url, and searches upwards from there.

        Basically we keep looking up until we find the control directory or

        run into the root.  If there isn't one, raises NotBranchError.

        If there is one and it is either an unrecognised format or an unsupported 

        format, UnknownFormatError or UnsupportedFormatError are raised.

        If there is one, it is returned, along with the unused portion of url.

        """

        control, relpath = bzrdir.BzrDir.open_containing(url,

                                                         possible_transports)

        return control.open_branch(), relpath

    def get_config(self):

        return BranchConfig(self)

    def _get_nick(self, possible_transports=None):

        config = self.get_config()

        if not config.has_explicit_nickname(): # explicit overrides master

            try:

                master = self.get_master_branch(possible_transports)

                if master is not None:

                    # return the master branch value

                    return master.nick

            except errors.BzrError, e:

                # Silently fall back to local implicit nick if the master is

                # unavailable

                mutter("Could not connect to bound branch, "

                    "falling back to local nick.\n " + str(e))

        return config.get_nickname()

    def _set_nick(self, nick):

        self.get_config().set_user_option('nickname', nick, warn_masked=True)

    nick = property(_get_nick, _set_nick)

    def is_locked(self):

        raise NotImplementedError(self.is_locked)

    def lock_write(self):

        raise NotImplementedError(self.lock_write)

    def lock_read(self):

        raise NotImplementedError(self.lock_read)

    def unlock(self):

        raise NotImplementedError(self.unlock)

    def peek_lock_mode(self):

        """Return lock mode for the Branch: 'r', 'w' or None"""

        raise NotImplementedError(self.peek_lock_mode)

    def get_physical_lock_status(self):

        raise NotImplementedError(self.get_physical_lock_status)

    @needs_read_lock

    def get_revision_id_to_revno_map(self):

        """Return the revision_id => dotted revno map.

        This will be regenerated on demand, but will be cached.

        :return: A dictionary mapping revision_id => dotted revno.

            This dictionary should not be modified by the caller.

        """

        if self._revision_id_to_revno_cache is not None:

            mapping = self._revision_id_to_revno_cache

        else:

            mapping = self._gen_revno_map()

            self._cache_revision_id_to_revno(mapping)

        # TODO: jam 20070417 Since this is being cached, should we be returning

        #       a copy?

        # I would rather not, and instead just declare that users should not

        # modify the return value.

        return mapping

    def _gen_revno_map(self):

        """Create a new mapping from revision ids to dotted revnos.

        Dotted revnos are generated based on the current tip in the revision

        history.

        This is the worker function for get_revision_id_to_revno_map, which

        just caches the return value.

        :return: A dictionary mapping revision_id => dotted revno.

        """

        last_revision = self.last_revision()

        revision_graph = repository._old_get_graph(self.repository,

            last_revision)

        merge_sorted_revisions = tsort.merge_sort(

            revision_graph,

            last_revision,

            None,

            generate_revno=True)

        revision_id_to_revno = dict((rev_id, revno)

                                    for seq_num, rev_id, depth, revno, end_of_merge

                                     in merge_sorted_revisions)

        return revision_id_to_revno

    def leave_lock_in_place(self):

        """Tell this branch object not to release the physical lock when this

        object is unlocked.

        If lock_write doesn't return a token, then this method is not supported.

        """

        self.control_files.leave_in_place()

    def dont_leave_lock_in_place(self):

        """Tell this branch object to release the physical lock when this

        object is unlocked, even if it didn't originally acquire it.

        If lock_write doesn't return a token, then this method is not supported.

        """

        self.control_files.dont_leave_in_place()

    def bind(self, other):

        """Bind the local branch the other branch.

        :param other: The branch to bind to

        :type other: Branch

        """

        raise errors.UpgradeRequired(self.base)

    @needs_write_lock

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

        """Copy revisions from from_branch into this branch.

        :param from_branch: Where to copy from.

        :param last_revision: What revision to stop at (None for at the end

                              of the branch.

        :param pb: An optional progress bar to use.

        Returns the copied revision count and the failed revisions in a tuple:

        (copied, failures).

        """

        if self.base == from_branch.base:

            return (0, [])

        if pb is None:

            nested_pb = ui.ui_factory.nested_progress_bar()

            pb = nested_pb

        else:

            nested_pb = None

        from_branch.lock_read()

        try:

            if last_revision is None:

                pb.update('get source history')

                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=nested_pb)

        finally:

            if nested_pb is not None:

                nested_pb.finished()

            from_branch.unlock()

    def get_bound_location(self):

        """Return the URL of the branch we are bound to.

        Older format branches cannot bind, please be sure to use a metadir

        branch.

        """

        return None

    def get_old_bound_location(self):

        """Return the URL of the branch we used to be bound to

        """

        raise errors.UpgradeRequired(self.base)

    def get_commit_builder(self, parents, config=None, timestamp=None, 

                           timezone=None, committer=None, revprops=None, 

                           revision_id=None):

        """Obtain a CommitBuilder for this branch.

        :param parents: Revision ids of the parents of the new revision.

        :param config: Optional configuration to use.

        :param timestamp: Optional timestamp recorded for commit.

        :param timezone: Optional timezone for timestamp.

        :param committer: Optional committer to set for commit.

        :param revprops: Optional dictionary of revision properties.

        :param revision_id: Optional revision id.

        """

        if config is None:

            config = self.get_config()

        return self.repository.get_commit_builder(self, parents, config,

            timestamp, timezone, committer, revprops, revision_id)

    def get_master_branch(self, possible_transports=None):

        """Return the branch we are bound to.

        :return: Either a Branch, or None

        """

        return None

    def get_revision_delta(self, revno):

        """Return the delta for one revision.

        The delta is relative to its mainline predecessor, or the

        empty tree for revision 1.

        """

        rh = self.revision_history()

        if not (1 <= revno <= len(rh)):

            raise errors.InvalidRevisionNumber(revno)

        return self.repository.get_revision_delta(rh[revno-1])

    def get_stacked_on_url(self):

        """Get the URL this branch is stacked against.

        :raises NotStacked: If the branch is not stacked.

        :raises UnstackableBranchFormat: If the branch does not support

            stacking.

        """

        raise NotImplementedError(self.get_stacked_on_url)

    def print_file(self, file, revision_id):

        """Print `file` to stdout."""

        raise NotImplementedError(self.print_file)

    def set_revision_history(self, rev_history):

        raise NotImplementedError(self.set_revision_history)

    def set_stacked_on_url(self, url):

        """Set the URL this branch is stacked against.

        :raises UnstackableBranchFormat: If the branch does not support

            stacking.

        :raises UnstackableRepositoryFormat: If the repository does not support

            stacking.

        """

        raise NotImplementedError(self.set_stacked_on_url)

    def _cache_revision_history(self, rev_history):

        """Set the cached revision history to rev_history.

        The revision_history method will use this cache to avoid regenerating

        the revision history.

        This API is semi-public; it only for use by subclasses, all other code

        should consider it to be private.

        """

        self._revision_history_cache = rev_history

    def _cache_revision_id_to_revno(self, revision_id_to_revno):

        """Set the cached revision_id => revno map to revision_id_to_revno.

        This API is semi-public; it only for use by subclasses, all other code

        should consider it to be private.

        """

        self._revision_id_to_revno_cache = revision_id_to_revno

    def _clear_cached_state(self):

        """Clear any cached data on this branch, e.g. cached revision history.

        This means the next call to revision_history will need to call

        _gen_revision_history.

        This API is semi-public; it only for use by subclasses, all other code

        should consider it to be private.

        """

        self._revision_history_cache = None

        self._revision_id_to_revno_cache = None

        self._last_revision_info_cache = None

    def _gen_revision_history(self):

        """Return sequence of revision hashes on to this branch.

        Unlike revision_history, this method always regenerates or rereads the

        revision history, i.e. it does not cache the result, so repeated calls

        may be expensive.

        Concrete subclasses should override this instead of revision_history so

        that subclasses do not need to deal with caching logic.

        This API is semi-public; it only for use by subclasses, all other code

        should consider it to be private.

        """

        raise NotImplementedError(self._gen_revision_history)

    @needs_read_lock

    def revision_history(self):

        """Return sequence of revision ids on this branch.

        This method will cache the revision history for as long as it is safe to

        do so.

        """

        if 'evil' in debug.debug_flags:

            mutter_callsite(3, "revision_history scales with history.")

        if self._revision_history_cache is not None:

            history = self._revision_history_cache

        else:

            history = self._gen_revision_history()

            self._cache_revision_history(history)

        return list(history)

    def revno(self):

        """Return current revision number for this branch.

        That is equivalent to the number of revisions committed to

        this branch.

        """

        return self.last_revision_info()[0]

    def unbind(self):

        """Older format branches cannot bind or unbind."""

        raise errors.UpgradeRequired(self.base)

    def set_append_revisions_only(self, enabled):

        """Older format branches are never restricted to append-only"""

        raise errors.UpgradeRequired(self.base)

    def last_revision(self):

        """Return last revision id, or NULL_REVISION."""

        return self.last_revision_info()[1]

    @needs_read_lock

    def last_revision_info(self):

        """Return information about the last revision.

        :return: A tuple (revno, revision_id).

        """

        if self._last_revision_info_cache is None:

            self._last_revision_info_cache = self._last_revision_info()

        return self._last_revision_info_cache

    def _last_revision_info(self):

        rh = self.revision_history()

        revno = len(rh)

        if revno:

            return (revno, rh[-1])

        else:

            return (0, _mod_revision.NULL_REVISION)

    @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]

    @needs_write_lock

    def update_revisions(self, other, stop_revision=None, overwrite=False,

                         graph=None):

        """Pull in new perfect-fit revisions.

        :param other: Another Branch to pull from

        :param stop_revision: Updated until the given revision

        :param overwrite: Always set the branch pointer, rather than checking

            to see if it is a proper descendant.

        :param graph: A Graph object that can be used to query history

            information. This can be None.

        :return: None

        """

        other.lock_read()

        try:

            other_revno, other_last_revision = other.last_revision_info()

            stop_revno = None # unknown

            if stop_revision is None:

                stop_revision = other_last_revision

                if _mod_revision.is_null(stop_revision):

                    # if there are no commits, we're done.

                    return

                stop_revno = other_revno

            # what's the current last revision, before we fetch [and change it

            # possibly]

            last_rev = _mod_revision.ensure_null(self.last_revision())

            # we fetch here so that we don't process data twice in the common

            # case of having something to pull, and so that the check for 

            # already merged can operate on the just fetched graph, which will

            # be cached in memory.

            self.fetch(other, stop_revision)

            # Check to see if one is an ancestor of the other

            if not overwrite:

                if graph is None:

                    graph = self.repository.get_graph()

                if self._check_if_descendant_or_diverged(

                        stop_revision, last_rev, graph, other):

                    # stop_revision is a descendant of last_rev, but we aren't

                    # overwriting, so we're done.

                    return

            if stop_revno is None:

                if graph is None:

                    graph = self.repository.get_graph()

                this_revno, this_last_revision = self.last_revision_info()

                stop_revno = graph.find_distance_to_null(stop_revision,

                                [(other_last_revision, other_revno),

                                 (this_last_revision, this_revno)])

            self.set_last_revision_info(stop_revno, stop_revision)

        finally:

            other.unlock()

    def revision_id_to_revno(self, revision_id):

        """Given a revision id, return its revno"""

        if _mod_revision.is_null(revision_id):

            return 0

        history = self.revision_history()

        try:

            return history.index(revision_id) + 1

        except ValueError:

            raise errors.NoSuchRevision(self, revision_id)

    def get_rev_id(self, revno, history=None):

        """Find the revision id of the specified revno."""

        if revno == 0:

            return _mod_revision.NULL_REVISION

        if history is None:

            history = self.revision_history()

        if revno <= 0 or revno > len(history):

            raise errors.NoSuchRevision(self, revno)

        return history[revno - 1]

    def pull(self, source, overwrite=False, stop_revision=None,

             possible_transports=None, _override_hook_target=None):

        """Mirror source into this branch.

        This branch is considered to be 'local', having low latency.

        :returns: PullResult instance

        """

        raise NotImplementedError(self.pull)

    def push(self, target, overwrite=False, stop_revision=None):

        """Mirror this branch into target.

        This branch is considered to be 'local', having low latency.

        """

        raise NotImplementedError(self.push)

    def basis_tree(self):

        """Return `Tree` object for last revision."""

        return self.repository.revision_tree(self.last_revision())

    def get_parent(self):

        """Return the parent location of the branch.

        This is the default location for push/pull/missing.  The usual

        pattern is that the user can override it by specifying a

        location.

        """

        raise NotImplementedError(self.get_parent)

    def _set_config_location(self, name, url, config=None,

                             make_relative=False):

        if config is None:

            config = self.get_config()

        if url is None:

            url = ''

        elif make_relative:

            url = urlutils.relative_url(self.base, url)

        config.set_user_option(name, url, warn_masked=True)

    def _get_config_location(self, name, config=None):

        if config is None:

            config = self.get_config()

        location = config.get_user_option(name)

        if location == '':

            location = None

        return location

    def get_submit_branch(self):

        """Return the submit location of the branch.

        This is the default location for bundle.  The usual

        pattern is that the user can override it by specifying a

        location.

        """

        return self.get_config().get_user_option('submit_branch')

    def set_submit_branch(self, location):

        """Return the submit location of the branch.

        This is the default location for bundle.  The usual

        pattern is that the user can override it by specifying a

        location.

        """

        self.get_config().set_user_option('submit_branch', location,

            warn_masked=True)

    def get_public_branch(self):

        """Return the public location of the branch.

        This is is used by merge directives.

        """

        return self._get_config_location('public_branch')

    def set_public_branch(self, location):

        """Return the submit location of the branch.

        This is the default location for bundle.  The usual

        pattern is that the user can override it by specifying a

        location.

        """

        self._set_config_location('public_branch', location)

    def get_push_location(self):

        """Return the None or the location to push this branch to."""

        push_loc = self.get_config().get_user_option('push_location')

        return push_loc

    def set_push_location(self, location):

        """Set a new push location for this branch."""

        raise NotImplementedError(self.set_push_location)

    def set_parent(self, url):

        raise NotImplementedError(self.set_parent)

    @needs_write_lock

    def update(self):

        """Synchronise this branch with the master branch if any. 

        :return: None or the last_revision pivoted out during the update.

        """

        return None

    def check_revno(self, revno):

        """\

        Check whether a revno corresponds to any revision.

        Zero (the NULL revision) is considered valid.

        """

        if revno != 0:

            self.check_real_revno(revno)

    def check_real_revno(self, revno):

        """\

        Check whether a revno corresponds to a real revision.

        Zero (the NULL revision) is considered invalid

        """

        if revno < 1 or revno > self.revno():

            raise errors.InvalidRevisionNumber(revno)

    @needs_read_lock

    def clone(self, to_bzrdir, revision_id=None):

        """Clone this branch into to_bzrdir preserving all semantic values.

        revision_id: if not None, the revision history in the new branch will

                     be truncated to end with revision_id.

        """

        result = to_bzrdir.create_branch()

        self.copy_content_into(result, revision_id=revision_id)

        return  result

    @needs_read_lock

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

        """Create a new line of development from the branch, into to_bzrdir.

        to_bzrdir controls the branch format.

        revision_id: if not None, the revision history in the new branch will

                     be truncated to end with revision_id.

        """

        result = to_bzrdir.create_branch()

        self.copy_content_into(result, revision_id=revision_id)

        result.set_parent(self.bzrdir.root_transport.base)

        return result

    def _synchronize_history(self, destination, revision_id):

        """Synchronize last revision and revision history between branches.

        This version is most efficient when the destination is also a

        BzrBranch6, but works for BzrBranch5, as long as the destination's

        repository contains all the lefthand ancestors of the intended

        last_revision.  If not, set_last_revision_info will fail.

        :param destination: The branch to copy the history into

        :param revision_id: The revision-id to truncate history at.  May

          be None to copy complete history.

        """

        source_revno, source_revision_id = self.last_revision_info()

        if revision_id is None: