~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tree.py

Merge from 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, include_root=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
            include_root=include_root
 
85
            )
 
86
    
53
87
    def conflicts(self):
54
88
        """Get a list of the conflicts in the tree.
55
89
 
73
107
    def has_id(self, file_id):
74
108
        return self.inventory.has_id(file_id)
75
109
 
 
110
    __contains__ = has_id
 
111
 
76
112
    def has_or_had_id(self, file_id):
77
113
        if file_id == self.inventory.root.file_id:
78
114
            return True
79
115
        return self.inventory.has_id(file_id)
80
116
 
81
 
    __contains__ = has_id
82
 
 
83
117
    def __iter__(self):
84
118
        return iter(self.inventory)
85
119
 
86
120
    def id2path(self, file_id):
87
121
        return self.inventory.id2path(file_id)
88
122
 
 
123
    def iter_entries_by_dir(self):
 
124
        """Walk the tree in 'by_dir' order.
 
125
 
 
126
        This will yield each entry in the tree as a (path, entry) tuple. The
 
127
        order that they are yielded is: the contents of a directory are 
 
128
        preceeded by the parent of a directory, and all the contents of a 
 
129
        directory are grouped together.
 
130
        """
 
131
        return self.inventory.iter_entries_by_dir()
 
132
 
89
133
    def kind(self, file_id):
90
134
        raise NotImplementedError("subclasses must implement kind")
91
135
 
146
190
        # are not versioned.
147
191
        pred = self.inventory.has_filename
148
192
        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, include_root=False):
223
 
        if self.inventory.root is not None and include_root:
224
 
            yield ('', 'V', 'directory', self.inventory.root.file_id,
225
 
                   self.inventory.root)
226
 
        # The only files returned by this are those from the version
227
 
        for path, entry in self.inventory.iter_entries():
228
 
            yield path, 'V', entry.kind, entry.file_id, entry
229
 
 
230
 
    def get_symlink_target(self, file_id):
231
 
        ie = self._inventory[file_id]
232
 
        return ie.symlink_target;
233
 
 
234
 
    def kind(self, file_id):
235
 
        return self._inventory[file_id].kind
236
 
 
237
 
    def lock_read(self):
238
 
        self._repository.lock_read()
239
 
 
240
 
    def unlock(self):
241
 
        self._repository.unlock()
242
 
 
 
193
 
 
194
 
 
195
# for compatibility
 
196
from bzrlib.revisiontree import RevisionTree
 
197
 
243
198
 
244
199
class EmptyTree(Tree):
245
200
 
246
201
    def __init__(self):
247
202
        self._inventory = Inventory(root_id=None)
 
203
        warn('EmptyTree is deprecated as of bzr 0.9 please use '
 
204
            'repository.revision_tree instead.',
 
205
            DeprecationWarning, stacklevel=2)
248
206
 
249
207
    def get_parent_ids(self):
250
 
        """See Tree.get_parent_ids.
251
 
 
252
 
        An EmptyTree always has NULL_REVISION as the only parent.
253
 
        """
254
208
        return []
255
209
 
256
210
    def get_symlink_target(self, file_id):
259
213
    def has_filename(self, filename):
260
214
        return False
261
215
 
262
 
    def list_files(self, include_root=False):
 
216
    def list_files(self, include_root=True):
263
217
        return iter([])
264
218
    
265
219
    def __contains__(self, file_id):
405
359
        interesting_ids.update(new_pending)
406
360
        pending = new_pending
407
361
    return interesting_ids
 
362
 
 
363
 
 
364
class InterTree(InterObject):
 
365
    """This class represents operations taking place between two Trees.
 
366
 
 
367
    Its instances have methods like 'compare' and contain references to the
 
368
    source and target trees these operations are to be carried out on.
 
369
 
 
370
    clients of bzrlib should not need to use InterTree directly, rather they
 
371
    should use the convenience methods on Tree such as 'Tree.compare()' which
 
372
    will pass through to InterTree as appropriate.
 
373
    """
 
374
 
 
375
    _optimisers = set()
 
376
 
 
377
    @needs_read_lock
 
378
    def compare(self, want_unchanged=False, specific_files=None,
 
379
        extra_trees=None, require_versioned=False, include_root=False):
 
380
        """Return the changes from source to target.
 
381
 
 
382
        :return: A TreeDelta.
 
383
        :param specific_files: An optional list of file paths to restrict the
 
384
            comparison to. When mapping filenames to ids, all matches in all
 
385
            trees (including optional extra_trees) are used, and all children of
 
386
            matched directories are included.
 
387
        :param want_unchanged: An optional boolean requesting the inclusion of
 
388
            unchanged entries in the result.
 
389
        :param extra_trees: An optional list of additional trees to use when
 
390
            mapping the contents of specific_files (paths) to file_ids.
 
391
        :param require_versioned: An optional boolean (defaults to False). When
 
392
            supplied and True all the 'specific_files' must be versioned, or
 
393
            a PathsNotVersionedError will be thrown.
 
394
        """
 
395
        # NB: show_status depends on being able to pass in non-versioned files and
 
396
        # report them as unknown
 
397
        trees = (self.source, self.target)
 
398
        if extra_trees is not None:
 
399
            trees = trees + tuple(extra_trees)
 
400
        specific_file_ids = find_ids_across_trees(specific_files,
 
401
            trees, require_versioned=require_versioned)
 
402
        if specific_files and not specific_file_ids:
 
403
            # All files are unversioned, so just return an empty delta
 
404
            # _compare_trees would think we want a complete delta
 
405
            return delta.TreeDelta()
 
406
        return delta._compare_trees(self.source, self.target, want_unchanged,
 
407
            specific_file_ids, include_root=include_root)