← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/branchbuilder.py

  • Committer: Martin Pool
  • Date: 2009-01-13 03:11:04 UTC
  • mto: This revision was merged to the branch mainline in revision 3937.
  • Revision ID: mbp@sourcefrog.net-20090113031104-03my054s02i9l2pe
Bump version to 1.12 and add news template

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/branchbuilder.py
1
 
# Copyright (C) 2007, 2008, 2009 Canonical Ltd
 
1
# Copyright (C) 2007, 2008 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
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""Utility for create branches with particular contents."""
18
18
 
19
19
from bzrlib import (
20
 
    bzrdir,
 
20
    bzrdir, 
21
21
    commit,
22
22
    errors,
23
23
    memorytree,
26
26
 
27
27
class BranchBuilder(object):
28
28
    r"""A BranchBuilder aids creating Branches with particular shapes.
29
 
 
 
29
    
30
30
    The expected way to use BranchBuilder is to construct a
31
31
    BranchBuilder on the transport you want your branch on, and then call
32
32
    appropriate build_ methods on it to get the shape of history you want.
56
56
        a series in progress, it should be None.
57
57
    """
58
58
 
59
 
    def __init__(self, transport=None, format=None, branch=None):
 
59
    def __init__(self, transport, format=None):
60
60
        """Construct a BranchBuilder on transport.
61
 
 
 
61
        
62
62
        :param transport: The transport the branch should be created on.
63
63
            If the path of the transport does not exist but its parent does
64
64
            it will be created.
65
65
        :param format: Either a BzrDirFormat, or the name of a format in the
66
66
            bzrdir format registry for the branch to be built.
67
 
        :param branch: An already constructed branch to use.  This param is
68
 
            mutually exclusive with the transport and format params.
69
67
        """
70
 
        if branch is not None:
71
 
            if format is not None:
72
 
                raise AssertionError(
73
 
                    "branch and format kwargs are mutually exclusive")
74
 
            if transport is not None:
75
 
                raise AssertionError(
76
 
                    "branch and transport kwargs are mutually exclusive")
77
 
            self._branch = branch
78
 
        else:
79
 
            if not transport.has('.'):
80
 
                transport.mkdir('.')
81
 
            if format is None:
82
 
                format = 'default'
83
 
            if isinstance(format, str):
84
 
                format = bzrdir.format_registry.make_bzrdir(format)
85
 
            self._branch = bzrdir.BzrDir.create_branch_convenience(
86
 
                transport.base, format=format, force_new_tree=False)
 
68
        if not transport.has('.'):
 
69
            transport.mkdir('.')
 
70
        if format is None:
 
71
            format = 'default'
 
72
        if isinstance(format, str):
 
73
            format = bzrdir.format_registry.make_bzrdir(format)
 
74
        self._branch = bzrdir.BzrDir.create_branch_convenience(transport.base,
 
75
            format=format, force_new_tree=False)
87
76
        self._tree = None
88
77
 
89
 
    def build_commit(self, **commit_kwargs):
90
 
        """Build a commit on the branch.
91
 
 
92
 
        This makes a commit with no real file content for when you only want
93
 
        to look at the revision graph structure.
94
 
 
95
 
        :param commit_kwargs: Arguments to pass through to commit, such as
96
 
             timestamp.
97
 
        """
 
78
    def build_commit(self):
 
79
        """Build a commit on the branch."""
98
80
        tree = memorytree.MemoryTree.create_on_branch(self._branch)
99
81
        tree.lock_write()
100
82
        try:
101
83
            tree.add('')
102
 
            return self._do_commit(tree, **commit_kwargs)
 
84
            return self._do_commit(tree)
103
85
        finally:
104
86
            tree.unlock()
105
87
 
106
 
    def _do_commit(self, tree, message=None, message_callback=None, **kwargs):
 
88
    def _do_commit(self, tree, message=None, **kwargs):
107
89
        reporter = commit.NullCommitReporter()
108
 
        if message is None and message_callback is None:
 
90
        if message is None:
109
91
            message = u'commit %d' % (self._branch.revno() + 1,)
110
 
        return tree.commit(message, message_callback=message_callback,
 
92
        return tree.commit(message,
111
93
            reporter=reporter,
112
94
            **kwargs)
113
95
 
114
 
    def _move_branch_pointer(self, new_revision_id,
115
 
        allow_leftmost_as_ghost=False):
 
96
    def _move_branch_pointer(self, new_revision_id):
116
97
        """Point self._branch to a different revision id."""
117
98
        self._branch.lock_write()
118
99
        try:
119
100
            # We don't seem to have a simple set_last_revision(), so we
120
101
            # implement it here.
121
102
            cur_revno, cur_revision_id = self._branch.last_revision_info()
122
 
            try:
123
 
                g = self._branch.repository.get_graph()
124
 
                new_revno = g.find_distance_to_null(new_revision_id,
125
 
                    [(cur_revision_id, cur_revno)])
126
 
                self._branch.set_last_revision_info(new_revno, new_revision_id)
127
 
            except errors.GhostRevisionsHaveNoRevno:
128
 
                if not allow_leftmost_as_ghost:
129
 
                    raise
130
 
                new_revno = 1
 
103
            g = self._branch.repository.get_graph()
 
104
            new_revno = g.find_distance_to_null(new_revision_id,
 
105
                                                [(cur_revision_id, cur_revno)])
 
106
            self._branch.set_last_revision_info(new_revno, new_revision_id)
131
107
        finally:
132
108
            self._branch.unlock()
133
109
        if self._tree is not None:
161
137
        self._tree = None
162
138
 
163
139
    def build_snapshot(self, revision_id, parent_ids, actions,
164
 
        message=None, timestamp=None, allow_leftmost_as_ghost=False,
165
 
        committer=None, timezone=None, message_callback=None):
 
140
                       message=None):
166
141
        """Build a commit, shaped in a specific way.
167
142
 
168
143
        :param revision_id: The handle for the new commit, can be None
175
150
            ('rename', ('orig-path', 'new-path'))
176
151
        :param message: An optional commit message, if not supplied, a default
177
152
            commit message will be written.
178
 
        :param message_callback: A message callback to use for the commit, as
179
 
            per mutabletree.commit.
180
 
        :param timestamp: If non-None, set the timestamp of the commit to this
181
 
            value.
182
 
        :param timezone: An optional timezone for timestamp.
183
 
        :param committer: An optional username to use for commit
184
 
        :param allow_leftmost_as_ghost: True if the leftmost parent should be
185
 
            permitted to be a ghost.
186
153
        :return: The revision_id of the new commit
187
154
        """
188
155
        if parent_ids is not None:
189
156
            base_id = parent_ids[0]
190
157
            if base_id != self._branch.last_revision():
191
 
                self._move_branch_pointer(base_id,
192
 
                    allow_leftmost_as_ghost=allow_leftmost_as_ghost)
 
158
                self._move_branch_pointer(base_id)
193
159
 
194
160
        if self._tree is not None:
195
161
            tree = self._tree
198
164
        tree.lock_write()
199
165
        try:
200
166
            if parent_ids is not None:
201
 
                tree.set_parent_ids(parent_ids,
202
 
                    allow_leftmost_as_ghost=allow_leftmost_as_ghost)
 
167
                tree.set_parent_ids(parent_ids)
203
168
            # Unfortunately, MemoryTree.add(directory) just creates an
204
169
            # inventory entry. And the only public function to create a
205
170
            # directory is MemoryTree.mkdir() which creates the directory, but
245
210
            tree.add(to_add_files, to_add_file_ids, to_add_kinds)
246
211
            for file_id, content in new_contents.iteritems():
247
212
                tree.put_file_bytes_non_atomic(file_id, content)
248
 
            return self._do_commit(tree, message=message, rev_id=revision_id,
249
 
                timestamp=timestamp, timezone=timezone, committer=committer,
250
 
                message_callback=message_callback)
 
213
            return self._do_commit(tree, message=message, rev_id=revision_id) 
251
214
        finally:
252
215
            tree.unlock()
253
216