/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/reconfigure.py

  • Committer: John Arbash Meinel
  • Date: 2008-07-09 21:42:24 UTC
  • mto: This revision was merged to the branch mainline in revision 3543.
  • Revision ID: john@arbash-meinel.com-20080709214224-r75k87r6a01pfc3h
Restore a real weave merge to 'bzr merge --weave'.

To do so efficiently, we only add the simple LCAs to the final weave
object, unless we run into complexities with the merge graph.
This gives the same effective result as adding all the texts,
with the advantage of not having to extract all of them.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/reconfigure.py
1
 
# Copyright (C) 2007-2010 Canonical Ltd
 
1
# Copyright (C) 2007 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
 
 
17
 
"""Reconfigure a bzrdir into a new tree/branch/repository layout.
18
 
 
19
 
Various types of reconfiguration operation are available either by
20
 
constructing a class or using a factory method on Reconfigure.
21
 
"""
22
 
 
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
"""Reconfigure a bzrdir into a new tree/branch/repository layout"""
23
18
 
24
19
from bzrlib import (
25
20
    branch,
26
21
    bzrdir,
27
22
    errors,
28
 
    trace,
29
 
    ui,
30
 
    urlutils,
31
23
    )
32
24
 
33
 
 
34
 
# TODO: common base class for all reconfigure operations, making no
35
 
# assumptions about what kind of change will be done.
36
 
 
37
 
 
38
 
class ReconfigureStackedOn(object):
39
 
    """Reconfigures a branch to be stacked on another branch."""
40
 
 
41
 
    def apply(self, bzrdir, stacked_on_url):
42
 
        branch = bzrdir.open_branch()
43
 
        # it may be a path relative to the cwd or a url; the branch wants
44
 
        # a path relative to itself...
45
 
        on_url = urlutils.relative_url(branch.base,
46
 
            urlutils.normalize_url(stacked_on_url))
47
 
        branch.lock_write()
48
 
        try:
49
 
            branch.set_stacked_on_url(on_url)
50
 
            if not trace.is_quiet():
51
 
                ui.ui_factory.note(
52
 
                    "%s is now stacked on %s\n"
53
 
                    % (branch.base, branch.get_stacked_on_url()))
54
 
        finally:
55
 
            branch.unlock()
56
 
 
57
 
 
58
 
class ReconfigureUnstacked(object):
59
 
 
60
 
    def apply(self, bzrdir):
61
 
        branch = bzrdir.open_branch()
62
 
        branch.lock_write()
63
 
        try:
64
 
            branch.set_stacked_on_url(None)
65
 
            if not trace.is_quiet():
66
 
                ui.ui_factory.note(
67
 
                    "%s is now not stacked\n"
68
 
                    % (branch.base,))
69
 
        finally:
70
 
            branch.unlock()
71
 
 
72
 
 
73
25
class Reconfigure(object):
74
26
 
75
27
    def __init__(self, bzrdir, new_bound_location=None):
76
28
        self.bzrdir = bzrdir
77
29
        self.new_bound_location = new_bound_location
78
 
        self.local_repository = None
79
30
        try:
80
31
            self.repository = self.bzrdir.find_repository()
81
32
        except errors.NoRepositoryPresent:
82
33
            self.repository = None
83
 
            self.local_repository = None
84
34
        else:
85
 
            if (self.repository.user_url == self.bzrdir.user_url):
 
35
            if (self.repository.bzrdir.root_transport.base ==
 
36
                self.bzrdir.root_transport.base):
86
37
                self.local_repository = self.repository
87
38
            else:
88
39
                self.local_repository = None
89
40
        try:
90
41
            branch = self.bzrdir.open_branch()
91
 
            if branch.user_url == bzrdir.user_url:
 
42
            if branch.bzrdir.root_transport.base == bzrdir.root_transport.base:
92
43
                self.local_branch = branch
93
44
                self.referenced_branch = None
94
45
            else:
111
62
        self._create_tree = False
112
63
        self._create_repository = False
113
64
        self._destroy_repository = False
114
 
        self._repository_trees = None
115
65
 
116
66
    @staticmethod
117
67
    def to_branch(bzrdir):
190
140
            raise errors.AlreadyStandalone(bzrdir)
191
141
        return reconfiguration
192
142
 
193
 
    @classmethod
194
 
    def set_repository_trees(klass, bzrdir, with_trees):
195
 
        """Adjust a repository's working tree presence default"""
196
 
        reconfiguration = klass(bzrdir)
197
 
        if not reconfiguration.repository.is_shared():
198
 
            raise errors.ReconfigurationNotSupported(reconfiguration.bzrdir)
199
 
        if with_trees and reconfiguration.repository.make_working_trees():
200
 
            raise errors.AlreadyWithTrees(bzrdir)
201
 
        elif (not with_trees
202
 
              and not reconfiguration.repository.make_working_trees()):
203
 
            raise errors.AlreadyWithNoTrees(bzrdir)
204
 
        else:
205
 
            reconfiguration._repository_trees = with_trees
206
 
        return reconfiguration
207
 
 
208
143
    def _plan_changes(self, want_tree, want_branch, want_bound,
209
144
                      want_reference):
210
145
        """Determine which changes are needed to assume the configuration"""
216
151
            if not want_reference:
217
152
                self._create_repository = True
218
153
        else:
219
 
            if want_reference and (
220
 
                self.repository.user_url == self.bzrdir.user_url):
 
154
            if want_reference and (self.repository.bzrdir.root_transport.base
 
155
                                   == self.bzrdir.root_transport.base):
221
156
                if not self.repository.is_shared():
222
157
                    self._destroy_repository = True
223
158
        if self.referenced_branch is None:
264
199
 
265
200
    def _check(self):
266
201
        """Raise if reconfiguration would destroy local changes"""
267
 
        if self._destroy_tree and self.tree.has_changes():
 
202
        if self._destroy_tree:
 
203
            changes = self.tree.changes_from(self.tree.basis_tree())
 
204
            if changes.has_changed():
268
205
                raise errors.UncommittedChanges(self.tree)
269
206
        if self._create_reference and self.local_branch is not None:
270
207
            reference_branch = branch.Branch.open(self._select_bind_location())
315
252
        if not force:
316
253
            self._check()
317
254
        if self._create_repository:
318
 
            if self.local_branch and not self._destroy_branch:
319
 
                old_repo = self.local_branch.repository
320
 
            elif self._create_branch and self.referenced_branch is not None:
321
 
                old_repo = self.referenced_branch.repository
322
 
            else:
323
 
                old_repo = None
324
 
            if old_repo is not None:
325
 
                repository_format = old_repo._format
326
 
            else:
327
 
                repository_format = None
328
 
            if repository_format is not None:
329
 
                repo = repository_format.initialize(self.bzrdir)
330
 
            else:
331
 
                repo = self.bzrdir.create_repository()
 
255
            repo = self.bzrdir.create_repository()
332
256
            if self.local_branch and not self._destroy_branch:
333
257
                repo.fetch(self.local_branch.repository,
334
258
                           self.local_branch.last_revision())
343
267
            if self._create_reference:
344
268
                reference_branch.repository.fetch(self.repository)
345
269
            elif self.local_branch is not None and not self._destroy_branch:
346
 
                up = self.local_branch.user_transport.clone('..')
 
270
                up = self.local_branch.bzrdir.root_transport.clone('..')
347
271
                up_bzrdir = bzrdir.BzrDir.open_containing_from_transport(up)[0]
348
272
                new_repo = up_bzrdir.find_repository()
349
273
                new_repo.fetch(self.repository)
362
286
                local_branch.set_last_revision_info(*last_revision_info)
363
287
            if self._destroy_reference:
364
288
                self.referenced_branch.tags.merge_to(local_branch.tags)
365
 
                self.referenced_branch.update_references(local_branch)
366
289
        else:
367
290
            local_branch = self.local_branch
368
291
        if self._create_reference:
369
292
            format = branch.BranchReferenceFormat().initialize(self.bzrdir,
370
 
                target_branch=reference_branch)
 
293
                reference_branch)
371
294
        if self._destroy_tree:
372
295
            self.bzrdir.destroy_workingtree()
373
296
        if self._create_tree:
379
302
            local_branch.bind(branch.Branch.open(bind_location))
380
303
        if self._destroy_repository:
381
304
            self.bzrdir.destroy_repository()
382
 
        if self._repository_trees is not None:
383
 
            repo.set_make_working_trees(self._repository_trees)