~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tree.py

merge bzr.dev

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 iter_entries_by_dir(self):
 
123
        """Walk the tree in 'by_dir' order.
 
124
 
 
125
        This will yield each entry in the tree as a (path, entry) tuple. The
 
126
        order that they are yielded is: the contents of a directory are 
 
127
        preceeded by the parent of a directory, and all the contents of a 
 
128
        directory are grouped together.
 
129
        """
 
130
        return self.inventory.iter_entries_by_dir()
 
131
 
89
132
    def kind(self, file_id):
90
133
        raise NotImplementedError("subclasses must implement kind")
91
134
 
146
189
        # are not versioned.
147
190
        pred = self.inventory.has_filename
148
191
        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
 
 
 
192
 
 
193
 
 
194
# for compatibility
 
195
from bzrlib.revisiontree import RevisionTree
 
196
 
240
197
 
241
198
class EmptyTree(Tree):
242
199
 
243
200
    def __init__(self):
244
201
        self._inventory = Inventory()
 
202
        warn('EmptyTree is deprecated as of bzr 0.9 please use '
 
203
            'repository.revision_tree instead.',
 
204
            DeprecationWarning, stacklevel=2)
245
205
 
246
206
    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
207
        return []
252
208
 
253
209
    def get_symlink_target(self, file_id):
407
363
        interesting_ids.update(new_pending)
408
364
        pending = new_pending
409
365
    return interesting_ids
 
366
 
 
367
 
 
368
class InterTree(InterObject):
 
369
    """This class represents operations taking place between two Trees.
 
370
 
 
371
    Its instances have methods like 'compare' and contain references to the
 
372
    source and target trees these operations are to be carried out on.
 
373
 
 
374
    clients of bzrlib should not need to use InterTree directly, rather they
 
375
    should use the convenience methods on Tree such as 'Tree.compare()' which
 
376
    will pass through to InterTree as appropriate.
 
377
    """
 
378
 
 
379
    _optimisers = set()
 
380
 
 
381
    @needs_read_lock
 
382
    def compare(self, want_unchanged=False, specific_files=None,
 
383
        extra_trees=None, require_versioned=False):
 
384
        """Return the changes from source to target.
 
385
 
 
386
        :return: A TreeDelta.
 
387
        :param specific_files: An optional list of file paths to restrict the
 
388
            comparison to. When mapping filenames to ids, all matches in all
 
389
            trees (including optional extra_trees) are used, and all children of
 
390
            matched directories are included.
 
391
        :param want_unchanged: An optional boolean requesting the inclusion of
 
392
            unchanged entries in the result.
 
393
        :param extra_trees: An optional list of additional trees to use when
 
394
            mapping the contents of specific_files (paths) to file_ids.
 
395
        :param require_versioned: An optional boolean (defaults to False). When
 
396
            supplied and True all the 'specific_files' must be versioned, or
 
397
            a PathsNotVersionedError will be thrown.
 
398
        """
 
399
        # NB: show_status depends on being able to pass in non-versioned files and
 
400
        # report them as unknown
 
401
        trees = (self.source, self.target)
 
402
        if extra_trees is not None:
 
403
            trees = trees + tuple(extra_trees)
 
404
        specific_file_ids = find_ids_across_trees(specific_files,
 
405
            trees, require_versioned=require_versioned)
 
406
        if specific_files and not specific_file_ids:
 
407
            # All files are unversioned, so just return an empty delta
 
408
            # _compare_trees would think we want a complete delta
 
409
            return delta.TreeDelta()
 
410
        return delta._compare_trees(self.source, self.target, want_unchanged,
 
411
            specific_file_ids)