/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: Martin Pool
  • Date: 2006-12-15 08:36:50 UTC
  • mto: (2193.3.1 short-options)
  • mto: This revision was merged to the branch mainline in revision 2203.
  • Revision ID: mbp@sourcefrog.net-20061215083650-14cbsfiijfq3kdf9
remove global registration of short options

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tree.py
1
1
# Copyright (C) 2005 Canonical Ltd
2
 
 
 
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
 
 
7
#
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
12
 
 
 
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
18
"""
19
19
 
20
20
import os
 
21
from cStringIO import StringIO
21
22
 
22
23
import bzrlib
 
24
from bzrlib import (
 
25
    delta,
 
26
    osutils,
 
27
    symbol_versioning,
 
28
    )
 
29
from bzrlib.decorators import needs_read_lock
 
30
from bzrlib.errors import BzrError, BzrCheckError
 
31
from bzrlib import errors
 
32
from bzrlib.inventory import Inventory
 
33
from bzrlib.inter import InterObject
 
34
from bzrlib.osutils import fingerprint_file
 
35
import bzrlib.revision
23
36
from bzrlib.trace import mutter, note
24
 
from bzrlib.errors import BzrError
25
 
from bzrlib.inventory import Inventory
26
 
from bzrlib.osutils import pumpfile, appendpath, fingerprint_file
27
 
 
28
 
 
29
 
exporters = {}
 
37
 
30
38
 
31
39
class Tree(object):
32
40
    """Abstract file tree.
37
45
 
38
46
    * `RevisionTree` is a tree as recorded at some point in the past.
39
47
 
40
 
    * `EmptyTree`
41
 
 
42
48
    Trees contain an `Inventory` object, and also know how to retrieve
43
49
    file texts mentioned in the inventory, either from a working
44
50
    directory or from a store.
50
56
    trees or versioned trees.
51
57
    """
52
58
    
 
59
    def changes_from(self, other, want_unchanged=False, specific_files=None,
 
60
        extra_trees=None, require_versioned=False, include_root=False):
 
61
        """Return a TreeDelta of the changes from other to this tree.
 
62
 
 
63
        :param other: A tree to compare with.
 
64
        :param specific_files: An optional list of file paths to restrict the
 
65
            comparison to. When mapping filenames to ids, all matches in all
 
66
            trees (including optional extra_trees) are used, and all children of
 
67
            matched directories are included.
 
68
        :param want_unchanged: An optional boolean requesting the inclusion of
 
69
            unchanged entries in the result.
 
70
        :param extra_trees: An optional list of additional trees to use when
 
71
            mapping the contents of specific_files (paths) to file_ids.
 
72
        :param require_versioned: An optional boolean (defaults to False). When
 
73
            supplied and True all the 'specific_files' must be versioned, or
 
74
            a PathsNotVersionedError will be thrown.
 
75
 
 
76
        The comparison will be performed by an InterTree object looked up on 
 
77
        self and other.
 
78
        """
 
79
        # Martin observes that Tree.changes_from returns a TreeDelta and this
 
80
        # may confuse people, because the class name of the returned object is
 
81
        # a synonym of the object referenced in the method name.
 
82
        return InterTree.get(other, self).compare(
 
83
            want_unchanged=want_unchanged,
 
84
            specific_files=specific_files,
 
85
            extra_trees=extra_trees,
 
86
            require_versioned=require_versioned,
 
87
            include_root=include_root
 
88
            )
 
89
 
 
90
    def _iter_changes(self, from_tree, include_unchanged=False, 
 
91
                     specific_file_ids=None, pb=None):
 
92
        intertree = InterTree.get(from_tree, self)
 
93
        return intertree._iter_changes(from_tree, self, include_unchanged, 
 
94
                                       specific_file_ids, pb)
 
95
    
 
96
    def conflicts(self):
 
97
        """Get a list of the conflicts in the tree.
 
98
 
 
99
        Each conflict is an instance of bzrlib.conflicts.Conflict.
 
100
        """
 
101
        return []
 
102
 
 
103
    def get_parent_ids(self):
 
104
        """Get the parent ids for this tree. 
 
105
 
 
106
        :return: a list of parent ids. [] is returned to indicate
 
107
        a tree with no parents.
 
108
        :raises: BzrError if the parents are not known.
 
109
        """
 
110
        raise NotImplementedError(self.get_parent_ids)
 
111
    
53
112
    def has_filename(self, filename):
54
113
        """True if the tree has given filename."""
55
114
        raise NotImplementedError()
59
118
 
60
119
    __contains__ = has_id
61
120
 
 
121
    def has_or_had_id(self, file_id):
 
122
        if file_id == self.inventory.root.file_id:
 
123
            return True
 
124
        return self.inventory.has_id(file_id)
 
125
 
62
126
    def __iter__(self):
63
127
        return iter(self.inventory)
64
128
 
65
129
    def id2path(self, file_id):
66
130
        return self.inventory.id2path(file_id)
67
131
 
 
132
    def is_control_filename(self, filename):
 
133
        """True if filename is the name of a control file in this tree.
 
134
        
 
135
        :param filename: A filename within the tree. This is a relative path
 
136
        from the root of this tree.
 
137
 
 
138
        This is true IF and ONLY IF the filename is part of the meta data
 
139
        that bzr controls in this tree. I.E. a random .bzr directory placed
 
140
        on disk will not be a control file for this tree.
 
141
        """
 
142
        return self.bzrdir.is_control_filename(filename)
 
143
 
 
144
    def iter_entries_by_dir(self):
 
145
        """Walk the tree in 'by_dir' order.
 
146
 
 
147
        This will yield each entry in the tree as a (path, entry) tuple. The
 
148
        order that they are yielded is: the contents of a directory are 
 
149
        preceeded by the parent of a directory, and all the contents of a 
 
150
        directory are grouped together.
 
151
        """
 
152
        return self.inventory.iter_entries_by_dir()
 
153
 
 
154
    def kind(self, file_id):
 
155
        raise NotImplementedError("subclasses must implement kind")
 
156
 
 
157
    def _comparison_data(self, entry, path):
 
158
        """Return a tuple of kind, executable, stat_value for a file.
 
159
 
 
160
        entry may be None if there is no inventory entry for the file, but
 
161
        path must always be supplied.
 
162
 
 
163
        kind is None if there is no file present (even if an inventory id is
 
164
        present).  executable is False for non-file entries.
 
165
        """
 
166
        raise NotImplementedError(self._comparison_data)
 
167
 
 
168
    def _file_size(entry, stat_value):
 
169
        raise NotImplementedError(self._file_size)
 
170
 
68
171
    def _get_inventory(self):
69
172
        return self._inventory
70
173
    
 
174
    def get_file(self, file_id):
 
175
        """Return a file object for the file file_id in the tree."""
 
176
        raise NotImplementedError(self.get_file)
 
177
    
71
178
    def get_file_by_path(self, path):
72
179
        return self.get_file(self._inventory.path2id(path))
73
180
 
75
182
                         doc="Inventory of this Tree")
76
183
 
77
184
    def _check_retrieved(self, ie, f):
 
185
        if not __debug__:
 
186
            return  
78
187
        fp = fingerprint_file(f)
79
188
        f.seek(0)
80
189
        
81
 
        if ie.text_size != None:
 
190
        if ie.text_size is not None:
82
191
            if ie.text_size != fp['size']:
83
192
                raise BzrError("mismatched size for file %r in %r" % (ie.file_id, self._store),
84
193
                        ["inventory expects %d bytes" % ie.text_size,
91
200
                     "file is actually %s" % fp['sha1'],
92
201
                     "store is probably damaged/corrupt"])
93
202
 
 
203
    def path2id(self, path):
 
204
        """Return the id for path in this tree."""
 
205
        return self._inventory.path2id(path)
94
206
 
95
 
    def print_file(self, fileid):
96
 
        """Print file with id `fileid` to stdout."""
 
207
    def print_file(self, file_id):
 
208
        """Print file with id `file_id` to stdout."""
97
209
        import sys
98
 
        pumpfile(self.get_file(fileid), sys.stdout)
99
 
        
100
 
        
101
 
    def export(self, dest, format='dir', root=None):
102
 
        """Export this tree."""
103
 
        try:
104
 
            exporter = exporters[format]
105
 
        except KeyError:
106
 
            from bzrlib.errors import BzrCommandError
107
 
            raise BzrCommandError("export format %r not supported" % format)
108
 
        exporter(self, dest, root)
109
 
 
110
 
 
111
 
 
112
 
class RevisionTree(Tree):
113
 
    """Tree viewing a previous revision.
114
 
 
115
 
    File text can be retrieved from the text store.
116
 
 
117
 
    TODO: Some kind of `__repr__` method, but a good one
118
 
           probably means knowing the branch and revision number,
119
 
           or at least passing a description to the constructor.
120
 
    """
121
 
    
122
 
    def __init__(self, store, inv):
123
 
        self._store = store
124
 
        self._inventory = inv
125
 
 
126
 
    def get_file(self, file_id):
127
 
        ie = self._inventory[file_id]
128
 
        f = self._store[ie.text_id]
129
 
        mutter("  get fileid{%s} from %r" % (file_id, self))
130
 
        self._check_retrieved(ie, f)
131
 
        return f
132
 
 
133
 
    def get_file_size(self, file_id):
134
 
        return self._inventory[file_id].text_size
135
 
 
136
 
    def get_file_sha1(self, file_id):
137
 
        ie = self._inventory[file_id]
138
 
        return ie.text_sha1
139
 
 
140
 
    def has_filename(self, filename):
141
 
        return bool(self.inventory.path2id(filename))
142
 
 
143
 
    def list_files(self):
144
 
        # The only files returned by this are those from the version
145
 
        for path, entry in self.inventory.iter_entries():
146
 
            yield path, 'V', entry.kind, entry.file_id
 
210
        sys.stdout.write(self.get_file_text(file_id))
 
211
 
 
212
    def lock_read(self):
 
213
        pass
 
214
 
 
215
    def unknowns(self):
 
216
        """What files are present in this tree and unknown.
 
217
        
 
218
        :return: an iterator over the unknown files.
 
219
        """
 
220
        return iter([])
 
221
 
 
222
    def unlock(self):
 
223
        pass
 
224
 
 
225
    def filter_unversioned_files(self, paths):
 
226
        """Filter out paths that are not versioned.
 
227
 
 
228
        :return: set of paths.
 
229
        """
 
230
        # NB: we specifically *don't* call self.has_filename, because for
 
231
        # WorkingTrees that can indicate files that exist on disk but that 
 
232
        # are not versioned.
 
233
        pred = self.inventory.has_filename
 
234
        return set((p for p in paths if not pred(p)))
147
235
 
148
236
 
149
237
class EmptyTree(Tree):
 
238
 
150
239
    def __init__(self):
151
 
        self._inventory = Inventory()
 
240
        self._inventory = Inventory(root_id=None)
 
241
        symbol_versioning.warn('EmptyTree is deprecated as of bzr 0.9 please'
 
242
                               ' use repository.revision_tree instead.',
 
243
                               DeprecationWarning, stacklevel=2)
 
244
 
 
245
    def get_parent_ids(self):
 
246
        return []
 
247
 
 
248
    def get_symlink_target(self, file_id):
 
249
        return None
152
250
 
153
251
    def has_filename(self, filename):
154
252
        return False
155
253
 
156
 
    def list_files(self):
157
 
        if False:  # just to make it a generator
158
 
            yield None
 
254
    def kind(self, file_id):
 
255
        assert self._inventory[file_id].kind == "directory"
 
256
        return "directory"
 
257
 
 
258
    def list_files(self, include_root=False):
 
259
        return iter([])
159
260
    
 
261
    def __contains__(self, file_id):
 
262
        return (file_id in self._inventory)
 
263
 
 
264
    def get_file_sha1(self, file_id, path=None, stat_value=None):
 
265
        return None
160
266
 
161
267
 
162
268
######################################################################
224
330
            yield (old_name, new_name)
225
331
            
226
332
 
227
 
 
228
 
######################################################################
229
 
# export
230
 
 
231
 
def dir_exporter(tree, dest, root):
232
 
    """Export this tree to a new directory.
233
 
 
234
 
    `dest` should not exist, and will be created holding the
235
 
    contents of this tree.
236
 
 
237
 
    TODO: To handle subdirectories we need to create the
238
 
           directories first.
239
 
 
240
 
    :note: If the export fails, the destination directory will be
241
 
           left in a half-assed state.
242
 
    """
243
 
    import os
244
 
    os.mkdir(dest)
245
 
    mutter('export version %r' % tree)
246
 
    inv = tree.inventory
247
 
    for dp, ie in inv.iter_entries():
248
 
        kind = ie.kind
249
 
        fullpath = appendpath(dest, dp)
250
 
        if kind == 'directory':
251
 
            os.mkdir(fullpath)
252
 
        elif kind == 'file':
253
 
            pumpfile(tree.get_file(ie.file_id), file(fullpath, 'wb'))
 
333
def find_ids_across_trees(filenames, trees, require_versioned=True):
 
334
    """Find the ids corresponding to specified filenames.
 
335
    
 
336
    All matches in all trees will be used, and all children of matched
 
337
    directories will be used.
 
338
 
 
339
    :param filenames: The filenames to find file_ids for
 
340
    :param trees: The trees to find file_ids within
 
341
    :param require_versioned: if true, all specified filenames must occur in
 
342
    at least one tree.
 
343
    :return: a set of file ids for the specified filenames and their children.
 
344
    """
 
345
    if not filenames:
 
346
        return None
 
347
    specified_ids = _find_filename_ids_across_trees(filenames, trees, 
 
348
                                                    require_versioned)
 
349
    return _find_children_across_trees(specified_ids, trees)
 
350
 
 
351
 
 
352
def _find_filename_ids_across_trees(filenames, trees, require_versioned):
 
353
    """Find the ids corresponding to specified filenames.
 
354
    
 
355
    All matches in all trees will be used.
 
356
 
 
357
    :param filenames: The filenames to find file_ids for
 
358
    :param trees: The trees to find file_ids within
 
359
    :param require_versioned: if true, all specified filenames must occur in
 
360
    at least one tree.
 
361
    :return: a set of file ids for the specified filenames
 
362
    """
 
363
    not_versioned = []
 
364
    interesting_ids = set()
 
365
    for tree_path in filenames:
 
366
        not_found = True
 
367
        for tree in trees:
 
368
            file_id = tree.inventory.path2id(tree_path)
 
369
            if file_id is not None:
 
370
                interesting_ids.add(file_id)
 
371
                not_found = False
 
372
        if not_found:
 
373
            not_versioned.append(tree_path)
 
374
    if len(not_versioned) > 0 and require_versioned:
 
375
        raise errors.PathsNotVersionedError(not_versioned)
 
376
    return interesting_ids
 
377
 
 
378
 
 
379
def _find_children_across_trees(specified_ids, trees):
 
380
    """Return a set including specified ids and their children
 
381
    
 
382
    All matches in all trees will be used.
 
383
 
 
384
    :param trees: The trees to find file_ids within
 
385
    :return: a set containing all specified ids and their children 
 
386
    """
 
387
    interesting_ids = set(specified_ids)
 
388
    pending = interesting_ids
 
389
    # now handle children of interesting ids
 
390
    # we loop so that we handle all children of each id in both trees
 
391
    while len(pending) > 0:
 
392
        new_pending = set()
 
393
        for file_id in pending:
 
394
            for tree in trees:
 
395
                if file_id not in tree:
 
396
                    continue
 
397
                entry = tree.inventory[file_id]
 
398
                for child in getattr(entry, 'children', {}).itervalues():
 
399
                    if child.file_id not in interesting_ids:
 
400
                        new_pending.add(child.file_id)
 
401
        interesting_ids.update(new_pending)
 
402
        pending = new_pending
 
403
    return interesting_ids
 
404
 
 
405
 
 
406
class InterTree(InterObject):
 
407
    """This class represents operations taking place between two Trees.
 
408
 
 
409
    Its instances have methods like 'compare' and contain references to the
 
410
    source and target trees these operations are to be carried out on.
 
411
 
 
412
    clients of bzrlib should not need to use InterTree directly, rather they
 
413
    should use the convenience methods on Tree such as 'Tree.compare()' which
 
414
    will pass through to InterTree as appropriate.
 
415
    """
 
416
 
 
417
    _optimisers = []
 
418
 
 
419
    @needs_read_lock
 
420
    def compare(self, want_unchanged=False, specific_files=None,
 
421
        extra_trees=None, require_versioned=False, include_root=False):
 
422
        """Return the changes from source to target.
 
423
 
 
424
        :return: A TreeDelta.
 
425
        :param specific_files: An optional list of file paths to restrict the
 
426
            comparison to. When mapping filenames to ids, all matches in all
 
427
            trees (including optional extra_trees) are used, and all children of
 
428
            matched directories are included.
 
429
        :param want_unchanged: An optional boolean requesting the inclusion of
 
430
            unchanged entries in the result.
 
431
        :param extra_trees: An optional list of additional trees to use when
 
432
            mapping the contents of specific_files (paths) to file_ids.
 
433
        :param require_versioned: An optional boolean (defaults to False). When
 
434
            supplied and True all the 'specific_files' must be versioned, or
 
435
            a PathsNotVersionedError will be thrown.
 
436
        """
 
437
        # NB: show_status depends on being able to pass in non-versioned files and
 
438
        # report them as unknown
 
439
        trees = (self.source, self.target)
 
440
        if extra_trees is not None:
 
441
            trees = trees + tuple(extra_trees)
 
442
        specific_file_ids = find_ids_across_trees(specific_files,
 
443
            trees, require_versioned=require_versioned)
 
444
        if specific_files and not specific_file_ids:
 
445
            # All files are unversioned, so just return an empty delta
 
446
            # _compare_trees would think we want a complete delta
 
447
            return delta.TreeDelta()
 
448
        return delta._compare_trees(self.source, self.target, want_unchanged,
 
449
            specific_file_ids, include_root)
 
450
 
 
451
    def _iter_changes(self, from_tree, to_tree, include_unchanged, 
 
452
                      specific_file_ids, pb):
 
453
        """Generate an iterator of changes between trees.
 
454
 
 
455
        A tuple is returned:
 
456
        (file_id, path, changed_content, versioned, parent, name, kind,
 
457
         executable)
 
458
 
 
459
        Path is relative to the to_tree.  changed_content is True if the file's
 
460
        content has changed.  This includes changes to its kind, and to
 
461
        a symlink's target.
 
462
 
 
463
        versioned, parent, name, kind, executable are tuples of (from, to).
 
464
        If a file is missing in a tree, its kind is None.
 
465
 
 
466
        Iteration is done in parent-to-child order, relative to the to_tree.
 
467
        """
 
468
        to_paths = {}
 
469
        from_entries_by_dir = list(from_tree.inventory.iter_entries_by_dir())
 
470
        from_data = dict((e.file_id, (p, e)) for p, e in from_entries_by_dir)
 
471
        to_entries_by_dir = list(to_tree.inventory.iter_entries_by_dir())
 
472
        if specific_file_ids is not None:
 
473
            specific_file_ids = set(specific_file_ids)
 
474
            num_entries = len(specific_file_ids)
254
475
        else:
255
 
            raise BzrError("don't know how to export {%s} of kind %r" % (ie.file_id, kind))
256
 
        mutter("  export {%s} kind %s to %s" % (ie.file_id, kind, fullpath))
257
 
exporters['dir'] = dir_exporter
258
 
 
259
 
try:
260
 
    import tarfile
261
 
except ImportError:
262
 
    pass
263
 
else:
264
 
    def get_root_name(dest):
265
 
        """Get just the root name for a tarball.
266
 
 
267
 
        >>> get_root_name('mytar.tar')
268
 
        'mytar'
269
 
        >>> get_root_name('mytar.tar.bz2')
270
 
        'mytar'
271
 
        >>> get_root_name('tar.tar.tar.tgz')
272
 
        'tar.tar.tar'
273
 
        >>> get_root_name('bzr-0.0.5.tar.gz')
274
 
        'bzr-0.0.5'
275
 
        >>> get_root_name('a/long/path/mytar.tgz')
276
 
        'mytar'
277
 
        >>> get_root_name('../parent/../dir/other.tbz2')
278
 
        'other'
279
 
        """
280
 
        endings = ['.tar', '.tar.gz', '.tgz', '.tar.bz2', '.tbz2']
281
 
        dest = os.path.basename(dest)
282
 
        for end in endings:
283
 
            if dest.endswith(end):
284
 
                return dest[:-len(end)]
285
 
 
286
 
    def tar_exporter(tree, dest, root, compression=None):
287
 
        """Export this tree to a new tar file.
288
 
 
289
 
        `dest` will be created holding the contents of this tree; if it
290
 
        already exists, it will be clobbered, like with "tar -c".
291
 
        """
292
 
        from time import time
293
 
        now = time()
294
 
        compression = str(compression or '')
295
 
        if root is None:
296
 
            root = get_root_name(dest)
297
 
        try:
298
 
            ball = tarfile.open(dest, 'w:' + compression)
299
 
        except tarfile.CompressionError, e:
300
 
            raise BzrError(str(e))
301
 
        mutter('export version %r' % tree)
302
 
        inv = tree.inventory
303
 
        for dp, ie in inv.iter_entries():
304
 
            mutter("  export {%s} kind %s to %s" % (ie.file_id, ie.kind, dest))
305
 
            item = tarfile.TarInfo(os.path.join(root, dp))
306
 
            # TODO: would be cool to actually set it to the timestamp of the
307
 
            # revision it was last changed
308
 
            item.mtime = now
309
 
            if ie.kind == 'directory':
310
 
                item.type = tarfile.DIRTYPE
311
 
                fileobj = None
312
 
                item.name += '/'
313
 
                item.size = 0
314
 
                item.mode = 0755
315
 
            elif ie.kind == 'file':
316
 
                item.type = tarfile.REGTYPE
317
 
                fileobj = tree.get_file(ie.file_id)
318
 
                item.size = _find_file_size(fileobj)
319
 
                item.mode = 0644
320
 
            else:
321
 
                raise BzrError("don't know how to export {%s} of kind %r" %
322
 
                        (ie.file_id, ie.kind))
323
 
 
324
 
            ball.addfile(item, fileobj)
325
 
        ball.close()
326
 
    exporters['tar'] = tar_exporter
327
 
 
328
 
    def tgz_exporter(tree, dest, root):
329
 
        tar_exporter(tree, dest, root, compression='gz')
330
 
    exporters['tgz'] = tgz_exporter
331
 
 
332
 
    def tbz_exporter(tree, dest, root):
333
 
        tar_exporter(tree, dest, root, compression='bz2')
334
 
    exporters['tbz2'] = tbz_exporter
335
 
 
336
 
 
337
 
def _find_file_size(fileobj):
338
 
    offset = fileobj.tell()
339
 
    try:
340
 
        fileobj.seek(0, 2)
341
 
        size = fileobj.tell()
342
 
    except TypeError:
343
 
        # gzip doesn't accept second argument to seek()
344
 
        fileobj.seek(0)
345
 
        size = 0
346
 
        while True:
347
 
            nread = len(fileobj.read())
348
 
            if nread == 0:
349
 
                break
350
 
            size += nread
351
 
    fileobj.seek(offset)
352
 
    return size
 
476
            num_entries = len(from_entries_by_dir) + len(to_entries_by_dir)
 
477
        entry_count = 0
 
478
        for to_path, to_entry in to_entries_by_dir:
 
479
            file_id = to_entry.file_id
 
480
            to_paths[file_id] = to_path
 
481
            if (specific_file_ids is not None and 
 
482
                file_id not in specific_file_ids):
 
483
                continue
 
484
            entry_count += 1
 
485
            changed_content = False
 
486
            from_path, from_entry = from_data.get(file_id, (None, None))
 
487
            from_versioned = (from_entry is not None)
 
488
            if from_entry is not None:
 
489
                from_versioned = True
 
490
                from_name = from_entry.name
 
491
                from_parent = from_entry.parent_id
 
492
                from_kind, from_executable, from_stat = \
 
493
                    from_tree._comparison_data(from_entry, from_path)
 
494
                if specific_file_ids is None:
 
495
                    entry_count += 1
 
496
            else:
 
497
                from_versioned = False
 
498
                from_kind = None
 
499
                from_parent = None
 
500
                from_name = None
 
501
                from_executable = None
 
502
            versioned = (from_versioned, True)
 
503
            to_kind, to_executable, to_stat = \
 
504
                to_tree._comparison_data(to_entry, to_path)
 
505
            kind = (from_kind, to_kind)
 
506
            if kind[0] != kind[1]:
 
507
                changed_content = True
 
508
            elif from_kind == 'file':
 
509
                from_size = from_tree._file_size(from_entry, from_stat)
 
510
                to_size = to_tree._file_size(to_entry, to_stat)
 
511
                if from_size != to_size:
 
512
                    changed_content = True
 
513
                elif (from_tree.get_file_sha1(file_id, from_path, from_stat) !=
 
514
                    to_tree.get_file_sha1(file_id, to_path, to_stat)):
 
515
                    changed_content = True
 
516
            elif from_kind == 'symlink':
 
517
                if (from_tree.get_symlink_target(file_id) != 
 
518
                    to_tree.get_symlink_target(file_id)):
 
519
                    changed_content = True
 
520
            parent = (from_parent, to_entry.parent_id)
 
521
            name = (from_name, to_entry.name)
 
522
            executable = (from_executable, to_executable)
 
523
            if pb is not None:
 
524
                pb.update('comparing files', entry_count, num_entries)
 
525
            if (changed_content is not False or versioned[0] != versioned[1] 
 
526
                or parent[0] != parent[1] or name[0] != name[1] or 
 
527
                executable[0] != executable[1] or include_unchanged):
 
528
                yield (file_id, to_path, changed_content, versioned, parent,
 
529
                       name, kind, executable)
 
530
 
 
531
        for path, from_entry in from_entries_by_dir:
 
532
            file_id = from_entry.file_id
 
533
            if file_id in to_paths:
 
534
                continue
 
535
            if from_entry.parent_id is None:
 
536
                to_path = ''
 
537
            else:
 
538
                to_path = osutils.pathjoin(to_paths[from_entry.parent_id],
 
539
                                           from_entry.name)
 
540
            to_paths[file_id] = to_path
 
541
            if (specific_file_ids is not None and 
 
542
                file_id not in specific_file_ids):
 
543
                continue
 
544
            entry_count += 1
 
545
            if pb is not None:
 
546
                pb.update('comparing files', entry_count, num_entries)
 
547
            versioned = (True, False)
 
548
            parent = (from_entry.parent_id, None)
 
549
            name = (from_entry.name, None)
 
550
            from_kind, from_executable, stat_value = \
 
551
                from_tree._comparison_data(from_entry, path)
 
552
            kind = (from_kind, None)
 
553
            executable = (from_executable, None)
 
554
            changed_content = True
 
555
            # the parent's path is necessarily known at this point.
 
556
            yield(file_id, to_path, changed_content, versioned, parent,
 
557
                  name, kind, executable)
 
558
 
 
559
 
 
560
# This was deprecated before 0.12, but did not have an official warning
 
561
@symbol_versioning.deprecated_function(symbol_versioning.zero_twelve)
 
562
def RevisionTree(*args, **kwargs):
 
563
    """RevisionTree has moved to bzrlib.revisiontree.RevisionTree()
 
564
 
 
565
    Accessing it as bzrlib.tree.RevisionTree has been deprecated as of
 
566
    bzr 0.12.
 
567
    """
 
568
    from bzrlib.revisiontree import RevisionTree as _RevisionTree
 
569
    return _RevisionTree(*args, **kwargs)
 
570
 
 
571