~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tree.py

  • Committer: Martin Pool
  • Date: 2006-09-28 05:43:24 UTC
  • mto: This revision was merged to the branch mainline in revision 2051.
  • Revision ID: mbp@sourcefrog.net-20060928054324-72aebdcd6b540449
Load python2.5's ElementTree if present

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
1
# Copyright (C) 2005 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
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
 
 
7
#
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
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
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19
19
 
20
20
import os
21
21
from cStringIO import StringIO
 
22
from warnings import warn
22
23
 
23
24
import bzrlib
 
25
from bzrlib import delta
 
26
from bzrlib.decorators import needs_read_lock
24
27
from bzrlib.errors import BzrError, BzrCheckError
25
28
from bzrlib import errors
26
29
from bzrlib.inventory import Inventory
 
30
from bzrlib.inter import InterObject
27
31
from bzrlib.osutils import fingerprint_file
28
32
import bzrlib.revision
29
33
from bzrlib.trace import mutter, note
30
34
 
 
35
 
31
36
class Tree(object):
32
37
    """Abstract file tree.
33
38
 
37
42
 
38
43
    * `RevisionTree` is a tree as recorded at some point in the past.
39
44
 
40
 
    * `EmptyTree`
41
 
 
42
45
    Trees contain an `Inventory` object, and also know how to retrieve
43
46
    file texts mentioned in the inventory, either from a working
44
47
    directory or from a store.
50
53
    trees or versioned trees.
51
54
    """
52
55
    
 
56
    def changes_from(self, other, want_unchanged=False, specific_files=None,
 
57
        extra_trees=None, require_versioned=False):
 
58
        """Return a TreeDelta of the changes from other to this tree.
 
59
 
 
60
        :param other: A tree to compare with.
 
61
        :param specific_files: An optional list of file paths to restrict the
 
62
            comparison to. When mapping filenames to ids, all matches in all
 
63
            trees (including optional extra_trees) are used, and all children of
 
64
            matched directories are included.
 
65
        :param want_unchanged: An optional boolean requesting the inclusion of
 
66
            unchanged entries in the result.
 
67
        :param extra_trees: An optional list of additional trees to use when
 
68
            mapping the contents of specific_files (paths) to file_ids.
 
69
        :param require_versioned: An optional boolean (defaults to False). When
 
70
            supplied and True all the 'specific_files' must be versioned, or
 
71
            a PathsNotVersionedError will be thrown.
 
72
 
 
73
        The comparison will be performed by an InterTree object looked up on 
 
74
        self and other.
 
75
        """
 
76
        # Martin observes that Tree.changes_from returns a TreeDelta and this
 
77
        # may confuse people, because the class name of the returned object is
 
78
        # a synonym of the object referenced in the method name.
 
79
        return InterTree.get(other, self).compare(
 
80
            want_unchanged=want_unchanged,
 
81
            specific_files=specific_files,
 
82
            extra_trees=extra_trees,
 
83
            require_versioned=require_versioned,
 
84
            )
 
85
    
53
86
    def conflicts(self):
54
87
        """Get a list of the conflicts in the tree.
55
88
 
73
106
    def has_id(self, file_id):
74
107
        return self.inventory.has_id(file_id)
75
108
 
 
109
    __contains__ = has_id
 
110
 
76
111
    def has_or_had_id(self, file_id):
77
112
        if file_id == self.inventory.root.file_id:
78
113
            return True
79
114
        return self.inventory.has_id(file_id)
80
115
 
81
 
    __contains__ = has_id
82
 
 
83
116
    def __iter__(self):
84
117
        return iter(self.inventory)
85
118
 
86
119
    def id2path(self, file_id):
87
120
        return self.inventory.id2path(file_id)
88
121
 
 
122
    def is_control_filename(self, filename):
 
123
        """True if filename is the name of a control file in this tree.
 
124
        
 
125
        :param filename: A filename within the tree. This is a relative path
 
126
        from the root of this tree.
 
127
 
 
128
        This is true IF and ONLY IF the filename is part of the meta data
 
129
        that bzr controls in this tree. I.E. a random .bzr directory placed
 
130
        on disk will not be a control file for this tree.
 
131
        """
 
132
        return self.bzrdir.is_control_filename(filename)
 
133
 
 
134
    def iter_entries_by_dir(self):
 
135
        """Walk the tree in 'by_dir' order.
 
136
 
 
137
        This will yield each entry in the tree as a (path, entry) tuple. The
 
138
        order that they are yielded is: the contents of a directory are 
 
139
        preceeded by the parent of a directory, and all the contents of a 
 
140
        directory are grouped together.
 
141
        """
 
142
        return self.inventory.iter_entries_by_dir()
 
143
 
89
144
    def kind(self, file_id):
90
145
        raise NotImplementedError("subclasses must implement kind")
91
146
 
92
147
    def _get_inventory(self):
93
148
        return self._inventory
94
149
    
 
150
    def get_file(self, file_id):
 
151
        """Return a file object for the file file_id in the tree."""
 
152
        raise NotImplementedError(self.get_file)
 
153
    
95
154
    def get_file_by_path(self, path):
96
155
        return self.get_file(self._inventory.path2id(path))
97
156
 
104
163
        fp = fingerprint_file(f)
105
164
        f.seek(0)
106
165
        
107
 
        if ie.text_size != None:
 
166
        if ie.text_size is not None:
108
167
            if ie.text_size != fp['size']:
109
168
                raise BzrError("mismatched size for file %r in %r" % (ie.file_id, self._store),
110
169
                        ["inventory expects %d bytes" % ie.text_size,
117
176
                     "file is actually %s" % fp['sha1'],
118
177
                     "store is probably damaged/corrupt"])
119
178
 
 
179
    def path2id(self, path):
 
180
        """Return the id for path in this tree."""
 
181
        return self._inventory.path2id(path)
120
182
 
121
183
    def print_file(self, file_id):
122
184
        """Print file with id `file_id` to stdout."""
146
208
        # are not versioned.
147
209
        pred = self.inventory.has_filename
148
210
        return set((p for p in paths if not pred(p)))
149
 
        
150
 
        
151
 
class RevisionTree(Tree):
152
 
    """Tree viewing a previous revision.
153
 
 
154
 
    File text can be retrieved from the text store.
155
 
 
156
 
    TODO: Some kind of `__repr__` method, but a good one
157
 
           probably means knowing the branch and revision number,
158
 
           or at least passing a description to the constructor.
159
 
    """
160
 
    
161
 
    def __init__(self, branch, inv, revision_id):
162
 
        # for compatability the 'branch' parameter has not been renamed to 
163
 
        # repository at this point. However, we should change RevisionTree's
164
 
        # construction to always be via Repository and not via direct 
165
 
        # construction - this will mean that we can change the constructor
166
 
        # with much less chance of breaking client code.
167
 
        self._repository = branch
168
 
        self._weave_store = branch.weave_store
169
 
        self._inventory = inv
170
 
        self._revision_id = revision_id
171
 
 
172
 
    def get_parent_ids(self):
173
 
        """See Tree.get_parent_ids.
174
 
 
175
 
        A RevisionTree's parents match the revision graph.
176
 
        """
177
 
        parent_ids = self._repository.get_revision(self._revision_id).parent_ids
178
 
        return parent_ids
179
 
        
180
 
    def get_revision_id(self):
181
 
        """Return the revision id associated with this tree."""
182
 
        return self._revision_id
183
 
 
184
 
    def get_weave(self, file_id):
185
 
        return self._weave_store.get_weave(file_id,
186
 
                self._repository.get_transaction())
187
 
 
188
 
    def get_file_lines(self, file_id):
189
 
        ie = self._inventory[file_id]
190
 
        weave = self.get_weave(file_id)
191
 
        return weave.get_lines(ie.revision)
192
 
 
193
 
    def get_file_text(self, file_id):
194
 
        return ''.join(self.get_file_lines(file_id))
195
 
 
196
 
    def get_file(self, file_id):
197
 
        return StringIO(self.get_file_text(file_id))
198
 
 
199
 
    def get_file_size(self, file_id):
200
 
        return self._inventory[file_id].text_size
201
 
 
202
 
    def get_file_sha1(self, file_id, path=None):
203
 
        ie = self._inventory[file_id]
204
 
        if ie.kind == "file":
205
 
            return ie.text_sha1
206
 
        return None
207
 
 
208
 
    def get_file_mtime(self, file_id, path=None):
209
 
        ie = self._inventory[file_id]
210
 
        revision = self._repository.get_revision(ie.revision)
211
 
        return revision.timestamp
212
 
 
213
 
    def is_executable(self, file_id, path=None):
214
 
        ie = self._inventory[file_id]
215
 
        if ie.kind != "file":
216
 
            return None 
217
 
        return self._inventory[file_id].executable
218
 
 
219
 
    def has_filename(self, filename):
220
 
        return bool(self.inventory.path2id(filename))
221
 
 
222
 
    def list_files(self):
223
 
        # The only files returned by this are those from the version
224
 
        for path, entry in self.inventory.iter_entries():
225
 
            yield path, 'V', entry.kind, entry.file_id, entry
226
 
 
227
 
    def get_symlink_target(self, file_id):
228
 
        ie = self._inventory[file_id]
229
 
        return ie.symlink_target;
230
 
 
231
 
    def kind(self, file_id):
232
 
        return self._inventory[file_id].kind
233
 
 
234
 
    def lock_read(self):
235
 
        self._repository.lock_read()
236
 
 
237
 
    def unlock(self):
238
 
        self._repository.unlock()
239
 
 
 
211
 
 
212
 
 
213
# for compatibility
 
214
from bzrlib.revisiontree import RevisionTree
 
215
 
240
216
 
241
217
class EmptyTree(Tree):
242
218
 
243
219
    def __init__(self):
244
220
        self._inventory = Inventory()
 
221
        warn('EmptyTree is deprecated as of bzr 0.9 please use '
 
222
            'repository.revision_tree instead.',
 
223
            DeprecationWarning, stacklevel=2)
245
224
 
246
225
    def get_parent_ids(self):
247
 
        """See Tree.get_parent_ids.
248
 
 
249
 
        An EmptyTree always has NULL_REVISION as the only parent.
250
 
        """
251
226
        return []
252
227
 
253
228
    def get_symlink_target(self, file_id):
257
232
        return False
258
233
 
259
234
    def kind(self, file_id):
260
 
        assert self._inventory[file_id].kind == "root_directory"
261
 
        return "root_directory"
 
235
        assert self._inventory[file_id].kind == "directory"
 
236
        return "directory"
262
237
 
263
238
    def list_files(self):
264
239
        return iter([])
265
240
    
266
241
    def __contains__(self, file_id):
267
 
        return file_id in self._inventory
 
242
        return (file_id in self._inventory)
268
243
 
269
244
    def get_file_sha1(self, file_id, path=None):
270
 
        assert self._inventory[file_id].kind == "root_directory"
271
245
        return None
272
246
 
273
247
 
407
381
        interesting_ids.update(new_pending)
408
382
        pending = new_pending
409
383
    return interesting_ids
 
384
 
 
385
 
 
386
class InterTree(InterObject):
 
387
    """This class represents operations taking place between two Trees.
 
388
 
 
389
    Its instances have methods like 'compare' and contain references to the
 
390
    source and target trees these operations are to be carried out on.
 
391
 
 
392
    clients of bzrlib should not need to use InterTree directly, rather they
 
393
    should use the convenience methods on Tree such as 'Tree.compare()' which
 
394
    will pass through to InterTree as appropriate.
 
395
    """
 
396
 
 
397
    _optimisers = []
 
398
 
 
399
    @needs_read_lock
 
400
    def compare(self, want_unchanged=False, specific_files=None,
 
401
        extra_trees=None, require_versioned=False):
 
402
        """Return the changes from source to target.
 
403
 
 
404
        :return: A TreeDelta.
 
405
        :param specific_files: An optional list of file paths to restrict the
 
406
            comparison to. When mapping filenames to ids, all matches in all
 
407
            trees (including optional extra_trees) are used, and all children of
 
408
            matched directories are included.
 
409
        :param want_unchanged: An optional boolean requesting the inclusion of
 
410
            unchanged entries in the result.
 
411
        :param extra_trees: An optional list of additional trees to use when
 
412
            mapping the contents of specific_files (paths) to file_ids.
 
413
        :param require_versioned: An optional boolean (defaults to False). When
 
414
            supplied and True all the 'specific_files' must be versioned, or
 
415
            a PathsNotVersionedError will be thrown.
 
416
        """
 
417
        # NB: show_status depends on being able to pass in non-versioned files and
 
418
        # report them as unknown
 
419
        trees = (self.source, self.target)
 
420
        if extra_trees is not None:
 
421
            trees = trees + tuple(extra_trees)
 
422
        specific_file_ids = find_ids_across_trees(specific_files,
 
423
            trees, require_versioned=require_versioned)
 
424
        if specific_files and not specific_file_ids:
 
425
            # All files are unversioned, so just return an empty delta
 
426
            # _compare_trees would think we want a complete delta
 
427
            return delta.TreeDelta()
 
428
        return delta._compare_trees(self.source, self.target, want_unchanged,
 
429
            specific_file_ids)