/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

  • Committer: Andrew Bennetts
  • Date: 2008-04-07 10:34:57 UTC
  • mfrom: (3344 +trunk)
  • mto: This revision was merged to the branch mainline in revision 3349.
  • Revision ID: andrew.bennetts@canonical.com-20080407103457-ro4t95pd3imwt0zw
Merge from bzr.dev.

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# Copyright (C) 2005 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
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
 
16
 
 
17
"""Tree classes, representing directory at point in time.
 
18
"""
 
19
 
 
20
import os
 
21
from collections import deque
 
22
from cStringIO import StringIO
 
23
 
 
24
import bzrlib
 
25
from bzrlib import (
 
26
    delta,
 
27
    osutils,
 
28
    revision as _mod_revision,
 
29
    conflicts as _mod_conflicts,
 
30
    symbol_versioning,
 
31
    )
 
32
from bzrlib.decorators import needs_read_lock
 
33
from bzrlib.errors import BzrError, BzrCheckError
 
34
from bzrlib import errors
 
35
from bzrlib.inventory import Inventory, InventoryFile
 
36
from bzrlib.inter import InterObject
 
37
from bzrlib.osutils import fingerprint_file
 
38
import bzrlib.revision
 
39
from bzrlib.trace import mutter, note
 
40
 
 
41
 
 
42
class Tree(object):
 
43
    """Abstract file tree.
 
44
 
 
45
    There are several subclasses:
 
46
    
 
47
    * `WorkingTree` exists as files on disk editable by the user.
 
48
 
 
49
    * `RevisionTree` is a tree as recorded at some point in the past.
 
50
 
 
51
    Trees contain an `Inventory` object, and also know how to retrieve
 
52
    file texts mentioned in the inventory, either from a working
 
53
    directory or from a store.
 
54
 
 
55
    It is possible for trees to contain files that are not described
 
56
    in their inventory or vice versa; for this use `filenames()`.
 
57
 
 
58
    Trees can be compared, etc, regardless of whether they are working
 
59
    trees or versioned trees.
 
60
    """
 
61
    
 
62
    def changes_from(self, other, want_unchanged=False, specific_files=None,
 
63
        extra_trees=None, require_versioned=False, include_root=False,
 
64
        want_unversioned=False):
 
65
        """Return a TreeDelta of the changes from other to this tree.
 
66
 
 
67
        :param other: A tree to compare with.
 
68
        :param specific_files: An optional list of file paths to restrict the
 
69
            comparison to. When mapping filenames to ids, all matches in all
 
70
            trees (including optional extra_trees) are used, and all children of
 
71
            matched directories are included.
 
72
        :param want_unchanged: An optional boolean requesting the inclusion of
 
73
            unchanged entries in the result.
 
74
        :param extra_trees: An optional list of additional trees to use when
 
75
            mapping the contents of specific_files (paths) to file_ids.
 
76
        :param require_versioned: An optional boolean (defaults to False). When
 
77
            supplied and True all the 'specific_files' must be versioned, or
 
78
            a PathsNotVersionedError will be thrown.
 
79
        :param want_unversioned: Scan for unversioned paths.
 
80
 
 
81
        The comparison will be performed by an InterTree object looked up on 
 
82
        self and other.
 
83
        """
 
84
        # Martin observes that Tree.changes_from returns a TreeDelta and this
 
85
        # may confuse people, because the class name of the returned object is
 
86
        # a synonym of the object referenced in the method name.
 
87
        return InterTree.get(other, self).compare(
 
88
            want_unchanged=want_unchanged,
 
89
            specific_files=specific_files,
 
90
            extra_trees=extra_trees,
 
91
            require_versioned=require_versioned,
 
92
            include_root=include_root,
 
93
            want_unversioned=want_unversioned,
 
94
            )
 
95
 
 
96
    @symbol_versioning.deprecated_method(symbol_versioning.one_three)
 
97
    def _iter_changes(self, *args, **kwargs):
 
98
        return self.iter_changes(*args, **kwargs)
 
99
 
 
100
    def iter_changes(self, from_tree, include_unchanged=False,
 
101
                     specific_files=None, pb=None, extra_trees=None,
 
102
                     require_versioned=True, want_unversioned=False):
 
103
        intertree = InterTree.get(from_tree, self)
 
104
        return intertree.iter_changes(include_unchanged, specific_files, pb,
 
105
            extra_trees, require_versioned, want_unversioned=want_unversioned)
 
106
    
 
107
    def conflicts(self):
 
108
        """Get a list of the conflicts in the tree.
 
109
 
 
110
        Each conflict is an instance of bzrlib.conflicts.Conflict.
 
111
        """
 
112
        return _mod_conflicts.ConflictList()
 
113
 
 
114
    def extras(self):
 
115
        """For trees that can have unversioned files, return all such paths."""
 
116
        return []
 
117
 
 
118
    def get_parent_ids(self):
 
119
        """Get the parent ids for this tree. 
 
120
 
 
121
        :return: a list of parent ids. [] is returned to indicate
 
122
        a tree with no parents.
 
123
        :raises: BzrError if the parents are not known.
 
124
        """
 
125
        raise NotImplementedError(self.get_parent_ids)
 
126
    
 
127
    def has_filename(self, filename):
 
128
        """True if the tree has given filename."""
 
129
        raise NotImplementedError(self.has_filename)
 
130
 
 
131
    def has_id(self, file_id):
 
132
        return self.inventory.has_id(file_id)
 
133
 
 
134
    __contains__ = has_id
 
135
 
 
136
    def has_or_had_id(self, file_id):
 
137
        if file_id == self.inventory.root.file_id:
 
138
            return True
 
139
        return self.inventory.has_id(file_id)
 
140
 
 
141
    def is_ignored(self, filename):
 
142
        """Check whether the filename is ignored by this tree.
 
143
 
 
144
        :param filename: The relative filename within the tree.
 
145
        :return: True if the filename is ignored.
 
146
        """
 
147
        return False
 
148
 
 
149
    def __iter__(self):
 
150
        return iter(self.inventory)
 
151
 
 
152
    def all_file_ids(self):
 
153
        """Iterate through all file ids, including ids for missing files."""
 
154
        return set(self.inventory)
 
155
 
 
156
    def id2path(self, file_id):
 
157
        """Return the path for a file id.
 
158
 
 
159
        :raises NoSuchId:
 
160
        """
 
161
        return self.inventory.id2path(file_id)
 
162
 
 
163
    def is_control_filename(self, filename):
 
164
        """True if filename is the name of a control file in this tree.
 
165
        
 
166
        :param filename: A filename within the tree. This is a relative path
 
167
        from the root of this tree.
 
168
 
 
169
        This is true IF and ONLY IF the filename is part of the meta data
 
170
        that bzr controls in this tree. I.E. a random .bzr directory placed
 
171
        on disk will not be a control file for this tree.
 
172
        """
 
173
        return self.bzrdir.is_control_filename(filename)
 
174
 
 
175
    @needs_read_lock
 
176
    def iter_entries_by_dir(self, specific_file_ids=None):
 
177
        """Walk the tree in 'by_dir' order.
 
178
 
 
179
        This will yield each entry in the tree as a (path, entry) tuple. The
 
180
        order that they are yielded is: the contents of a directory are 
 
181
        preceeded by the parent of a directory, and all the contents of a 
 
182
        directory are grouped together.
 
183
        """
 
184
        return self.inventory.iter_entries_by_dir(
 
185
            specific_file_ids=specific_file_ids)
 
186
 
 
187
    def iter_references(self):
 
188
        for path, entry in self.iter_entries_by_dir():
 
189
            if entry.kind == 'tree-reference':
 
190
                yield path, entry.file_id
 
191
 
 
192
    def kind(self, file_id):
 
193
        raise NotImplementedError("Tree subclass %s must implement kind"
 
194
            % self.__class__.__name__)
 
195
 
 
196
    def stored_kind(self, file_id):
 
197
        """File kind stored for this file_id.
 
198
 
 
199
        May not match kind on disk for working trees.  Always available
 
200
        for versioned files, even when the file itself is missing.
 
201
        """
 
202
        return self.kind(file_id)
 
203
 
 
204
    def path_content_summary(self, path):
 
205
        """Get a summary of the information about path.
 
206
        
 
207
        :param path: A relative path within the tree.
 
208
        :return: A tuple containing kind, size, exec, sha1-or-link.
 
209
            Kind is always present (see tree.kind()).
 
210
            size is present if kind is file, None otherwise.
 
211
            exec is None unless kind is file and the platform supports the 'x'
 
212
                bit.
 
213
            sha1-or-link is the link target if kind is symlink, or the sha1 if
 
214
                it can be obtained without reading the file.
 
215
        """
 
216
        raise NotImplementedError(self.path_content_summary)
 
217
 
 
218
    def get_reference_revision(self, file_id, path=None):
 
219
        raise NotImplementedError("Tree subclass %s must implement "
 
220
                                  "get_reference_revision"
 
221
            % self.__class__.__name__)
 
222
 
 
223
    def _comparison_data(self, entry, path):
 
224
        """Return a tuple of kind, executable, stat_value for a file.
 
225
 
 
226
        entry may be None if there is no inventory entry for the file, but
 
227
        path must always be supplied.
 
228
 
 
229
        kind is None if there is no file present (even if an inventory id is
 
230
        present).  executable is False for non-file entries.
 
231
        """
 
232
        raise NotImplementedError(self._comparison_data)
 
233
 
 
234
    def _file_size(self, entry, stat_value):
 
235
        raise NotImplementedError(self._file_size)
 
236
 
 
237
    def _get_inventory(self):
 
238
        return self._inventory
 
239
    
 
240
    def get_file(self, file_id, path=None):
 
241
        """Return a file object for the file file_id in the tree.
 
242
        
 
243
        If both file_id and path are defined, it is implementation defined as
 
244
        to which one is used.
 
245
        """
 
246
        raise NotImplementedError(self.get_file)
 
247
 
 
248
    def get_file_mtime(self, file_id, path=None):
 
249
        """Return the modification time for a file.
 
250
 
 
251
        :param file_id: The handle for this file.
 
252
        :param path: The path that this file can be found at.
 
253
            These must point to the same object.
 
254
        """
 
255
        raise NotImplementedError(self.get_file_mtime)
 
256
 
 
257
    def get_file_by_path(self, path):
 
258
        return self.get_file(self._inventory.path2id(path), path)
 
259
 
 
260
    def iter_files_bytes(self, desired_files):
 
261
        """Iterate through file contents.
 
262
 
 
263
        Files will not necessarily be returned in the order they occur in
 
264
        desired_files.  No specific order is guaranteed.
 
265
 
 
266
        Yields pairs of identifier, bytes_iterator.  identifier is an opaque
 
267
        value supplied by the caller as part of desired_files.  It should
 
268
        uniquely identify the file version in the caller's context.  (Examples:
 
269
        an index number or a TreeTransform trans_id.)
 
270
 
 
271
        bytes_iterator is an iterable of bytestrings for the file.  The
 
272
        kind of iterable and length of the bytestrings are unspecified, but for
 
273
        this implementation, it is a tuple containing a single bytestring with
 
274
        the complete text of the file.
 
275
 
 
276
        :param desired_files: a list of (file_id, identifier) pairs
 
277
        """
 
278
        for file_id, identifier in desired_files:
 
279
            # We wrap the string in a tuple so that we can return an iterable
 
280
            # of bytestrings.  (Technically, a bytestring is also an iterable
 
281
            # of bytestrings, but iterating through each character is not
 
282
            # performant.)
 
283
            cur_file = (self.get_file_text(file_id),)
 
284
            yield identifier, cur_file
 
285
 
 
286
    def get_symlink_target(self, file_id):
 
287
        """Get the target for a given file_id.
 
288
 
 
289
        It is assumed that the caller already knows that file_id is referencing
 
290
        a symlink.
 
291
        :param file_id: Handle for the symlink entry.
 
292
        :return: The path the symlink points to.
 
293
        """
 
294
        raise NotImplementedError(self.get_symlink_target)
 
295
 
 
296
    def get_root_id(self):
 
297
        """Return the file_id for the root of this tree."""
 
298
        raise NotImplementedError(self.get_root_id)
 
299
 
 
300
    def annotate_iter(self, file_id,
 
301
                      default_revision=_mod_revision.CURRENT_REVISION):
 
302
        """Return an iterator of revision_id, line tuples.
 
303
 
 
304
        For working trees (and mutable trees in general), the special
 
305
        revision_id 'current:' will be used for lines that are new in this
 
306
        tree, e.g. uncommitted changes.
 
307
        :param file_id: The file to produce an annotated version from
 
308
        :param default_revision: For lines that don't match a basis, mark them
 
309
            with this revision id. Not all implementations will make use of
 
310
            this value.
 
311
        """
 
312
        raise NotImplementedError(self.annotate_iter)
 
313
 
 
314
    def _get_plan_merge_data(self, file_id, other, base):
 
315
        from bzrlib import merge, versionedfile
 
316
        vf = versionedfile._PlanMergeVersionedFile(file_id)
 
317
        last_revision_a = self._get_file_revision(file_id, vf, 'this:')
 
318
        last_revision_b = other._get_file_revision(file_id, vf, 'other:')
 
319
        if base is None:
 
320
            last_revision_base = None
 
321
        else:
 
322
            last_revision_base = base._get_file_revision(file_id, vf, 'base:')
 
323
        return vf, last_revision_a, last_revision_b, last_revision_base
 
324
 
 
325
    def plan_file_merge(self, file_id, other, base=None):
 
326
        """Generate a merge plan based on annotations.
 
327
 
 
328
        If the file contains uncommitted changes in this tree, they will be
 
329
        attributed to the 'current:' pseudo-revision.  If the file contains
 
330
        uncommitted changes in the other tree, they will be assigned to the
 
331
        'other:' pseudo-revision.
 
332
        """
 
333
        data = self._get_plan_merge_data(file_id, other, base)
 
334
        vf, last_revision_a, last_revision_b, last_revision_base = data
 
335
        return vf.plan_merge(last_revision_a, last_revision_b,
 
336
                             last_revision_base)
 
337
 
 
338
    def plan_file_lca_merge(self, file_id, other, base=None):
 
339
        """Generate a merge plan based lca-newness.
 
340
 
 
341
        If the file contains uncommitted changes in this tree, they will be
 
342
        attributed to the 'current:' pseudo-revision.  If the file contains
 
343
        uncommitted changes in the other tree, they will be assigned to the
 
344
        'other:' pseudo-revision.
 
345
        """
 
346
        data = self._get_plan_merge_data(file_id, other, base)
 
347
        vf, last_revision_a, last_revision_b, last_revision_base = data
 
348
        return vf.plan_lca_merge(last_revision_a, last_revision_b,
 
349
                                 last_revision_base)
 
350
 
 
351
    def _get_file_revision(self, file_id, vf, tree_revision):
 
352
        def file_revision(revision_tree):
 
353
            revision_tree.lock_read()
 
354
            try:
 
355
                return revision_tree.inventory[file_id].revision
 
356
            finally:
 
357
                revision_tree.unlock()
 
358
 
 
359
        def iter_parent_trees():
 
360
            for revision_id in self.get_parent_ids():
 
361
                try:
 
362
                    yield self.revision_tree(revision_id)
 
363
                except:
 
364
                    yield self.repository.revision_tree(revision_id)
 
365
 
 
366
        if getattr(self, '_get_weave', None) is None:
 
367
            last_revision = tree_revision
 
368
            parent_revisions = [file_revision(t) for t in iter_parent_trees()]
 
369
            vf.add_lines(last_revision, parent_revisions,
 
370
                         self.get_file(file_id).readlines())
 
371
            repo = self.branch.repository
 
372
            transaction = repo.get_transaction()
 
373
            base_vf = repo.weave_store.get_weave(file_id, transaction)
 
374
        else:
 
375
            last_revision = file_revision(self)
 
376
            base_vf = self._get_weave(file_id)
 
377
        vf.fallback_versionedfiles.append(base_vf)
 
378
        return last_revision
 
379
 
 
380
    inventory = property(_get_inventory,
 
381
                         doc="Inventory of this Tree")
 
382
 
 
383
    def _check_retrieved(self, ie, f):
 
384
        if not __debug__:
 
385
            return  
 
386
        fp = fingerprint_file(f)
 
387
        f.seek(0)
 
388
        
 
389
        if ie.text_size is not None:
 
390
            if ie.text_size != fp['size']:
 
391
                raise BzrError("mismatched size for file %r in %r" % (ie.file_id, self._store),
 
392
                        ["inventory expects %d bytes" % ie.text_size,
 
393
                         "file is actually %d bytes" % fp['size'],
 
394
                         "store is probably damaged/corrupt"])
 
395
 
 
396
        if ie.text_sha1 != fp['sha1']:
 
397
            raise BzrError("wrong SHA-1 for file %r in %r" % (ie.file_id, self._store),
 
398
                    ["inventory expects %s" % ie.text_sha1,
 
399
                     "file is actually %s" % fp['sha1'],
 
400
                     "store is probably damaged/corrupt"])
 
401
 
 
402
    @needs_read_lock
 
403
    def path2id(self, path):
 
404
        """Return the id for path in this tree."""
 
405
        return self._inventory.path2id(path)
 
406
 
 
407
    def paths2ids(self, paths, trees=[], require_versioned=True):
 
408
        """Return all the ids that can be reached by walking from paths.
 
409
        
 
410
        Each path is looked up in this tree and any extras provided in
 
411
        trees, and this is repeated recursively: the children in an extra tree
 
412
        of a directory that has been renamed under a provided path in this tree
 
413
        are all returned, even if none exist under a provided path in this
 
414
        tree, and vice versa.
 
415
 
 
416
        :param paths: An iterable of paths to start converting to ids from.
 
417
            Alternatively, if paths is None, no ids should be calculated and None
 
418
            will be returned. This is offered to make calling the api unconditional
 
419
            for code that *might* take a list of files.
 
420
        :param trees: Additional trees to consider.
 
421
        :param require_versioned: If False, do not raise NotVersionedError if
 
422
            an element of paths is not versioned in this tree and all of trees.
 
423
        """
 
424
        return find_ids_across_trees(paths, [self] + list(trees), require_versioned)
 
425
 
 
426
    def print_file(self, file_id):
 
427
        """Print file with id `file_id` to stdout."""
 
428
        import sys
 
429
        sys.stdout.write(self.get_file_text(file_id))
 
430
 
 
431
    def lock_read(self):
 
432
        pass
 
433
 
 
434
    def revision_tree(self, revision_id):
 
435
        """Obtain a revision tree for the revision revision_id.
 
436
 
 
437
        The intention of this method is to allow access to possibly cached
 
438
        tree data. Implementors of this method should raise NoSuchRevision if
 
439
        the tree is not locally available, even if they could obtain the 
 
440
        tree via a repository or some other means. Callers are responsible 
 
441
        for finding the ultimate source for a revision tree.
 
442
 
 
443
        :param revision_id: The revision_id of the requested tree.
 
444
        :return: A Tree.
 
445
        :raises: NoSuchRevision if the tree cannot be obtained.
 
446
        """
 
447
        raise errors.NoSuchRevisionInTree(self, revision_id)
 
448
 
 
449
    def unknowns(self):
 
450
        """What files are present in this tree and unknown.
 
451
        
 
452
        :return: an iterator over the unknown files.
 
453
        """
 
454
        return iter([])
 
455
 
 
456
    def unlock(self):
 
457
        pass
 
458
 
 
459
    def filter_unversioned_files(self, paths):
 
460
        """Filter out paths that are versioned.
 
461
 
 
462
        :return: set of paths.
 
463
        """
 
464
        # NB: we specifically *don't* call self.has_filename, because for
 
465
        # WorkingTrees that can indicate files that exist on disk but that 
 
466
        # are not versioned.
 
467
        pred = self.inventory.has_filename
 
468
        return set((p for p in paths if not pred(p)))
 
469
 
 
470
    def walkdirs(self, prefix=""):
 
471
        """Walk the contents of this tree from path down.
 
472
 
 
473
        This yields all the data about the contents of a directory at a time.
 
474
        After each directory has been yielded, if the caller has mutated the
 
475
        list to exclude some directories, they are then not descended into.
 
476
        
 
477
        The data yielded is of the form:
 
478
        ((directory-relpath, directory-path-from-root, directory-fileid),
 
479
        [(relpath, basename, kind, lstat, path_from_tree_root, file_id, 
 
480
          versioned_kind), ...]),
 
481
         - directory-relpath is the containing dirs relpath from prefix
 
482
         - directory-path-from-root is the containing dirs path from /
 
483
         - directory-fileid is the id of the directory if it is versioned.
 
484
         - relpath is the relative path within the subtree being walked.
 
485
         - basename is the basename
 
486
         - kind is the kind of the file now. If unknonwn then the file is not
 
487
           present within the tree - but it may be recorded as versioned. See
 
488
           versioned_kind.
 
489
         - lstat is the stat data *if* the file was statted.
 
490
         - path_from_tree_root is the path from the root of the tree.
 
491
         - file_id is the file_id if the entry is versioned.
 
492
         - versioned_kind is the kind of the file as last recorded in the 
 
493
           versioning system. If 'unknown' the file is not versioned.
 
494
        One of 'kind' and 'versioned_kind' must not be 'unknown'.
 
495
 
 
496
        :param prefix: Start walking from prefix within the tree rather than
 
497
        at the root. This allows one to walk a subtree but get paths that are
 
498
        relative to a tree rooted higher up.
 
499
        :return: an iterator over the directory data.
 
500
        """
 
501
        raise NotImplementedError(self.walkdirs)
 
502
 
 
503
 
 
504
class EmptyTree(Tree):
 
505
 
 
506
    def __init__(self):
 
507
        self._inventory = Inventory(root_id=None)
 
508
        symbol_versioning.warn('EmptyTree is deprecated as of bzr 0.9 please'
 
509
                               ' use repository.revision_tree instead.',
 
510
                               DeprecationWarning, stacklevel=2)
 
511
 
 
512
    def get_parent_ids(self):
 
513
        return []
 
514
 
 
515
    def get_symlink_target(self, file_id):
 
516
        return None
 
517
 
 
518
    def has_filename(self, filename):
 
519
        return False
 
520
 
 
521
    def kind(self, file_id):
 
522
        assert self._inventory[file_id].kind == "directory"
 
523
        return "directory"
 
524
 
 
525
    def list_files(self, include_root=False):
 
526
        return iter([])
 
527
    
 
528
    def __contains__(self, file_id):
 
529
        return (file_id in self._inventory)
 
530
 
 
531
    def get_file_sha1(self, file_id, path=None, stat_value=None):
 
532
        return None
 
533
 
 
534
 
 
535
######################################################################
 
536
# diff
 
537
 
 
538
# TODO: Merge these two functions into a single one that can operate
 
539
# on either a whole tree or a set of files.
 
540
 
 
541
# TODO: Return the diff in order by filename, not by category or in
 
542
# random order.  Can probably be done by lock-stepping through the
 
543
# filenames from both trees.
 
544
 
 
545
 
 
546
def file_status(filename, old_tree, new_tree):
 
547
    """Return single-letter status, old and new names for a file.
 
548
 
 
549
    The complexity here is in deciding how to represent renames;
 
550
    many complex cases are possible.
 
551
    """
 
552
    old_inv = old_tree.inventory
 
553
    new_inv = new_tree.inventory
 
554
    new_id = new_inv.path2id(filename)
 
555
    old_id = old_inv.path2id(filename)
 
556
 
 
557
    if not new_id and not old_id:
 
558
        # easy: doesn't exist in either; not versioned at all
 
559
        if new_tree.is_ignored(filename):
 
560
            return 'I', None, None
 
561
        else:
 
562
            return '?', None, None
 
563
    elif new_id:
 
564
        # There is now a file of this name, great.
 
565
        pass
 
566
    else:
 
567
        # There is no longer a file of this name, but we can describe
 
568
        # what happened to the file that used to have
 
569
        # this name.  There are two possibilities: either it was
 
570
        # deleted entirely, or renamed.
 
571
        assert old_id
 
572
        if new_inv.has_id(old_id):
 
573
            return 'X', old_inv.id2path(old_id), new_inv.id2path(old_id)
 
574
        else:
 
575
            return 'D', old_inv.id2path(old_id), None
 
576
 
 
577
    # if the file_id is new in this revision, it is added
 
578
    if new_id and not old_inv.has_id(new_id):
 
579
        return 'A'
 
580
 
 
581
    # if there used to be a file of this name, but that ID has now
 
582
    # disappeared, it is deleted
 
583
    if old_id and not new_inv.has_id(old_id):
 
584
        return 'D'
 
585
 
 
586
    return 'wtf?'
 
587
 
 
588
    
 
589
 
 
590
def find_renames(old_inv, new_inv):
 
591
    for file_id in old_inv:
 
592
        if file_id not in new_inv:
 
593
            continue
 
594
        old_name = old_inv.id2path(file_id)
 
595
        new_name = new_inv.id2path(file_id)
 
596
        if old_name != new_name:
 
597
            yield (old_name, new_name)
 
598
            
 
599
 
 
600
def find_ids_across_trees(filenames, trees, require_versioned=True):
 
601
    """Find the ids corresponding to specified filenames.
 
602
    
 
603
    All matches in all trees will be used, and all children of matched
 
604
    directories will be used.
 
605
 
 
606
    :param filenames: The filenames to find file_ids for (if None, returns
 
607
        None)
 
608
    :param trees: The trees to find file_ids within
 
609
    :param require_versioned: if true, all specified filenames must occur in
 
610
    at least one tree.
 
611
    :return: a set of file ids for the specified filenames and their children.
 
612
    """
 
613
    if not filenames:
 
614
        return None
 
615
    specified_path_ids = _find_ids_across_trees(filenames, trees,
 
616
        require_versioned)
 
617
    return _find_children_across_trees(specified_path_ids, trees)
 
618
 
 
619
 
 
620
def _find_ids_across_trees(filenames, trees, require_versioned):
 
621
    """Find the ids corresponding to specified filenames.
 
622
    
 
623
    All matches in all trees will be used, but subdirectories are not scanned.
 
624
 
 
625
    :param filenames: The filenames to find file_ids for
 
626
    :param trees: The trees to find file_ids within
 
627
    :param require_versioned: if true, all specified filenames must occur in
 
628
        at least one tree.
 
629
    :return: a set of file ids for the specified filenames
 
630
    """
 
631
    not_versioned = []
 
632
    interesting_ids = set()
 
633
    for tree_path in filenames:
 
634
        not_found = True
 
635
        for tree in trees:
 
636
            file_id = tree.path2id(tree_path)
 
637
            if file_id is not None:
 
638
                interesting_ids.add(file_id)
 
639
                not_found = False
 
640
        if not_found:
 
641
            not_versioned.append(tree_path)
 
642
    if len(not_versioned) > 0 and require_versioned:
 
643
        raise errors.PathsNotVersionedError(not_versioned)
 
644
    return interesting_ids
 
645
 
 
646
 
 
647
def _find_children_across_trees(specified_ids, trees):
 
648
    """Return a set including specified ids and their children.
 
649
    
 
650
    All matches in all trees will be used.
 
651
 
 
652
    :param trees: The trees to find file_ids within
 
653
    :return: a set containing all specified ids and their children 
 
654
    """
 
655
    interesting_ids = set(specified_ids)
 
656
    pending = interesting_ids
 
657
    # now handle children of interesting ids
 
658
    # we loop so that we handle all children of each id in both trees
 
659
    while len(pending) > 0:
 
660
        new_pending = set()
 
661
        for file_id in pending:
 
662
            for tree in trees:
 
663
                if not tree.has_id(file_id):
 
664
                    continue
 
665
                entry = tree.inventory[file_id]
 
666
                for child in getattr(entry, 'children', {}).itervalues():
 
667
                    if child.file_id not in interesting_ids:
 
668
                        new_pending.add(child.file_id)
 
669
        interesting_ids.update(new_pending)
 
670
        pending = new_pending
 
671
    return interesting_ids
 
672
 
 
673
 
 
674
class InterTree(InterObject):
 
675
    """This class represents operations taking place between two Trees.
 
676
 
 
677
    Its instances have methods like 'compare' and contain references to the
 
678
    source and target trees these operations are to be carried out on.
 
679
 
 
680
    Clients of bzrlib should not need to use InterTree directly, rather they
 
681
    should use the convenience methods on Tree such as 'Tree.compare()' which
 
682
    will pass through to InterTree as appropriate.
 
683
    """
 
684
 
 
685
    _optimisers = []
 
686
 
 
687
    @needs_read_lock
 
688
    def compare(self, want_unchanged=False, specific_files=None,
 
689
        extra_trees=None, require_versioned=False, include_root=False,
 
690
        want_unversioned=False):
 
691
        """Return the changes from source to target.
 
692
 
 
693
        :return: A TreeDelta.
 
694
        :param specific_files: An optional list of file paths to restrict the
 
695
            comparison to. When mapping filenames to ids, all matches in all
 
696
            trees (including optional extra_trees) are used, and all children of
 
697
            matched directories are included.
 
698
        :param want_unchanged: An optional boolean requesting the inclusion of
 
699
            unchanged entries in the result.
 
700
        :param extra_trees: An optional list of additional trees to use when
 
701
            mapping the contents of specific_files (paths) to file_ids.
 
702
        :param require_versioned: An optional boolean (defaults to False). When
 
703
            supplied and True all the 'specific_files' must be versioned, or
 
704
            a PathsNotVersionedError will be thrown.
 
705
        :param want_unversioned: Scan for unversioned paths.
 
706
        """
 
707
        # NB: show_status depends on being able to pass in non-versioned files
 
708
        # and report them as unknown
 
709
        trees = (self.source,)
 
710
        if extra_trees is not None:
 
711
            trees = trees + tuple(extra_trees)
 
712
        # target is usually the newer tree:
 
713
        specific_file_ids = self.target.paths2ids(specific_files, trees,
 
714
            require_versioned=require_versioned)
 
715
        if specific_files and not specific_file_ids:
 
716
            # All files are unversioned, so just return an empty delta
 
717
            # _compare_trees would think we want a complete delta
 
718
            result = delta.TreeDelta()
 
719
            fake_entry = InventoryFile('unused', 'unused', 'unused')
 
720
            result.unversioned = [(path, None,
 
721
                self.target._comparison_data(fake_entry, path)[0]) for path in
 
722
                specific_files]
 
723
            return result
 
724
        return delta._compare_trees(self.source, self.target, want_unchanged,
 
725
            specific_files, include_root, extra_trees=extra_trees,
 
726
            require_versioned=require_versioned,
 
727
            want_unversioned=want_unversioned)
 
728
 
 
729
    def iter_changes(self, include_unchanged=False,
 
730
                      specific_files=None, pb=None, extra_trees=[],
 
731
                      require_versioned=True, want_unversioned=False):
 
732
        """Generate an iterator of changes between trees.
 
733
 
 
734
        A tuple is returned:
 
735
        (file_id, (path_in_source, path_in_target),
 
736
         changed_content, versioned, parent, name, kind,
 
737
         executable)
 
738
 
 
739
        Changed_content is True if the file's content has changed.  This
 
740
        includes changes to its kind, and to a symlink's target.
 
741
 
 
742
        versioned, parent, name, kind, executable are tuples of (from, to).
 
743
        If a file is missing in a tree, its kind is None.
 
744
 
 
745
        Iteration is done in parent-to-child order, relative to the target
 
746
        tree.
 
747
 
 
748
        There is no guarantee that all paths are in sorted order: the
 
749
        requirement to expand the search due to renames may result in children
 
750
        that should be found early being found late in the search, after
 
751
        lexically later results have been returned.
 
752
        :param require_versioned: Raise errors.PathsNotVersionedError if a
 
753
            path in the specific_files list is not versioned in one of
 
754
            source, target or extra_trees.
 
755
        :param want_unversioned: Should unversioned files be returned in the
 
756
            output. An unversioned file is defined as one with (False, False)
 
757
            for the versioned pair.
 
758
        """
 
759
        result = []
 
760
        lookup_trees = [self.source]
 
761
        if extra_trees:
 
762
             lookup_trees.extend(extra_trees)
 
763
        if specific_files == []:
 
764
            specific_file_ids = []
 
765
        else:
 
766
            specific_file_ids = self.target.paths2ids(specific_files,
 
767
                lookup_trees, require_versioned=require_versioned)
 
768
        if want_unversioned:
 
769
            all_unversioned = sorted([(p.split('/'), p) for p in
 
770
                                     self.target.extras()
 
771
                if specific_files is None or
 
772
                    osutils.is_inside_any(specific_files, p)])
 
773
            all_unversioned = deque(all_unversioned)
 
774
        else:
 
775
            all_unversioned = deque()
 
776
        to_paths = {}
 
777
        from_entries_by_dir = list(self.source.inventory.iter_entries_by_dir(
 
778
            specific_file_ids=specific_file_ids))
 
779
        from_data = dict((e.file_id, (p, e)) for p, e in from_entries_by_dir)
 
780
        to_entries_by_dir = list(self.target.inventory.iter_entries_by_dir(
 
781
            specific_file_ids=specific_file_ids))
 
782
        num_entries = len(from_entries_by_dir) + len(to_entries_by_dir)
 
783
        entry_count = 0
 
784
        # the unversioned path lookup only occurs on real trees - where there 
 
785
        # can be extras. So the fake_entry is solely used to look up
 
786
        # executable it values when execute is not supported.
 
787
        fake_entry = InventoryFile('unused', 'unused', 'unused')
 
788
        for to_path, to_entry in to_entries_by_dir:
 
789
            while all_unversioned and all_unversioned[0][0] < to_path.split('/'):
 
790
                unversioned_path = all_unversioned.popleft()
 
791
                to_kind, to_executable, to_stat = \
 
792
                    self.target._comparison_data(fake_entry, unversioned_path[1])
 
793
                yield (None, (None, unversioned_path[1]), True, (False, False),
 
794
                    (None, None),
 
795
                    (None, unversioned_path[0][-1]),
 
796
                    (None, to_kind),
 
797
                    (None, to_executable))
 
798
            file_id = to_entry.file_id
 
799
            to_paths[file_id] = to_path
 
800
            entry_count += 1
 
801
            changed_content = False
 
802
            from_path, from_entry = from_data.get(file_id, (None, None))
 
803
            from_versioned = (from_entry is not None)
 
804
            if from_entry is not None:
 
805
                from_versioned = True
 
806
                from_name = from_entry.name
 
807
                from_parent = from_entry.parent_id
 
808
                from_kind, from_executable, from_stat = \
 
809
                    self.source._comparison_data(from_entry, from_path)
 
810
                entry_count += 1
 
811
            else:
 
812
                from_versioned = False
 
813
                from_kind = None
 
814
                from_parent = None
 
815
                from_name = None
 
816
                from_executable = None
 
817
            versioned = (from_versioned, True)
 
818
            to_kind, to_executable, to_stat = \
 
819
                self.target._comparison_data(to_entry, to_path)
 
820
            kind = (from_kind, to_kind)
 
821
            if kind[0] != kind[1]:
 
822
                changed_content = True
 
823
            elif from_kind == 'file':
 
824
                from_size = self.source._file_size(from_entry, from_stat)
 
825
                to_size = self.target._file_size(to_entry, to_stat)
 
826
                if from_size != to_size:
 
827
                    changed_content = True
 
828
                elif (self.source.get_file_sha1(file_id, from_path, from_stat) !=
 
829
                    self.target.get_file_sha1(file_id, to_path, to_stat)):
 
830
                    changed_content = True
 
831
            elif from_kind == 'symlink':
 
832
                if (self.source.get_symlink_target(file_id) !=
 
833
                    self.target.get_symlink_target(file_id)):
 
834
                    changed_content = True
 
835
                elif from_kind == 'tree-reference':
 
836
                    if (self.source.get_reference_revision(file_id, from_path)
 
837
                        != self.target.get_reference_revision(file_id, to_path)):
 
838
                        changed_content = True 
 
839
            parent = (from_parent, to_entry.parent_id)
 
840
            name = (from_name, to_entry.name)
 
841
            executable = (from_executable, to_executable)
 
842
            if pb is not None:
 
843
                pb.update('comparing files', entry_count, num_entries)
 
844
            if (changed_content is not False or versioned[0] != versioned[1]
 
845
                or parent[0] != parent[1] or name[0] != name[1] or 
 
846
                executable[0] != executable[1] or include_unchanged):
 
847
                yield (file_id, (from_path, to_path), changed_content,
 
848
                    versioned, parent, name, kind, executable)
 
849
 
 
850
        while all_unversioned:
 
851
            # yield any trailing unversioned paths
 
852
            unversioned_path = all_unversioned.popleft()
 
853
            to_kind, to_executable, to_stat = \
 
854
                self.target._comparison_data(fake_entry, unversioned_path[1])
 
855
            yield (None, (None, unversioned_path[1]), True, (False, False),
 
856
                (None, None),
 
857
                (None, unversioned_path[0][-1]),
 
858
                (None, to_kind),
 
859
                (None, to_executable))
 
860
 
 
861
        def get_to_path(to_entry):
 
862
            if to_entry.parent_id is None:
 
863
                to_path = '' # the root
 
864
            else:
 
865
                if to_entry.parent_id not in to_paths:
 
866
                    # recurse up
 
867
                    return get_to_path(self.target.inventory[to_entry.parent_id])
 
868
                to_path = osutils.pathjoin(to_paths[to_entry.parent_id],
 
869
                                           to_entry.name)
 
870
            to_paths[to_entry.file_id] = to_path
 
871
            return to_path
 
872
 
 
873
        for path, from_entry in from_entries_by_dir:
 
874
            file_id = from_entry.file_id
 
875
            if file_id in to_paths:
 
876
                # already returned
 
877
                continue
 
878
            if not file_id in self.target.inventory:
 
879
                # common case - paths we have not emitted are not present in
 
880
                # target.
 
881
                to_path = None
 
882
            else:
 
883
                to_path = get_to_path(self.target.inventory[file_id])
 
884
            entry_count += 1
 
885
            if pb is not None:
 
886
                pb.update('comparing files', entry_count, num_entries)
 
887
            versioned = (True, False)
 
888
            parent = (from_entry.parent_id, None)
 
889
            name = (from_entry.name, None)
 
890
            from_kind, from_executable, stat_value = \
 
891
                self.source._comparison_data(from_entry, path)
 
892
            kind = (from_kind, None)
 
893
            executable = (from_executable, None)
 
894
            changed_content = True
 
895
            # the parent's path is necessarily known at this point.
 
896
            yield(file_id, (path, to_path), changed_content, versioned, parent,
 
897
                  name, kind, executable)
 
898
 
 
899
 
 
900
# This was deprecated before 0.12, but did not have an official warning
 
901
@symbol_versioning.deprecated_function(symbol_versioning.zero_twelve)
 
902
def RevisionTree(*args, **kwargs):
 
903
    """RevisionTree has moved to bzrlib.revisiontree.RevisionTree()
 
904
 
 
905
    Accessing it as bzrlib.tree.RevisionTree has been deprecated as of
 
906
    bzr 0.12.
 
907
    """
 
908
    from bzrlib.revisiontree import RevisionTree as _RevisionTree
 
909
    return _RevisionTree(*args, **kwargs)
 
910
 
 
911