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

merge bzr.dev.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tree.py
1
 
# Copyright (C) 2005 Canonical Ltd
 
1
# Copyright (C) 2005, 2009 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., 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
"""Tree classes, representing directory at point in time.
18
18
"""
23
23
 
24
24
import bzrlib
25
25
from bzrlib import (
 
26
    conflicts as _mod_conflicts,
 
27
    debug,
26
28
    delta,
 
29
    filters,
27
30
    osutils,
28
31
    revision as _mod_revision,
 
32
    rules,
29
33
    symbol_versioning,
30
34
    )
31
35
from bzrlib.decorators import needs_read_lock
32
 
from bzrlib.errors import BzrError, BzrCheckError
 
36
from bzrlib.errors import BzrError, BzrCheckError, NoSuchId
33
37
from bzrlib import errors
34
38
from bzrlib.inventory import Inventory, InventoryFile
35
39
from bzrlib.inter import InterObject
36
40
from bzrlib.osutils import fingerprint_file
37
41
import bzrlib.revision
 
42
from bzrlib.symbol_versioning import deprecated_function, deprecated_in
38
43
from bzrlib.trace import mutter, note
39
44
 
40
45
 
42
47
    """Abstract file tree.
43
48
 
44
49
    There are several subclasses:
45
 
    
 
50
 
46
51
    * `WorkingTree` exists as files on disk editable by the user.
47
52
 
48
53
    * `RevisionTree` is a tree as recorded at some point in the past.
57
62
    Trees can be compared, etc, regardless of whether they are working
58
63
    trees or versioned trees.
59
64
    """
60
 
    
 
65
 
61
66
    def changes_from(self, other, want_unchanged=False, specific_files=None,
62
67
        extra_trees=None, require_versioned=False, include_root=False,
63
68
        want_unversioned=False):
77
82
            a PathsNotVersionedError will be thrown.
78
83
        :param want_unversioned: Scan for unversioned paths.
79
84
 
80
 
        The comparison will be performed by an InterTree object looked up on 
 
85
        The comparison will be performed by an InterTree object looked up on
81
86
        self and other.
82
87
        """
83
88
        # Martin observes that Tree.changes_from returns a TreeDelta and this
92
97
            want_unversioned=want_unversioned,
93
98
            )
94
99
 
95
 
    def _iter_changes(self, from_tree, include_unchanged=False,
 
100
    def iter_changes(self, from_tree, include_unchanged=False,
96
101
                     specific_files=None, pb=None, extra_trees=None,
97
102
                     require_versioned=True, want_unversioned=False):
98
103
        intertree = InterTree.get(from_tree, self)
99
 
        return intertree._iter_changes(include_unchanged, specific_files, pb,
 
104
        return intertree.iter_changes(include_unchanged, specific_files, pb,
100
105
            extra_trees, require_versioned, want_unversioned=want_unversioned)
101
 
    
 
106
 
102
107
    def conflicts(self):
103
108
        """Get a list of the conflicts in the tree.
104
109
 
105
110
        Each conflict is an instance of bzrlib.conflicts.Conflict.
106
111
        """
107
 
        return []
 
112
        return _mod_conflicts.ConflictList()
108
113
 
109
114
    def extras(self):
110
115
        """For trees that can have unversioned files, return all such paths."""
111
116
        return []
112
117
 
113
118
    def get_parent_ids(self):
114
 
        """Get the parent ids for this tree. 
 
119
        """Get the parent ids for this tree.
115
120
 
116
121
        :return: a list of parent ids. [] is returned to indicate
117
122
        a tree with no parents.
118
123
        :raises: BzrError if the parents are not known.
119
124
        """
120
125
        raise NotImplementedError(self.get_parent_ids)
121
 
    
 
126
 
122
127
    def has_filename(self, filename):
123
128
        """True if the tree has given filename."""
124
 
        raise NotImplementedError()
 
129
        raise NotImplementedError(self.has_filename)
125
130
 
126
131
    def has_id(self, file_id):
127
 
        file_id = osutils.safe_file_id(file_id)
128
132
        return self.inventory.has_id(file_id)
129
133
 
130
 
    __contains__ = has_id
 
134
    def __contains__(self, file_id):
 
135
        return self.has_id(file_id)
131
136
 
132
137
    def has_or_had_id(self, file_id):
133
 
        file_id = osutils.safe_file_id(file_id)
134
138
        if file_id == self.inventory.root.file_id:
135
139
            return True
136
140
        return self.inventory.has_id(file_id)
146
150
    def __iter__(self):
147
151
        return iter(self.inventory)
148
152
 
 
153
    def all_file_ids(self):
 
154
        """Iterate through all file ids, including ids for missing files."""
 
155
        return set(self.inventory)
 
156
 
149
157
    def id2path(self, file_id):
150
158
        """Return the path for a file id.
151
159
 
152
160
        :raises NoSuchId:
153
161
        """
154
 
        file_id = osutils.safe_file_id(file_id)
155
162
        return self.inventory.id2path(file_id)
156
163
 
157
164
    def is_control_filename(self, filename):
158
165
        """True if filename is the name of a control file in this tree.
159
 
        
 
166
 
160
167
        :param filename: A filename within the tree. This is a relative path
161
168
        from the root of this tree.
162
169
 
170
177
    def iter_entries_by_dir(self, specific_file_ids=None):
171
178
        """Walk the tree in 'by_dir' order.
172
179
 
173
 
        This will yield each entry in the tree as a (path, entry) tuple. The
174
 
        order that they are yielded is: the contents of a directory are 
175
 
        preceeded by the parent of a directory, and all the contents of a 
176
 
        directory are grouped together.
 
180
        This will yield each entry in the tree as a (path, entry) tuple.
 
181
        The order that they are yielded is:
 
182
 
 
183
        Directories are walked in a depth-first lexicographical order,
 
184
        however, whenever a directory is reached, all of its direct child
 
185
        nodes are yielded in  lexicographical order before yielding the
 
186
        grandchildren.
 
187
 
 
188
        For example, in the tree::
 
189
 
 
190
           a/
 
191
             b/
 
192
               c
 
193
             d/
 
194
               e
 
195
           f/
 
196
             g
 
197
 
 
198
        The yield order (ignoring root) would be::
 
199
          a, f, a/b, a/d, a/b/c, a/d/e, f/g
177
200
        """
178
201
        return self.inventory.iter_entries_by_dir(
179
202
            specific_file_ids=specific_file_ids)
180
203
 
181
204
    def iter_references(self):
182
 
        for path, entry in self.iter_entries_by_dir():
183
 
            if entry.kind == 'tree-reference':
184
 
                yield path, entry.file_id
 
205
        if self.supports_tree_reference():
 
206
            for path, entry in self.iter_entries_by_dir():
 
207
                if entry.kind == 'tree-reference':
 
208
                    yield path, entry.file_id
185
209
 
186
210
    def kind(self, file_id):
187
211
        raise NotImplementedError("Tree subclass %s must implement kind"
188
212
            % self.__class__.__name__)
189
213
 
 
214
    def stored_kind(self, file_id):
 
215
        """File kind stored for this file_id.
 
216
 
 
217
        May not match kind on disk for working trees.  Always available
 
218
        for versioned files, even when the file itself is missing.
 
219
        """
 
220
        return self.kind(file_id)
 
221
 
 
222
    def path_content_summary(self, path):
 
223
        """Get a summary of the information about path.
 
224
 
 
225
        :param path: A relative path within the tree.
 
226
        :return: A tuple containing kind, size, exec, sha1-or-link.
 
227
            Kind is always present (see tree.kind()).
 
228
            size is present if kind is file, None otherwise.
 
229
            exec is None unless kind is file and the platform supports the 'x'
 
230
                bit.
 
231
            sha1-or-link is the link target if kind is symlink, or the sha1 if
 
232
                it can be obtained without reading the file.
 
233
        """
 
234
        raise NotImplementedError(self.path_content_summary)
 
235
 
190
236
    def get_reference_revision(self, file_id, path=None):
191
237
        raise NotImplementedError("Tree subclass %s must implement "
192
238
                                  "get_reference_revision"
208
254
 
209
255
    def _get_inventory(self):
210
256
        return self._inventory
211
 
    
212
 
    def get_file(self, file_id):
213
 
        """Return a file object for the file file_id in the tree."""
 
257
 
 
258
    def get_file(self, file_id, path=None):
 
259
        """Return a file object for the file file_id in the tree.
 
260
 
 
261
        If both file_id and path are defined, it is implementation defined as
 
262
        to which one is used.
 
263
        """
214
264
        raise NotImplementedError(self.get_file)
215
265
 
 
266
    def get_file_text(self, file_id, path=None):
 
267
        """Return the byte content of a file.
 
268
 
 
269
        :param file_id: The file_id of the file.
 
270
        :param path: The path of the file.
 
271
        If both file_id and path are supplied, an implementation may use
 
272
        either one.
 
273
        """
 
274
        my_file = self.get_file(file_id, path)
 
275
        try:
 
276
            return my_file.read()
 
277
        finally:
 
278
            my_file.close()
 
279
 
 
280
    def get_file_lines(self, file_id, path=None):
 
281
        """Return the content of a file, as lines.
 
282
 
 
283
        :param file_id: The file_id of the file.
 
284
        :param path: The path of the file.
 
285
        If both file_id and path are supplied, an implementation may use
 
286
        either one.
 
287
        """
 
288
        return osutils.split_lines(self.get_file_text(file_id, path))
 
289
 
216
290
    def get_file_mtime(self, file_id, path=None):
217
291
        """Return the modification time for a file.
218
292
 
222
296
        """
223
297
        raise NotImplementedError(self.get_file_mtime)
224
298
 
 
299
    def get_file_size(self, file_id):
 
300
        """Return the size of a file in bytes.
 
301
 
 
302
        This applies only to regular files.  If invoked on directories or
 
303
        symlinks, it will return None.
 
304
        :param file_id: The file-id of the file
 
305
        """
 
306
        raise NotImplementedError(self.get_file_size)
 
307
 
225
308
    def get_file_by_path(self, path):
226
 
        return self.get_file(self._inventory.path2id(path))
 
309
        return self.get_file(self._inventory.path2id(path), path)
 
310
 
 
311
    def iter_files_bytes(self, desired_files):
 
312
        """Iterate through file contents.
 
313
 
 
314
        Files will not necessarily be returned in the order they occur in
 
315
        desired_files.  No specific order is guaranteed.
 
316
 
 
317
        Yields pairs of identifier, bytes_iterator.  identifier is an opaque
 
318
        value supplied by the caller as part of desired_files.  It should
 
319
        uniquely identify the file version in the caller's context.  (Examples:
 
320
        an index number or a TreeTransform trans_id.)
 
321
 
 
322
        bytes_iterator is an iterable of bytestrings for the file.  The
 
323
        kind of iterable and length of the bytestrings are unspecified, but for
 
324
        this implementation, it is a tuple containing a single bytestring with
 
325
        the complete text of the file.
 
326
 
 
327
        :param desired_files: a list of (file_id, identifier) pairs
 
328
        """
 
329
        for file_id, identifier in desired_files:
 
330
            # We wrap the string in a tuple so that we can return an iterable
 
331
            # of bytestrings.  (Technically, a bytestring is also an iterable
 
332
            # of bytestrings, but iterating through each character is not
 
333
            # performant.)
 
334
            cur_file = (self.get_file_text(file_id),)
 
335
            yield identifier, cur_file
227
336
 
228
337
    def get_symlink_target(self, file_id):
229
338
        """Get the target for a given file_id.
235
344
        """
236
345
        raise NotImplementedError(self.get_symlink_target)
237
346
 
238
 
    def annotate_iter(self, file_id):
239
 
        """Return an iterator of revision_id, line tuples
 
347
    def get_canonical_inventory_paths(self, paths):
 
348
        """Like get_canonical_inventory_path() but works on multiple items.
 
349
 
 
350
        :param paths: A sequence of paths relative to the root of the tree.
 
351
        :return: A list of paths, with each item the corresponding input path
 
352
        adjusted to account for existing elements that match case
 
353
        insensitively.
 
354
        """
 
355
        return list(self._yield_canonical_inventory_paths(paths))
 
356
 
 
357
    def get_canonical_inventory_path(self, path):
 
358
        """Returns the first inventory item that case-insensitively matches path.
 
359
 
 
360
        If a path matches exactly, it is returned. If no path matches exactly
 
361
        but more than one path matches case-insensitively, it is implementation
 
362
        defined which is returned.
 
363
 
 
364
        If no path matches case-insensitively, the input path is returned, but
 
365
        with as many path entries that do exist changed to their canonical
 
366
        form.
 
367
 
 
368
        If you need to resolve many names from the same tree, you should
 
369
        use get_canonical_inventory_paths() to avoid O(N) behaviour.
 
370
 
 
371
        :param path: A paths relative to the root of the tree.
 
372
        :return: The input path adjusted to account for existing elements
 
373
        that match case insensitively.
 
374
        """
 
375
        return self._yield_canonical_inventory_paths([path]).next()
 
376
 
 
377
    def _yield_canonical_inventory_paths(self, paths):
 
378
        for path in paths:
 
379
            # First, if the path as specified exists exactly, just use it.
 
380
            if self.path2id(path) is not None:
 
381
                yield path
 
382
                continue
 
383
            # go walkin...
 
384
            cur_id = self.get_root_id()
 
385
            cur_path = ''
 
386
            bit_iter = iter(path.split("/"))
 
387
            for elt in bit_iter:
 
388
                lelt = elt.lower()
 
389
                for child in self.iter_children(cur_id):
 
390
                    try:
 
391
                        child_base = os.path.basename(self.id2path(child))
 
392
                        if child_base.lower() == lelt:
 
393
                            cur_id = child
 
394
                            cur_path = osutils.pathjoin(cur_path, child_base)
 
395
                            break
 
396
                    except NoSuchId:
 
397
                        # before a change is committed we can see this error...
 
398
                        continue
 
399
                else:
 
400
                    # got to the end of this directory and no entries matched.
 
401
                    # Return what matched so far, plus the rest as specified.
 
402
                    cur_path = osutils.pathjoin(cur_path, elt, *list(bit_iter))
 
403
                    break
 
404
            yield cur_path
 
405
        # all done.
 
406
 
 
407
    def get_root_id(self):
 
408
        """Return the file_id for the root of this tree."""
 
409
        raise NotImplementedError(self.get_root_id)
 
410
 
 
411
    def annotate_iter(self, file_id,
 
412
                      default_revision=_mod_revision.CURRENT_REVISION):
 
413
        """Return an iterator of revision_id, line tuples.
240
414
 
241
415
        For working trees (and mutable trees in general), the special
242
416
        revision_id 'current:' will be used for lines that are new in this
243
417
        tree, e.g. uncommitted changes.
244
418
        :param file_id: The file to produce an annotated version from
 
419
        :param default_revision: For lines that don't match a basis, mark them
 
420
            with this revision id. Not all implementations will make use of
 
421
            this value.
245
422
        """
246
423
        raise NotImplementedError(self.annotate_iter)
247
424
 
248
 
    def plan_file_merge(self, file_id, other):
249
 
        """Generate a merge plan based on annotations
250
 
 
251
 
        If the file contains uncommitted changes in this tree, they will be
252
 
        attributed to the 'current:' pseudo-revision.  If the file contains
253
 
        uncommitted changes in the other tree, they will be assigned to the
254
 
        'other:' pseudo-revision.
255
 
        """
256
 
        from bzrlib import merge
257
 
        annotated_a = list(self.annotate_iter(file_id,
258
 
                                              _mod_revision.CURRENT_REVISION))
259
 
        annotated_b = list(other.annotate_iter(file_id, 'other:'))
260
 
        ancestors_a = self._get_ancestors(_mod_revision.CURRENT_REVISION)
261
 
        ancestors_b = other._get_ancestors('other:')
262
 
        return merge._plan_annotate_merge(annotated_a, annotated_b,
263
 
                                          ancestors_a, ancestors_b)
 
425
    def _get_plan_merge_data(self, file_id, other, base):
 
426
        from bzrlib import merge, versionedfile
 
427
        vf = versionedfile._PlanMergeVersionedFile(file_id)
 
428
        last_revision_a = self._get_file_revision(file_id, vf, 'this:')
 
429
        last_revision_b = other._get_file_revision(file_id, vf, 'other:')
 
430
        if base is None:
 
431
            last_revision_base = None
 
432
        else:
 
433
            last_revision_base = base._get_file_revision(file_id, vf, 'base:')
 
434
        return vf, last_revision_a, last_revision_b, last_revision_base
 
435
 
 
436
    def plan_file_merge(self, file_id, other, base=None):
 
437
        """Generate a merge plan based on annotations.
 
438
 
 
439
        If the file contains uncommitted changes in this tree, they will be
 
440
        attributed to the 'current:' pseudo-revision.  If the file contains
 
441
        uncommitted changes in the other tree, they will be assigned to the
 
442
        'other:' pseudo-revision.
 
443
        """
 
444
        data = self._get_plan_merge_data(file_id, other, base)
 
445
        vf, last_revision_a, last_revision_b, last_revision_base = data
 
446
        return vf.plan_merge(last_revision_a, last_revision_b,
 
447
                             last_revision_base)
 
448
 
 
449
    def plan_file_lca_merge(self, file_id, other, base=None):
 
450
        """Generate a merge plan based lca-newness.
 
451
 
 
452
        If the file contains uncommitted changes in this tree, they will be
 
453
        attributed to the 'current:' pseudo-revision.  If the file contains
 
454
        uncommitted changes in the other tree, they will be assigned to the
 
455
        'other:' pseudo-revision.
 
456
        """
 
457
        data = self._get_plan_merge_data(file_id, other, base)
 
458
        vf, last_revision_a, last_revision_b, last_revision_base = data
 
459
        return vf.plan_lca_merge(last_revision_a, last_revision_b,
 
460
                                 last_revision_base)
 
461
 
 
462
    def _iter_parent_trees(self):
 
463
        """Iterate through parent trees, defaulting to Tree.revision_tree."""
 
464
        for revision_id in self.get_parent_ids():
 
465
            try:
 
466
                yield self.revision_tree(revision_id)
 
467
            except errors.NoSuchRevisionInTree:
 
468
                yield self.repository.revision_tree(revision_id)
 
469
 
 
470
    @staticmethod
 
471
    def _file_revision(revision_tree, file_id):
 
472
        """Determine the revision associated with a file in a given tree."""
 
473
        revision_tree.lock_read()
 
474
        try:
 
475
            return revision_tree.inventory[file_id].revision
 
476
        finally:
 
477
            revision_tree.unlock()
 
478
 
 
479
    def _get_file_revision(self, file_id, vf, tree_revision):
 
480
        """Ensure that file_id, tree_revision is in vf to plan the merge."""
 
481
 
 
482
        if getattr(self, '_repository', None) is None:
 
483
            last_revision = tree_revision
 
484
            parent_keys = [(file_id, self._file_revision(t, file_id)) for t in
 
485
                self._iter_parent_trees()]
 
486
            vf.add_lines((file_id, last_revision), parent_keys,
 
487
                         self.get_file(file_id).readlines())
 
488
            repo = self.branch.repository
 
489
            base_vf = repo.texts
 
490
        else:
 
491
            last_revision = self._file_revision(self, file_id)
 
492
            base_vf = self._repository.texts
 
493
        if base_vf not in vf.fallback_versionedfiles:
 
494
            vf.fallback_versionedfiles.append(base_vf)
 
495
        return last_revision
264
496
 
265
497
    inventory = property(_get_inventory,
266
498
                         doc="Inventory of this Tree")
267
499
 
268
500
    def _check_retrieved(self, ie, f):
269
501
        if not __debug__:
270
 
            return  
 
502
            return
271
503
        fp = fingerprint_file(f)
272
504
        f.seek(0)
273
 
        
 
505
 
274
506
        if ie.text_size is not None:
275
507
            if ie.text_size != fp['size']:
276
508
                raise BzrError("mismatched size for file %r in %r" % (ie.file_id, self._store),
291
523
 
292
524
    def paths2ids(self, paths, trees=[], require_versioned=True):
293
525
        """Return all the ids that can be reached by walking from paths.
294
 
        
295
 
        Each path is looked up in each this tree and any extras provided in
 
526
 
 
527
        Each path is looked up in this tree and any extras provided in
296
528
        trees, and this is repeated recursively: the children in an extra tree
297
529
        of a directory that has been renamed under a provided path in this tree
298
 
        are all returned, even if none exist until a provided path in this
 
530
        are all returned, even if none exist under a provided path in this
299
531
        tree, and vice versa.
300
532
 
301
533
        :param paths: An iterable of paths to start converting to ids from.
308
540
        """
309
541
        return find_ids_across_trees(paths, [self] + list(trees), require_versioned)
310
542
 
311
 
    def print_file(self, file_id):
312
 
        """Print file with id `file_id` to stdout."""
313
 
        file_id = osutils.safe_file_id(file_id)
314
 
        import sys
315
 
        sys.stdout.write(self.get_file_text(file_id))
 
543
    def iter_children(self, file_id):
 
544
        entry = self.iter_entries_by_dir([file_id]).next()[1]
 
545
        for child in getattr(entry, 'children', {}).itervalues():
 
546
            yield child.file_id
316
547
 
317
548
    def lock_read(self):
318
549
        pass
322
553
 
323
554
        The intention of this method is to allow access to possibly cached
324
555
        tree data. Implementors of this method should raise NoSuchRevision if
325
 
        the tree is not locally available, even if they could obtain the 
326
 
        tree via a repository or some other means. Callers are responsible 
 
556
        the tree is not locally available, even if they could obtain the
 
557
        tree via a repository or some other means. Callers are responsible
327
558
        for finding the ultimate source for a revision tree.
328
559
 
329
560
        :param revision_id: The revision_id of the requested tree.
334
565
 
335
566
    def unknowns(self):
336
567
        """What files are present in this tree and unknown.
337
 
        
 
568
 
338
569
        :return: an iterator over the unknown files.
339
570
        """
340
571
        return iter([])
348
579
        :return: set of paths.
349
580
        """
350
581
        # NB: we specifically *don't* call self.has_filename, because for
351
 
        # WorkingTrees that can indicate files that exist on disk but that 
 
582
        # WorkingTrees that can indicate files that exist on disk but that
352
583
        # are not versioned.
353
584
        pred = self.inventory.has_filename
354
585
        return set((p for p in paths if not pred(p)))
359
590
        This yields all the data about the contents of a directory at a time.
360
591
        After each directory has been yielded, if the caller has mutated the
361
592
        list to exclude some directories, they are then not descended into.
362
 
        
 
593
 
363
594
        The data yielded is of the form:
364
595
        ((directory-relpath, directory-path-from-root, directory-fileid),
365
 
        [(relpath, basename, kind, lstat, path_from_tree_root, file_id, 
 
596
        [(relpath, basename, kind, lstat, path_from_tree_root, file_id,
366
597
          versioned_kind), ...]),
367
598
         - directory-relpath is the containing dirs relpath from prefix
368
599
         - directory-path-from-root is the containing dirs path from /
374
605
           versioned_kind.
375
606
         - lstat is the stat data *if* the file was statted.
376
607
         - path_from_tree_root is the path from the root of the tree.
377
 
         - file_id is the file_id is the entry is versioned.
378
 
         - versioned_kind is the kind of the file as last recorded in the 
 
608
         - file_id is the file_id if the entry is versioned.
 
609
         - versioned_kind is the kind of the file as last recorded in the
379
610
           versioning system. If 'unknown' the file is not versioned.
380
611
        One of 'kind' and 'versioned_kind' must not be 'unknown'.
381
612
 
386
617
        """
387
618
        raise NotImplementedError(self.walkdirs)
388
619
 
389
 
 
390
 
class EmptyTree(Tree):
391
 
 
392
 
    def __init__(self):
393
 
        self._inventory = Inventory(root_id=None)
394
 
        symbol_versioning.warn('EmptyTree is deprecated as of bzr 0.9 please'
395
 
                               ' use repository.revision_tree instead.',
396
 
                               DeprecationWarning, stacklevel=2)
397
 
 
398
 
    def get_parent_ids(self):
399
 
        return []
400
 
 
401
 
    def get_symlink_target(self, file_id):
402
 
        return None
403
 
 
404
 
    def has_filename(self, filename):
 
620
    def supports_content_filtering(self):
405
621
        return False
406
622
 
407
 
    def kind(self, file_id):
408
 
        file_id = osutils.safe_file_id(file_id)
409
 
        assert self._inventory[file_id].kind == "directory"
410
 
        return "directory"
411
 
 
412
 
    def list_files(self, include_root=False):
413
 
        return iter([])
414
 
    
415
 
    def __contains__(self, file_id):
416
 
        file_id = osutils.safe_file_id(file_id)
417
 
        return (file_id in self._inventory)
418
 
 
419
 
    def get_file_sha1(self, file_id, path=None, stat_value=None):
420
 
        return None
 
623
    def _content_filter_stack(self, path=None, file_id=None):
 
624
        """The stack of content filters for a path if filtering is supported.
 
625
 
 
626
        Readers will be applied in first-to-last order.
 
627
        Writers will be applied in last-to-first order.
 
628
        Either the path or the file-id needs to be provided.
 
629
 
 
630
        :param path: path relative to the root of the tree
 
631
            or None if unknown
 
632
        :param file_id: file_id or None if unknown
 
633
        :return: the list of filters - [] if there are none
 
634
        """
 
635
        filter_pref_names = filters._get_registered_names()
 
636
        if len(filter_pref_names) == 0:
 
637
            return []
 
638
        if path is None:
 
639
            path = self.id2path(file_id)
 
640
        prefs = self.iter_search_rules([path], filter_pref_names).next()
 
641
        stk = filters._get_filter_stack_for(prefs)
 
642
        if 'filters' in debug.debug_flags:
 
643
            note("*** %s content-filter: %s => %r" % (path,prefs,stk))
 
644
        return stk
 
645
 
 
646
    def _content_filter_stack_provider(self):
 
647
        """A function that returns a stack of ContentFilters.
 
648
 
 
649
        The function takes a path (relative to the top of the tree) and a
 
650
        file-id as parameters.
 
651
 
 
652
        :return: None if content filtering is not supported by this tree.
 
653
        """
 
654
        if self.supports_content_filtering():
 
655
            return lambda path, file_id: \
 
656
                    self._content_filter_stack(path, file_id)
 
657
        else:
 
658
            return None
 
659
 
 
660
    def iter_search_rules(self, path_names, pref_names=None,
 
661
        _default_searcher=None):
 
662
        """Find the preferences for filenames in a tree.
 
663
 
 
664
        :param path_names: an iterable of paths to find attributes for.
 
665
          Paths are given relative to the root of the tree.
 
666
        :param pref_names: the list of preferences to lookup - None for all
 
667
        :param _default_searcher: private parameter to assist testing - don't use
 
668
        :return: an iterator of tuple sequences, one per path-name.
 
669
          See _RulesSearcher.get_items for details on the tuple sequence.
 
670
        """
 
671
        if _default_searcher is None:
 
672
            _default_searcher = rules._per_user_searcher
 
673
        searcher = self._get_rules_searcher(_default_searcher)
 
674
        if searcher is not None:
 
675
            if pref_names is not None:
 
676
                for path in path_names:
 
677
                    yield searcher.get_selected_items(path, pref_names)
 
678
            else:
 
679
                for path in path_names:
 
680
                    yield searcher.get_items(path)
 
681
 
 
682
    @needs_read_lock
 
683
    def _get_rules_searcher(self, default_searcher):
 
684
        """Get the RulesSearcher for this tree given the default one."""
 
685
        searcher = default_searcher
 
686
        return searcher
421
687
 
422
688
 
423
689
######################################################################
456
722
        # what happened to the file that used to have
457
723
        # this name.  There are two possibilities: either it was
458
724
        # deleted entirely, or renamed.
459
 
        assert old_id
460
725
        if new_inv.has_id(old_id):
461
726
            return 'X', old_inv.id2path(old_id), new_inv.id2path(old_id)
462
727
        else:
473
738
 
474
739
    return 'wtf?'
475
740
 
476
 
    
477
741
 
 
742
@deprecated_function(deprecated_in((1, 9, 0)))
478
743
def find_renames(old_inv, new_inv):
479
744
    for file_id in old_inv:
480
745
        if file_id not in new_inv:
483
748
        new_name = new_inv.id2path(file_id)
484
749
        if old_name != new_name:
485
750
            yield (old_name, new_name)
486
 
            
 
751
 
487
752
 
488
753
def find_ids_across_trees(filenames, trees, require_versioned=True):
489
754
    """Find the ids corresponding to specified filenames.
490
 
    
 
755
 
491
756
    All matches in all trees will be used, and all children of matched
492
757
    directories will be used.
493
758
 
507
772
 
508
773
def _find_ids_across_trees(filenames, trees, require_versioned):
509
774
    """Find the ids corresponding to specified filenames.
510
 
    
 
775
 
511
776
    All matches in all trees will be used, but subdirectories are not scanned.
512
777
 
513
778
    :param filenames: The filenames to find file_ids for
514
779
    :param trees: The trees to find file_ids within
515
780
    :param require_versioned: if true, all specified filenames must occur in
516
781
        at least one tree.
517
 
    :return: a set of (path, file ids) for the specified filenames
 
782
    :return: a set of file ids for the specified filenames
518
783
    """
519
784
    not_versioned = []
520
785
    interesting_ids = set()
533
798
 
534
799
 
535
800
def _find_children_across_trees(specified_ids, trees):
536
 
    """Return a set including specified ids and their children
537
 
    
 
801
    """Return a set including specified ids and their children.
 
802
 
538
803
    All matches in all trees will be used.
539
804
 
540
805
    :param trees: The trees to find file_ids within
541
 
    :return: a set containing all specified ids and their children 
 
806
    :return: a set containing all specified ids and their children
542
807
    """
543
808
    interesting_ids = set(specified_ids)
544
809
    pending = interesting_ids
550
815
            for tree in trees:
551
816
                if not tree.has_id(file_id):
552
817
                    continue
553
 
                entry = tree.inventory[file_id]
554
 
                for child in getattr(entry, 'children', {}).itervalues():
555
 
                    if child.file_id not in interesting_ids:
556
 
                        new_pending.add(child.file_id)
 
818
                for child_id in tree.iter_children(file_id):
 
819
                    if child_id not in interesting_ids:
 
820
                        new_pending.add(child_id)
557
821
        interesting_ids.update(new_pending)
558
822
        pending = new_pending
559
823
    return interesting_ids
565
829
    Its instances have methods like 'compare' and contain references to the
566
830
    source and target trees these operations are to be carried out on.
567
831
 
568
 
    clients of bzrlib should not need to use InterTree directly, rather they
 
832
    Clients of bzrlib should not need to use InterTree directly, rather they
569
833
    should use the convenience methods on Tree such as 'Tree.compare()' which
570
834
    will pass through to InterTree as appropriate.
571
835
    """
614
878
            require_versioned=require_versioned,
615
879
            want_unversioned=want_unversioned)
616
880
 
617
 
    def _iter_changes(self, include_unchanged=False,
 
881
    def iter_changes(self, include_unchanged=False,
618
882
                      specific_files=None, pb=None, extra_trees=[],
619
883
                      require_versioned=True, want_unversioned=False):
620
884
        """Generate an iterator of changes between trees.
644
908
            output. An unversioned file is defined as one with (False, False)
645
909
            for the versioned pair.
646
910
        """
647
 
        result = []
648
911
        lookup_trees = [self.source]
649
912
        if extra_trees:
650
913
             lookup_trees.extend(extra_trees)
651
 
        specific_file_ids = self.target.paths2ids(specific_files,
652
 
            lookup_trees, require_versioned=require_versioned)
 
914
        if specific_files == []:
 
915
            specific_file_ids = []
 
916
        else:
 
917
            specific_file_ids = self.target.paths2ids(specific_files,
 
918
                lookup_trees, require_versioned=require_versioned)
653
919
        if want_unversioned:
654
 
            all_unversioned = sorted([(p.split('/'), p) for p in self.target.extras()
655
 
                if not specific_files or
 
920
            all_unversioned = sorted([(p.split('/'), p) for p in
 
921
                                     self.target.extras()
 
922
                if specific_files is None or
656
923
                    osutils.is_inside_any(specific_files, p)])
657
924
            all_unversioned = deque(all_unversioned)
658
925
        else:
659
926
            all_unversioned = deque()
660
927
        to_paths = {}
661
 
        from_entries_by_dir = list(self.source.inventory.iter_entries_by_dir(
 
928
        from_entries_by_dir = list(self.source.iter_entries_by_dir(
662
929
            specific_file_ids=specific_file_ids))
663
930
        from_data = dict((e.file_id, (p, e)) for p, e in from_entries_by_dir)
664
 
        to_entries_by_dir = list(self.target.inventory.iter_entries_by_dir(
 
931
        to_entries_by_dir = list(self.target.iter_entries_by_dir(
665
932
            specific_file_ids=specific_file_ids))
666
933
        num_entries = len(from_entries_by_dir) + len(to_entries_by_dir)
667
934
        entry_count = 0
668
 
        # the unversioned path lookup only occurs on real trees - where there 
 
935
        # the unversioned path lookup only occurs on real trees - where there
669
936
        # can be extras. So the fake_entry is solely used to look up
670
937
        # executable it values when execute is not supported.
671
938
        fake_entry = InventoryFile('unused', 'unused', 'unused')
705
972
            if kind[0] != kind[1]:
706
973
                changed_content = True
707
974
            elif from_kind == 'file':
708
 
                from_size = self.source._file_size(from_entry, from_stat)
709
 
                to_size = self.target._file_size(to_entry, to_stat)
710
 
                if from_size != to_size:
711
 
                    changed_content = True
712
 
                elif (self.source.get_file_sha1(file_id, from_path, from_stat) !=
 
975
                if (self.source.get_file_sha1(file_id, from_path, from_stat) !=
713
976
                    self.target.get_file_sha1(file_id, to_path, to_stat)):
714
977
                    changed_content = True
715
978
            elif from_kind == 'symlink':
716
979
                if (self.source.get_symlink_target(file_id) !=
717
980
                    self.target.get_symlink_target(file_id)):
718
981
                    changed_content = True
 
982
                # XXX: Yes, the indentation below is wrong. But fixing it broke
 
983
                # test_merge.TestMergerEntriesLCAOnDisk.
 
984
                # test_nested_tree_subtree_renamed_and_modified. We'll wait for
 
985
                # the fix from bzr.dev -- vila 2009026
719
986
                elif from_kind == 'tree-reference':
720
987
                    if (self.source.get_reference_revision(file_id, from_path)
721
988
                        != self.target.get_reference_revision(file_id, to_path)):
722
 
                        changed_content = True 
 
989
                        changed_content = True
723
990
            parent = (from_parent, to_entry.parent_id)
724
991
            name = (from_name, to_entry.name)
725
992
            executable = (from_executable, to_executable)
726
993
            if pb is not None:
727
994
                pb.update('comparing files', entry_count, num_entries)
728
995
            if (changed_content is not False or versioned[0] != versioned[1]
729
 
                or parent[0] != parent[1] or name[0] != name[1] or 
 
996
                or parent[0] != parent[1] or name[0] != name[1] or
730
997
                executable[0] != executable[1] or include_unchanged):
731
998
                yield (file_id, (from_path, to_path), changed_content,
732
999
                    versioned, parent, name, kind, executable)
759
1026
            if file_id in to_paths:
760
1027
                # already returned
761
1028
                continue
762
 
            if not file_id in self.target.inventory:
 
1029
            if not file_id in self.target.all_file_ids():
763
1030
                # common case - paths we have not emitted are not present in
764
1031
                # target.
765
1032
                to_path = None
775
1042
                self.source._comparison_data(from_entry, path)
776
1043
            kind = (from_kind, None)
777
1044
            executable = (from_executable, None)
778
 
            changed_content = True
 
1045
            changed_content = from_kind is not None
779
1046
            # the parent's path is necessarily known at this point.
780
1047
            yield(file_id, (path, to_path), changed_content, versioned, parent,
781
1048
                  name, kind, executable)
782
1049
 
783
1050
 
784
 
# This was deprecated before 0.12, but did not have an official warning
785
 
@symbol_versioning.deprecated_function(symbol_versioning.zero_twelve)
786
 
def RevisionTree(*args, **kwargs):
787
 
    """RevisionTree has moved to bzrlib.revisiontree.RevisionTree()
788
 
 
789
 
    Accessing it as bzrlib.tree.RevisionTree has been deprecated as of
790
 
    bzr 0.12.
791
 
    """
792
 
    from bzrlib.revisiontree import RevisionTree as _RevisionTree
793
 
    return _RevisionTree(*args, **kwargs)
794
 
 
795
 
 
 
1051
class MultiWalker(object):
 
1052
    """Walk multiple trees simultaneously, getting combined results."""
 
1053
 
 
1054
    # Note: This could be written to not assume you can do out-of-order
 
1055
    #       lookups. Instead any nodes that don't match in all trees could be
 
1056
    #       marked as 'deferred', and then returned in the final cleanup loop.
 
1057
    #       For now, I think it is "nicer" to return things as close to the
 
1058
    #       "master_tree" order as we can.
 
1059
 
 
1060
    def __init__(self, master_tree, other_trees):
 
1061
        """Create a new MultiWalker.
 
1062
 
 
1063
        All trees being walked must implement "iter_entries_by_dir()", such
 
1064
        that they yield (path, object) tuples, where that object will have a
 
1065
        '.file_id' member, that can be used to check equality.
 
1066
 
 
1067
        :param master_tree: All trees will be 'slaved' to the master_tree such
 
1068
            that nodes in master_tree will be used as 'first-pass' sync points.
 
1069
            Any nodes that aren't in master_tree will be merged in a second
 
1070
            pass.
 
1071
        :param other_trees: A list of other trees to walk simultaneously.
 
1072
        """
 
1073
        self._master_tree = master_tree
 
1074
        self._other_trees = other_trees
 
1075
 
 
1076
        # Keep track of any nodes that were properly processed just out of
 
1077
        # order, that way we don't return them at the end, we don't have to
 
1078
        # track *all* processed file_ids, just the out-of-order ones
 
1079
        self._out_of_order_processed = set()
 
1080
 
 
1081
    @staticmethod
 
1082
    def _step_one(iterator):
 
1083
        """Step an iter_entries_by_dir iterator.
 
1084
 
 
1085
        :return: (has_more, path, ie)
 
1086
            If has_more is False, path and ie will be None.
 
1087
        """
 
1088
        try:
 
1089
            path, ie = iterator.next()
 
1090
        except StopIteration:
 
1091
            return False, None, None
 
1092
        else:
 
1093
            return True, path, ie
 
1094
 
 
1095
    @staticmethod
 
1096
    def _cmp_path_by_dirblock(path1, path2):
 
1097
        """Compare two paths based on what directory they are in.
 
1098
 
 
1099
        This generates a sort order, such that all children of a directory are
 
1100
        sorted together, and grandchildren are in the same order as the
 
1101
        children appear. But all grandchildren come after all children.
 
1102
 
 
1103
        :param path1: first path
 
1104
        :param path2: the second path
 
1105
        :return: negative number if ``path1`` comes first,
 
1106
            0 if paths are equal
 
1107
            and a positive number if ``path2`` sorts first
 
1108
        """
 
1109
        # Shortcut this special case
 
1110
        if path1 == path2:
 
1111
            return 0
 
1112
        # This is stolen from _dirstate_helpers_py.py, only switching it to
 
1113
        # Unicode objects. Consider using encode_utf8() and then using the
 
1114
        # optimized versions, or maybe writing optimized unicode versions.
 
1115
        if not isinstance(path1, unicode):
 
1116
            raise TypeError("'path1' must be a unicode string, not %s: %r"
 
1117
                            % (type(path1), path1))
 
1118
        if not isinstance(path2, unicode):
 
1119
            raise TypeError("'path2' must be a unicode string, not %s: %r"
 
1120
                            % (type(path2), path2))
 
1121
        return cmp(MultiWalker._path_to_key(path1),
 
1122
                   MultiWalker._path_to_key(path2))
 
1123
 
 
1124
    @staticmethod
 
1125
    def _path_to_key(path):
 
1126
        dirname, basename = osutils.split(path)
 
1127
        return (dirname.split(u'/'), basename)
 
1128
 
 
1129
    def _lookup_by_file_id(self, extra_entries, other_tree, file_id):
 
1130
        """Lookup an inventory entry by file_id.
 
1131
 
 
1132
        This is called when an entry is missing in the normal order.
 
1133
        Generally this is because a file was either renamed, or it was
 
1134
        deleted/added. If the entry was found in the inventory and not in
 
1135
        extra_entries, it will be added to self._out_of_order_processed
 
1136
 
 
1137
        :param extra_entries: A dictionary of {file_id: (path, ie)}.  This
 
1138
            should be filled with entries that were found before they were
 
1139
            used. If file_id is present, it will be removed from the
 
1140
            dictionary.
 
1141
        :param other_tree: The Tree to search, in case we didn't find the entry
 
1142
            yet.
 
1143
        :param file_id: The file_id to look for
 
1144
        :return: (path, ie) if found or (None, None) if not present.
 
1145
        """
 
1146
        if file_id in extra_entries:
 
1147
            return extra_entries.pop(file_id)
 
1148
        # TODO: Is id2path better as the first call, or is
 
1149
        #       inventory[file_id] better as a first check?
 
1150
        try:
 
1151
            cur_path = other_tree.id2path(file_id)
 
1152
        except errors.NoSuchId:
 
1153
            cur_path = None
 
1154
        if cur_path is None:
 
1155
            return (None, None)
 
1156
        else:
 
1157
            self._out_of_order_processed.add(file_id)
 
1158
            cur_ie = other_tree.inventory[file_id]
 
1159
            return (cur_path, cur_ie)
 
1160
 
 
1161
    def iter_all(self):
 
1162
        """Match up the values in the different trees."""
 
1163
        for result in self._walk_master_tree():
 
1164
            yield result
 
1165
        self._finish_others()
 
1166
        for result in self._walk_others():
 
1167
            yield result
 
1168
 
 
1169
    def _walk_master_tree(self):
 
1170
        """First pass, walk all trees in lock-step.
 
1171
 
 
1172
        When we are done, all nodes in the master_tree will have been
 
1173
        processed. _other_walkers, _other_entries, and _others_extra will be
 
1174
        set on 'self' for future processing.
 
1175
        """
 
1176
        # This iterator has the most "inlining" done, because it tends to touch
 
1177
        # every file in the tree, while the others only hit nodes that don't
 
1178
        # match.
 
1179
        master_iterator = self._master_tree.iter_entries_by_dir()
 
1180
 
 
1181
        other_walkers = [other.iter_entries_by_dir()
 
1182
                         for other in self._other_trees]
 
1183
        other_entries = [self._step_one(walker) for walker in other_walkers]
 
1184
        # Track extra nodes in the other trees
 
1185
        others_extra = [{} for i in xrange(len(self._other_trees))]
 
1186
 
 
1187
        master_has_more = True
 
1188
        step_one = self._step_one
 
1189
        lookup_by_file_id = self._lookup_by_file_id
 
1190
        out_of_order_processed = self._out_of_order_processed
 
1191
 
 
1192
        while master_has_more:
 
1193
            (master_has_more, path, master_ie) = step_one(master_iterator)
 
1194
            if not master_has_more:
 
1195
                break
 
1196
 
 
1197
            file_id = master_ie.file_id
 
1198
            other_values = []
 
1199
            other_values_append = other_values.append
 
1200
            next_other_entries = []
 
1201
            next_other_entries_append = next_other_entries.append
 
1202
            for idx, (other_has_more, other_path, other_ie) in enumerate(other_entries):
 
1203
                if not other_has_more:
 
1204
                    other_values_append(lookup_by_file_id(
 
1205
                        others_extra[idx], self._other_trees[idx], file_id))
 
1206
                    next_other_entries_append((False, None, None))
 
1207
                elif file_id == other_ie.file_id:
 
1208
                    # This is the critical code path, as most of the entries
 
1209
                    # should match between most trees.
 
1210
                    other_values_append((other_path, other_ie))
 
1211
                    next_other_entries_append(step_one(other_walkers[idx]))
 
1212
                else:
 
1213
                    # This walker did not match, step it until it either
 
1214
                    # matches, or we know we are past the current walker.
 
1215
                    other_walker = other_walkers[idx]
 
1216
                    other_extra = others_extra[idx]
 
1217
                    while (other_has_more and
 
1218
                           self._cmp_path_by_dirblock(other_path, path) < 0):
 
1219
                        other_file_id = other_ie.file_id
 
1220
                        if other_file_id not in out_of_order_processed:
 
1221
                            other_extra[other_file_id] = (other_path, other_ie)
 
1222
                        other_has_more, other_path, other_ie = \
 
1223
                            step_one(other_walker)
 
1224
                    if other_has_more and other_ie.file_id == file_id:
 
1225
                        # We ended up walking to this point, match and step
 
1226
                        # again
 
1227
                        other_values_append((other_path, other_ie))
 
1228
                        other_has_more, other_path, other_ie = \
 
1229
                            step_one(other_walker)
 
1230
                    else:
 
1231
                        # This record isn't in the normal order, see if it
 
1232
                        # exists at all.
 
1233
                        other_values_append(lookup_by_file_id(
 
1234
                            other_extra, self._other_trees[idx], file_id))
 
1235
                    next_other_entries_append((other_has_more, other_path,
 
1236
                                               other_ie))
 
1237
            other_entries = next_other_entries
 
1238
 
 
1239
            # We've matched all the walkers, yield this datapoint
 
1240
            yield path, file_id, master_ie, other_values
 
1241
        self._other_walkers = other_walkers
 
1242
        self._other_entries = other_entries
 
1243
        self._others_extra = others_extra
 
1244
 
 
1245
    def _finish_others(self):
 
1246
        """Finish walking the other iterators, so we get all entries."""
 
1247
        for idx, info in enumerate(self._other_entries):
 
1248
            other_extra = self._others_extra[idx]
 
1249
            (other_has_more, other_path, other_ie) = info
 
1250
            while other_has_more:
 
1251
                other_file_id = other_ie.file_id
 
1252
                if other_file_id not in self._out_of_order_processed:
 
1253
                    other_extra[other_file_id] = (other_path, other_ie)
 
1254
                other_has_more, other_path, other_ie = \
 
1255
                    self._step_one(self._other_walkers[idx])
 
1256
        del self._other_entries
 
1257
 
 
1258
    def _walk_others(self):
 
1259
        """Finish up by walking all the 'deferred' nodes."""
 
1260
        # TODO: One alternative would be to grab all possible unprocessed
 
1261
        #       file_ids, and then sort by path, and then yield them. That
 
1262
        #       might ensure better ordering, in case a caller strictly
 
1263
        #       requires parents before children.
 
1264
        for idx, other_extra in enumerate(self._others_extra):
 
1265
            others = sorted(other_extra.itervalues(),
 
1266
                            key=lambda x: self._path_to_key(x[0]))
 
1267
            for other_path, other_ie in others:
 
1268
                file_id = other_ie.file_id
 
1269
                # We don't need to check out_of_order_processed here, because
 
1270
                # the lookup_by_file_id will be removing anything processed
 
1271
                # from the extras cache
 
1272
                other_extra.pop(file_id)
 
1273
                other_values = [(None, None) for i in xrange(idx)]
 
1274
                other_values.append((other_path, other_ie))
 
1275
                for alt_idx, alt_extra in enumerate(self._others_extra[idx+1:]):
 
1276
                    alt_idx = alt_idx + idx + 1
 
1277
                    alt_extra = self._others_extra[alt_idx]
 
1278
                    alt_tree = self._other_trees[alt_idx]
 
1279
                    other_values.append(self._lookup_by_file_id(
 
1280
                                            alt_extra, alt_tree, file_id))
 
1281
                yield other_path, file_id, None, other_values