/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/memorytree.py

merge bzr.dev.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/memorytree.py
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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
"""MemoryTree object.
18
18
 
20
20
"""
21
21
 
22
22
 
23
 
from copy import deepcopy
 
23
import os
24
24
 
25
25
from bzrlib import (
26
26
    errors,
27
27
    mutabletree,
 
28
    osutils,
28
29
    revision as _mod_revision,
29
30
    )
30
31
from bzrlib.decorators import needs_read_lock, needs_write_lock
35
36
 
36
37
class MemoryTree(mutabletree.MutableTree):
37
38
    """A MemoryTree is a specialisation of MutableTree.
38
 
    
 
39
 
39
40
    It maintains nearly no state outside of read_lock and write_lock
40
41
    transactions. (it keeps a reference to the branch, and its last-revision
41
42
    only).
68
69
    def create_on_branch(branch):
69
70
        """Create a MemoryTree for branch, using the last-revision of branch."""
70
71
        revision_id = _mod_revision.ensure_null(branch.last_revision())
71
 
        if _mod_revision.is_null(revision_id):
72
 
            revision_id = None
73
72
        return MemoryTree(branch, revision_id)
74
73
 
75
74
    def _gather_kinds(self, files, kinds):
76
75
        """See MutableTree._gather_kinds.
77
 
        
 
76
 
78
77
        This implementation does not care about the file kind of
79
78
        missing files, so is a no-op.
80
79
        """
81
80
 
82
 
    def get_file(self, file_id):
 
81
    def get_file(self, file_id, path=None):
83
82
        """See Tree.get_file."""
84
 
        return self._file_transport.get(self.id2path(file_id))
 
83
        if path is None:
 
84
            path = self.id2path(file_id)
 
85
        return self._file_transport.get(path)
85
86
 
86
87
    def get_file_sha1(self, file_id, path=None, stat_value=None):
87
88
        """See Tree.get_file_sha1()."""
90
91
        stream = self._file_transport.get(path)
91
92
        return sha_file(stream)
92
93
 
 
94
    def get_root_id(self):
 
95
        return self.path2id('')
 
96
 
93
97
    def _comparison_data(self, entry, path):
94
98
        """See Tree._comparison_data."""
95
99
        if entry is None:
96
100
            return None, False, None
97
101
        return entry.kind, entry.executable, None
98
102
 
 
103
    @needs_tree_write_lock
 
104
    def rename_one(self, from_rel, to_rel):
 
105
        file_id = self.path2id(from_rel)
 
106
        to_dir, to_tail = os.path.split(to_rel)
 
107
        to_parent_id = self.path2id(to_dir)
 
108
        self._file_transport.move(from_rel, to_rel)
 
109
        self._inventory.rename(file_id, to_parent_id, to_tail)
 
110
 
 
111
    def path_content_summary(self, path):
 
112
        """See Tree.path_content_summary."""
 
113
        id = self.path2id(path)
 
114
        if id is None:
 
115
            return 'missing', None, None, None
 
116
        kind = self.kind(id)
 
117
        if kind == 'file':
 
118
            bytes = self._file_transport.get_bytes(path)
 
119
            size = len(bytes)
 
120
            executable = self._inventory[id].executable
 
121
            sha1 = None # no stat cache
 
122
            return (kind, size, executable, sha1)
 
123
        elif kind == 'directory':
 
124
            # memory tree does not support nested trees yet.
 
125
            return kind, None, None, None
 
126
        elif kind == 'symlink':
 
127
            raise NotImplementedError('symlink support')
 
128
        else:
 
129
            raise NotImplementedError('unknown kind')
 
130
 
99
131
    def _file_size(self, entry, stat_value):
100
132
        """See Tree._file_size."""
101
133
        if entry is None:
179
211
 
180
212
    def _populate_from_branch(self):
181
213
        """Populate the in-tree state from the branch."""
182
 
        self._basis_tree = self.branch.repository.revision_tree(
183
 
            self._branch_revision_id)
184
 
        if self._branch_revision_id is None:
 
214
        self._set_basis()
 
215
        if self._branch_revision_id == _mod_revision.NULL_REVISION:
185
216
            self._parent_ids = []
186
217
        else:
187
218
            self._parent_ids = [self._branch_revision_id]
188
 
        self._inventory = deepcopy(self._basis_tree._inventory)
 
219
        self._inventory = self._basis_tree._inventory._get_mutable_inventory()
189
220
        self._file_transport = MemoryTransport()
190
221
        # TODO copy the revision trees content, or do it lazy, or something.
191
222
        inventory_entries = self._inventory.iter_entries()
247
278
            _mod_revision.check_not_reserved_id(revision_id)
248
279
        if len(revision_ids) == 0:
249
280
            self._parent_ids = []
250
 
            self._basis_tree = self.branch.repository.revision_tree(None)
 
281
            self._branch_revision_id = _mod_revision.NULL_REVISION
251
282
        else:
252
283
            self._parent_ids = revision_ids
253
 
            self._basis_tree = self.branch.repository.revision_tree(
254
 
                                    revision_ids[0])
255
284
            self._branch_revision_id = revision_ids[0]
 
285
        self._allow_leftmost_as_ghost = allow_leftmost_as_ghost
 
286
        self._set_basis()
 
287
    
 
288
    def _set_basis(self):
 
289
        try:
 
290
            self._basis_tree = self.branch.repository.revision_tree(
 
291
                self._branch_revision_id)
 
292
        except errors.NoSuchRevision:
 
293
            if self._allow_leftmost_as_ghost:
 
294
                self._basis_tree = self.branch.repository.revision_tree(
 
295
                    _mod_revision.NULL_REVISION)
 
296
            else:
 
297
                raise
256
298
 
257
299
    def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
258
300
        """See MutableTree.set_parent_trees()."""
259
301
        if len(parents_list) == 0:
260
302
            self._parent_ids = []
261
 
            self._basis_tree = self.branch.repository.revision_tree(None)
 
303
            self._basis_tree = self.branch.repository.revision_tree(
 
304
                                   _mod_revision.NULL_REVISION)
262
305
        else:
263
306
            if parents_list[0][1] is None and not allow_leftmost_as_ghost:
264
307
                # a ghost in the left most parent
265
308
                raise errors.GhostRevisionUnusableHere(parents_list[0][0])
266
309
            self._parent_ids = [parent_id for parent_id, tree in parents_list]
267
310
            if parents_list[0][1] is None or parents_list[0][1] == 'null:':
268
 
                import pdb; pdb.set_trace()
269
 
                self._basis_tree = self.branch.repository.revision_tree(None)
 
311
                self._basis_tree = self.branch.repository.revision_tree(
 
312
                                       _mod_revision.NULL_REVISION)
270
313
            else:
271
314
                self._basis_tree = parents_list[0][1]
272
315
            self._branch_revision_id = parents_list[0][0]