/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 breezy/transform.py

  • Committer: Jelmer Vernooij
  • Date: 2017-06-08 23:30:31 UTC
  • mto: This revision was merged to the branch mainline in revision 6690.
  • Revision ID: jelmer@jelmer.uk-20170608233031-3qavls2o7a1pqllj
Update imports.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/transform.py
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
import contextlib
 
17
from __future__ import absolute_import
 
18
 
18
19
import os
19
20
import errno
20
21
from stat import S_ISREG, S_IEXEC
22
23
 
23
24
from . import (
24
25
    config as _mod_config,
25
 
    controldir,
26
26
    errors,
27
27
    lazy_import,
28
 
    lock,
29
 
    osutils,
30
28
    registry,
31
29
    trace,
 
30
    tree,
32
31
    )
33
32
lazy_import.lazy_import(globals(), """
34
33
from breezy import (
 
34
    annotate,
 
35
    bencode,
 
36
    controldir,
 
37
    commit,
35
38
    conflicts,
 
39
    delta,
36
40
    multiparent,
 
41
    osutils,
37
42
    revision as _mod_revision,
38
43
    ui,
39
44
    urlutils,
40
45
    )
 
46
from breezy.bzr import (
 
47
    inventory,
 
48
    )
41
49
from breezy.i18n import gettext
42
50
""")
43
 
 
44
 
from .errors import (DuplicateKey,
45
 
                     BzrError, InternalBzrError)
 
51
from .errors import (DuplicateKey, MalformedTransform,
 
52
                     ReusingTransform, CantMoveRoot,
 
53
                     ImmortalLimbo, NoFinalPath,
 
54
                     UnableCreateSymlink)
46
55
from .filters import filtered_output_bytes, ContentFilterContext
47
56
from .mutabletree import MutableTree
48
57
from .osutils import (
49
58
    delete_any,
50
59
    file_kind,
 
60
    has_symlinks,
51
61
    pathjoin,
52
62
    sha_file,
53
63
    splitpath,
54
 
    supports_symlinks,
55
64
    )
56
65
from .progress import ProgressPhase
57
 
from .tree import (
58
 
    InterTree,
59
 
    TreeChange,
60
 
    find_previous_path,
 
66
from .sixish import (
 
67
    viewitems,
 
68
    viewvalues,
61
69
    )
62
70
 
63
71
 
64
72
ROOT_PARENT = "root-parent"
65
73
 
66
 
 
67
 
class NoFinalPath(BzrError):
68
 
 
69
 
    _fmt = ("No final name for trans_id %(trans_id)r\n"
70
 
            "file-id: %(file_id)r\n"
71
 
            "root trans-id: %(root_trans_id)r\n")
72
 
 
73
 
    def __init__(self, trans_id, transform):
74
 
        self.trans_id = trans_id
75
 
        self.file_id = transform.final_file_id(trans_id)
76
 
        self.root_trans_id = transform.root
77
 
 
78
 
 
79
 
class ReusingTransform(BzrError):
80
 
 
81
 
    _fmt = "Attempt to reuse a transform that has already been applied."
82
 
 
83
 
 
84
 
class MalformedTransform(InternalBzrError):
85
 
 
86
 
    _fmt = "Tree transform is malformed %(conflicts)r"
87
 
 
88
 
 
89
 
class CantMoveRoot(BzrError):
90
 
 
91
 
    _fmt = "Moving the root directory is not supported at this time"
92
 
 
93
 
 
94
 
class ImmortalLimbo(BzrError):
95
 
 
96
 
    _fmt = """Unable to delete transform temporary directory %(limbo_dir)s.
97
 
    Please examine %(limbo_dir)s to see if it contains any files you wish to
98
 
    keep, and delete it when you are done."""
99
 
 
100
 
    def __init__(self, limbo_dir):
101
 
        BzrError.__init__(self)
102
 
        self.limbo_dir = limbo_dir
103
 
 
104
 
 
105
 
class TransformRenameFailed(BzrError):
106
 
 
107
 
    _fmt = "Failed to rename %(from_path)s to %(to_path)s: %(why)s"
108
 
 
109
 
    def __init__(self, from_path, to_path, why, errno):
110
 
        self.from_path = from_path
111
 
        self.to_path = to_path
112
 
        self.why = why
113
 
        self.errno = errno
114
 
 
115
 
 
116
74
def unique_add(map, key, value):
117
75
    if key in map:
118
76
        raise DuplicateKey(key=key)
119
77
    map[key] = value
120
78
 
121
79
 
 
80
 
122
81
class _TransformResults(object):
123
 
 
124
82
    def __init__(self, modified_paths, rename_count):
125
83
        object.__init__(self)
126
84
        self.modified_paths = modified_paths
127
85
        self.rename_count = rename_count
128
86
 
129
87
 
130
 
class TreeTransform(object):
131
 
    """Represent a tree transformation.
132
 
 
133
 
    This object is designed to support incremental generation of the transform,
134
 
    in any order.
135
 
 
136
 
    However, it gives optimum performance when parent directories are created
137
 
    before their contents.  The transform is then able to put child files
138
 
    directly in their parent directory, avoiding later renames.
139
 
 
140
 
    It is easy to produce malformed transforms, but they are generally
141
 
    harmless.  Attempting to apply a malformed transform will cause an
142
 
    exception to be raised before any modifications are made to the tree.
143
 
 
144
 
    Many kinds of malformed transforms can be corrected with the
145
 
    resolve_conflicts function.  The remaining ones indicate programming error,
146
 
    such as trying to create a file with no path.
147
 
 
148
 
    Two sets of file creation methods are supplied.  Convenience methods are:
149
 
     * new_file
150
 
     * new_directory
151
 
     * new_symlink
152
 
 
153
 
    These are composed of the low-level methods:
154
 
     * create_path
155
 
     * create_file or create_directory or create_symlink
156
 
     * version_file
157
 
     * set_executability
158
 
 
159
 
    Transform/Transaction ids
160
 
    -------------------------
161
 
    trans_ids are temporary ids assigned to all files involved in a transform.
162
 
    It's possible, even common, that not all files in the Tree have trans_ids.
163
 
 
164
 
    trans_ids are only valid for the TreeTransform that generated them.
165
 
    """
166
 
 
167
 
    def __init__(self, tree, pb=None):
 
88
class TreeTransformBase(object):
 
89
    """The base class for TreeTransform and its kin."""
 
90
 
 
91
    def __init__(self, tree, pb=None,
 
92
                 case_sensitive=True):
 
93
        """Constructor.
 
94
 
 
95
        :param tree: The tree that will be transformed, but not necessarily
 
96
            the output tree.
 
97
        :param pb: ignored
 
98
        :param case_sensitive: If True, the target of the transform is
 
99
            case sensitive, not just case preserving.
 
100
        """
 
101
        object.__init__(self)
168
102
        self._tree = tree
169
 
        # A progress bar
170
 
        self._pb = pb
171
103
        self._id_number = 0
172
 
        # Mapping of path in old tree -> trans_id
173
 
        self._tree_path_ids = {}
174
 
        # Mapping trans_id -> path in old tree
175
 
        self._tree_id_paths = {}
176
104
        # mapping of trans_id -> new basename
177
105
        self._new_name = {}
178
106
        # mapping of trans_id -> new parent trans_id
179
107
        self._new_parent = {}
180
108
        # mapping of trans_id with new contents -> new file_kind
181
109
        self._new_contents = {}
 
110
        # mapping of trans_id => (sha1 of content, stat_value)
 
111
        self._observed_sha1s = {}
182
112
        # Set of trans_ids whose contents will be removed
183
113
        self._removed_contents = set()
184
114
        # Mapping of trans_id -> new execute-bit value
185
115
        self._new_executability = {}
186
116
        # Mapping of trans_id -> new tree-reference value
187
117
        self._new_reference_revision = {}
 
118
        # Mapping of trans_id -> new file_id
 
119
        self._new_id = {}
 
120
        # Mapping of old file-id -> trans_id
 
121
        self._non_present_ids = {}
 
122
        # Mapping of new file_id -> trans_id
 
123
        self._r_new_id = {}
188
124
        # Set of trans_ids that will be removed
189
125
        self._removed_id = set()
 
126
        # Mapping of path in old tree -> trans_id
 
127
        self._tree_path_ids = {}
 
128
        # Mapping trans_id -> path in old tree
 
129
        self._tree_id_paths = {}
 
130
        # The trans_id that will be used as the tree root
 
131
        root_id = tree.get_root_id()
 
132
        if root_id is not None:
 
133
            self._new_root = self.trans_id_tree_file_id(root_id)
 
134
        else:
 
135
            self._new_root = None
190
136
        # Indicator of whether the transform has been applied
191
137
        self._done = False
 
138
        # A progress bar
 
139
        self._pb = pb
 
140
        # Whether the target is case sensitive
 
141
        self._case_sensitive_target = case_sensitive
 
142
        # A counter of how many files have been renamed
 
143
        self.rename_count = 0
192
144
 
193
145
    def __enter__(self):
194
146
        """Support Context Manager API."""
198
150
        """Support Context Manager API."""
199
151
        self.finalize()
200
152
 
201
 
    def iter_tree_children(self, trans_id):
202
 
        """Iterate through the entry's tree children, if any.
203
 
 
204
 
        :param trans_id: trans id to iterate
205
 
        :returns: Iterator over paths
206
 
        """
207
 
        raise NotImplementedError(self.iter_tree_children)
208
 
 
209
 
    def canonical_path(self, path):
210
 
        return path
211
 
 
212
 
    def tree_kind(self, trans_id):
213
 
        raise NotImplementedError(self.tree_kind)
214
 
 
215
 
    def by_parent(self):
216
 
        """Return a map of parent: children for known parents.
217
 
 
218
 
        Only new paths and parents of tree files with assigned ids are used.
219
 
        """
220
 
        by_parent = {}
221
 
        items = list(self._new_parent.items())
222
 
        items.extend((t, self.final_parent(t))
223
 
                     for t in list(self._tree_id_paths))
224
 
        for trans_id, parent_id in items:
225
 
            if parent_id not in by_parent:
226
 
                by_parent[parent_id] = set()
227
 
            by_parent[parent_id].add(trans_id)
228
 
        return by_parent
229
 
 
230
153
    def finalize(self):
231
154
        """Release the working tree lock, if held.
232
155
 
233
156
        This is required if apply has not been invoked, but can be invoked
234
157
        even after apply.
235
158
        """
236
 
        raise NotImplementedError(self.finalize)
 
159
        if self._tree is None:
 
160
            return
 
161
        for hook in MutableTree.hooks['post_transform']:
 
162
            hook(self._tree, self)
 
163
        self._tree.unlock()
 
164
        self._tree = None
 
165
 
 
166
    def __get_root(self):
 
167
        return self._new_root
 
168
 
 
169
    root = property(__get_root)
 
170
 
 
171
    def _assign_id(self):
 
172
        """Produce a new tranform id"""
 
173
        new_id = "new-%s" % self._id_number
 
174
        self._id_number +=1
 
175
        return new_id
237
176
 
238
177
    def create_path(self, name, parent):
239
178
        """Assign a transaction id to a new path"""
260
199
        physically new directory, and hope someone versions the tree root
261
200
        later.
262
201
        """
263
 
        raise NotImplementedError(self.adjust_root_path)
 
202
        old_root = self._new_root
 
203
        old_root_file_id = self.final_file_id(old_root)
 
204
        # force moving all children of root
 
205
        for child_id in self.iter_tree_children(old_root):
 
206
            if child_id != parent:
 
207
                self.adjust_path(self.final_name(child_id),
 
208
                                 self.final_parent(child_id), child_id)
 
209
            file_id = self.final_file_id(child_id)
 
210
            if file_id is not None:
 
211
                self.unversion_file(child_id)
 
212
            self.version_file(file_id, child_id)
 
213
 
 
214
        # the physical root needs a new transaction id
 
215
        self._tree_path_ids.pop("")
 
216
        self._tree_id_paths.pop(old_root)
 
217
        self._new_root = self.trans_id_tree_file_id(self._tree.get_root_id())
 
218
        if parent == old_root:
 
219
            parent = self._new_root
 
220
        self.adjust_path(name, parent, old_root)
 
221
        self.create_directory(old_root)
 
222
        self.version_file(old_root_file_id, old_root)
 
223
        self.unversion_file(self._new_root)
264
224
 
265
225
    def fixup_new_roots(self):
266
226
        """Reinterpret requests to change the root directory
272
232
        This means that the old root trans-id becomes obsolete, so it is
273
233
        recommended only to invoke this after the root trans-id has become
274
234
        irrelevant.
275
 
        """
276
 
        raise NotImplementedError(self.fixup_new_roots)
277
 
 
278
 
    def _assign_id(self):
279
 
        """Produce a new tranform id"""
280
 
        new_id = "new-%s" % self._id_number
281
 
        self._id_number += 1
282
 
        return new_id
 
235
 
 
236
        """
 
237
        new_roots = [k for k, v in viewitems(self._new_parent)
 
238
                     if v == ROOT_PARENT]
 
239
        if len(new_roots) < 1:
 
240
            return
 
241
        if len(new_roots) != 1:
 
242
            raise ValueError('A tree cannot have two roots!')
 
243
        if self._new_root is None:
 
244
            self._new_root = new_roots[0]
 
245
            return
 
246
        old_new_root = new_roots[0]
 
247
        # unversion the new root's directory.
 
248
        if self.final_kind(self._new_root) is None:
 
249
            file_id = self.final_file_id(old_new_root)
 
250
        else:
 
251
            file_id = self.final_file_id(self._new_root)
 
252
        if old_new_root in self._new_id:
 
253
            self.cancel_versioning(old_new_root)
 
254
        else:
 
255
            self.unversion_file(old_new_root)
 
256
        # if, at this stage, root still has an old file_id, zap it so we can
 
257
        # stick a new one in.
 
258
        if (self.tree_file_id(self._new_root) is not None and
 
259
            self._new_root not in self._removed_id):
 
260
            self.unversion_file(self._new_root)
 
261
        if file_id is not None:
 
262
            self.version_file(file_id, self._new_root)
 
263
 
 
264
        # Now move children of new root into old root directory.
 
265
        # Ensure all children are registered with the transaction, but don't
 
266
        # use directly-- some tree children have new parents
 
267
        list(self.iter_tree_children(old_new_root))
 
268
        # Move all children of new root into old root directory.
 
269
        for child in self.by_parent().get(old_new_root, []):
 
270
            self.adjust_path(self.final_name(child), self._new_root, child)
 
271
 
 
272
        # Ensure old_new_root has no directory.
 
273
        if old_new_root in self._new_contents:
 
274
            self.cancel_creation(old_new_root)
 
275
        else:
 
276
            self.delete_contents(old_new_root)
 
277
 
 
278
        # prevent deletion of root directory.
 
279
        if self._new_root in self._removed_contents:
 
280
            self.cancel_deletion(self._new_root)
 
281
 
 
282
        # destroy path info for old_new_root.
 
283
        del self._new_parent[old_new_root]
 
284
        del self._new_name[old_new_root]
 
285
 
 
286
    def trans_id_tree_file_id(self, inventory_id):
 
287
        """Determine the transaction id of a working tree file.
 
288
 
 
289
        This reflects only files that already exist, not ones that will be
 
290
        added by transactions.
 
291
        """
 
292
        if inventory_id is None:
 
293
            raise ValueError('None is not a valid file id')
 
294
        path = self._tree.id2path(inventory_id)
 
295
        return self.trans_id_tree_path(path)
 
296
 
 
297
    def trans_id_file_id(self, file_id):
 
298
        """Determine or set the transaction id associated with a file ID.
 
299
        A new id is only created for file_ids that were never present.  If
 
300
        a transaction has been unversioned, it is deliberately still returned.
 
301
        (this will likely lead to an unversioned parent conflict.)
 
302
        """
 
303
        if file_id is None:
 
304
            raise ValueError('None is not a valid file id')
 
305
        if file_id in self._r_new_id and self._r_new_id[file_id] is not None:
 
306
            return self._r_new_id[file_id]
 
307
        else:
 
308
            try:
 
309
                next(self._tree.iter_entries_by_dir([file_id]))
 
310
            except StopIteration:
 
311
                if file_id in self._non_present_ids:
 
312
                    return self._non_present_ids[file_id]
 
313
                else:
 
314
                    trans_id = self._assign_id()
 
315
                    self._non_present_ids[file_id] = trans_id
 
316
                    return trans_id
 
317
            else:
 
318
                return self.trans_id_tree_file_id(file_id)
283
319
 
284
320
    def trans_id_tree_path(self, path):
285
321
        """Determine (and maybe set) the transaction ID for a tree path."""
306
342
        """Cancel a scheduled deletion"""
307
343
        self._removed_contents.remove(trans_id)
308
344
 
 
345
    def unversion_file(self, trans_id):
 
346
        """Schedule a path entry to become unversioned"""
 
347
        self._removed_id.add(trans_id)
 
348
 
309
349
    def delete_versioned(self, trans_id):
310
350
        """Delete and unversion a versioned file"""
311
351
        self.delete_contents(trans_id)
324
364
        """Set the reference associated with a directory"""
325
365
        unique_add(self._new_reference_revision, trans_id, revision_id)
326
366
 
327
 
    def version_file(self, trans_id, file_id=None):
 
367
    def version_file(self, file_id, trans_id):
328
368
        """Schedule a file to become versioned."""
329
 
        raise NotImplementedError(self.version_file)
 
369
        if file_id is None:
 
370
            raise ValueError()
 
371
        unique_add(self._new_id, trans_id, file_id)
 
372
        unique_add(self._r_new_id, file_id, trans_id)
330
373
 
331
374
    def cancel_versioning(self, trans_id):
332
375
        """Undo a previous versioning of a file"""
333
 
        raise NotImplementedError(self.cancel_versioning)
334
 
 
335
 
    def unversion_file(self, trans_id):
336
 
        """Schedule a path entry to become unversioned"""
337
 
        self._removed_id.add(trans_id)
 
376
        file_id = self._new_id[trans_id]
 
377
        del self._new_id[trans_id]
 
378
        del self._r_new_id[file_id]
338
379
 
339
380
    def new_paths(self, filesystem_only=False):
340
381
        """Determine the paths of all new and changed files.
342
383
        :param filesystem_only: if True, only calculate values for files
343
384
            that require renames or execute bit changes.
344
385
        """
345
 
        raise NotImplementedError(self.new_paths)
 
386
        new_ids = set()
 
387
        if filesystem_only:
 
388
            stale_ids = self._needs_rename.difference(self._new_name)
 
389
            stale_ids.difference_update(self._new_parent)
 
390
            stale_ids.difference_update(self._new_contents)
 
391
            stale_ids.difference_update(self._new_id)
 
392
            needs_rename = self._needs_rename.difference(stale_ids)
 
393
            id_sets = (needs_rename, self._new_executability)
 
394
        else:
 
395
            id_sets = (self._new_name, self._new_parent, self._new_contents,
 
396
                       self._new_id, self._new_executability)
 
397
        for id_set in id_sets:
 
398
            new_ids.update(id_set)
 
399
        return sorted(FinalPaths(self).get_paths(new_ids))
 
400
 
 
401
    def _inventory_altered(self):
 
402
        """Determine which trans_ids need new Inventory entries.
 
403
 
 
404
        An new entry is needed when anything that would be reflected by an
 
405
        inventory entry changes, including file name, file_id, parent file_id,
 
406
        file kind, and the execute bit.
 
407
 
 
408
        Some care is taken to return entries with real changes, not cases
 
409
        where the value is deleted and then restored to its original value,
 
410
        but some actually unchanged values may be returned.
 
411
 
 
412
        :returns: A list of (path, trans_id) for all items requiring an
 
413
            inventory change. Ordered by path.
 
414
        """
 
415
        changed_ids = set()
 
416
        # Find entries whose file_ids are new (or changed).
 
417
        new_file_id = set(t for t in self._new_id
 
418
                          if self._new_id[t] != self.tree_file_id(t))
 
419
        for id_set in [self._new_name, self._new_parent, new_file_id,
 
420
                       self._new_executability]:
 
421
            changed_ids.update(id_set)
 
422
        # removing implies a kind change
 
423
        changed_kind = set(self._removed_contents)
 
424
        # so does adding
 
425
        changed_kind.intersection_update(self._new_contents)
 
426
        # Ignore entries that are already known to have changed.
 
427
        changed_kind.difference_update(changed_ids)
 
428
        #  to keep only the truly changed ones
 
429
        changed_kind = (t for t in changed_kind
 
430
                        if self.tree_kind(t) != self.final_kind(t))
 
431
        # all kind changes will alter the inventory
 
432
        changed_ids.update(changed_kind)
 
433
        # To find entries with changed parent_ids, find parents which existed,
 
434
        # but changed file_id.
 
435
        changed_file_id = set(t for t in new_file_id if t in self._removed_id)
 
436
        # Now add all their children to the set.
 
437
        for parent_trans_id in new_file_id:
 
438
            changed_ids.update(self.iter_tree_children(parent_trans_id))
 
439
        return sorted(FinalPaths(self).get_paths(changed_ids))
346
440
 
347
441
    def final_kind(self, trans_id):
348
442
        """Determine the final file kind, after any changes applied.
358
452
        else:
359
453
            return self.tree_kind(trans_id)
360
454
 
361
 
    def tree_path(self, trans_id):
362
 
        """Determine the tree path associated with the trans_id."""
363
 
        return self._tree_id_paths.get(trans_id)
364
 
 
365
 
    def final_is_versioned(self, trans_id):
366
 
        raise NotImplementedError(self.final_is_versioned)
 
455
    def tree_file_id(self, trans_id):
 
456
        """Determine the file id associated with the trans_id in the tree"""
 
457
        try:
 
458
            path = self._tree_id_paths[trans_id]
 
459
        except KeyError:
 
460
            # the file is a new, unversioned file, or invalid trans_id
 
461
            return None
 
462
        # the file is old; the old id is still valid
 
463
        if self._new_root == trans_id:
 
464
            return self._tree.get_root_id()
 
465
        return self._tree.path2id(path)
 
466
 
 
467
    def final_file_id(self, trans_id):
 
468
        """Determine the file id after any changes are applied, or None.
 
469
 
 
470
        None indicates that the file will not be versioned after changes are
 
471
        applied.
 
472
        """
 
473
        try:
 
474
            return self._new_id[trans_id]
 
475
        except KeyError:
 
476
            if trans_id in self._removed_id:
 
477
                return None
 
478
        return self.tree_file_id(trans_id)
 
479
 
 
480
    def inactive_file_id(self, trans_id):
 
481
        """Return the inactive file_id associated with a transaction id.
 
482
        That is, the one in the tree or in non_present_ids.
 
483
        The file_id may actually be active, too.
 
484
        """
 
485
        file_id = self.tree_file_id(trans_id)
 
486
        if file_id is not None:
 
487
            return file_id
 
488
        for key, value in viewitems(self._non_present_ids):
 
489
            if value == trans_id:
 
490
                return key
367
491
 
368
492
    def final_parent(self, trans_id):
369
493
        """Determine the parent file_id, after any changes are applied.
385
509
            except KeyError:
386
510
                raise NoFinalPath(trans_id, self)
387
511
 
 
512
    def by_parent(self):
 
513
        """Return a map of parent: children for known parents.
 
514
 
 
515
        Only new paths and parents of tree files with assigned ids are used.
 
516
        """
 
517
        by_parent = {}
 
518
        items = list(viewitems(self._new_parent))
 
519
        items.extend((t, self.final_parent(t))
 
520
            for t in list(self._tree_id_paths))
 
521
        for trans_id, parent_id in items:
 
522
            if parent_id not in by_parent:
 
523
                by_parent[parent_id] = set()
 
524
            by_parent[parent_id].add(trans_id)
 
525
        return by_parent
 
526
 
388
527
    def path_changed(self, trans_id):
389
528
        """Return True if a trans_id's path has changed."""
390
529
        return (trans_id in self._new_name) or (trans_id in self._new_parent)
394
533
 
395
534
    def find_conflicts(self):
396
535
        """Find any violations of inventory or filesystem invariants"""
397
 
        raise NotImplementedError(self.find_conflicts)
 
536
        if self._done is True:
 
537
            raise ReusingTransform()
 
538
        conflicts = []
 
539
        # ensure all children of all existent parents are known
 
540
        # all children of non-existent parents are known, by definition.
 
541
        self._add_tree_children()
 
542
        by_parent = self.by_parent()
 
543
        conflicts.extend(self._unversioned_parents(by_parent))
 
544
        conflicts.extend(self._parent_loops())
 
545
        conflicts.extend(self._duplicate_entries(by_parent))
 
546
        conflicts.extend(self._duplicate_ids())
 
547
        conflicts.extend(self._parent_type_conflicts(by_parent))
 
548
        conflicts.extend(self._improper_versioning())
 
549
        conflicts.extend(self._executability_conflicts())
 
550
        conflicts.extend(self._overwrite_conflicts())
 
551
        return conflicts
 
552
 
 
553
    def _check_malformed(self):
 
554
        conflicts = self.find_conflicts()
 
555
        if len(conflicts) != 0:
 
556
            raise MalformedTransform(conflicts=conflicts)
 
557
 
 
558
    def _add_tree_children(self):
 
559
        """Add all the children of all active parents to the known paths.
 
560
 
 
561
        Active parents are those which gain children, and those which are
 
562
        removed.  This is a necessary first step in detecting conflicts.
 
563
        """
 
564
        parents = list(self.by_parent())
 
565
        parents.extend([t for t in self._removed_contents if
 
566
                        self.tree_kind(t) == 'directory'])
 
567
        for trans_id in self._removed_id:
 
568
            file_id = self.tree_file_id(trans_id)
 
569
            if file_id is not None:
 
570
                if self._tree.stored_kind(file_id) == 'directory':
 
571
                    parents.append(trans_id)
 
572
            elif self.tree_kind(trans_id) == 'directory':
 
573
                parents.append(trans_id)
 
574
 
 
575
        for parent_id in parents:
 
576
            # ensure that all children are registered with the transaction
 
577
            list(self.iter_tree_children(parent_id))
 
578
 
 
579
    def _has_named_child(self, name, parent_id, known_children):
 
580
        """Does a parent already have a name child.
 
581
 
 
582
        :param name: The searched for name.
 
583
 
 
584
        :param parent_id: The parent for which the check is made.
 
585
 
 
586
        :param known_children: The already known children. This should have
 
587
            been recently obtained from `self.by_parent.get(parent_id)`
 
588
            (or will be if None is passed).
 
589
        """
 
590
        if known_children is None:
 
591
            known_children = self.by_parent().get(parent_id, [])
 
592
        for child in known_children:
 
593
            if self.final_name(child) == name:
 
594
                return True
 
595
        parent_path = self._tree_id_paths.get(parent_id, None)
 
596
        if parent_path is None:
 
597
            # No parent... no children
 
598
            return False
 
599
        child_path = joinpath(parent_path, name)
 
600
        child_id = self._tree_path_ids.get(child_path, None)
 
601
        if child_id is None:
 
602
            # Not known by the tree transform yet, check the filesystem
 
603
            return osutils.lexists(self._tree.abspath(child_path))
 
604
        else:
 
605
            raise AssertionError('child_id is missing: %s, %s, %s'
 
606
                                 % (name, parent_id, child_id))
 
607
 
 
608
    def _available_backup_name(self, name, target_id):
 
609
        """Find an available backup name.
 
610
 
 
611
        :param name: The basename of the file.
 
612
 
 
613
        :param target_id: The directory trans_id where the backup should 
 
614
            be placed.
 
615
        """
 
616
        known_children = self.by_parent().get(target_id, [])
 
617
        return osutils.available_backup_name(
 
618
            name,
 
619
            lambda base: self._has_named_child(
 
620
                base, target_id, known_children))
 
621
 
 
622
    def _parent_loops(self):
 
623
        """No entry should be its own ancestor"""
 
624
        conflicts = []
 
625
        for trans_id in self._new_parent:
 
626
            seen = set()
 
627
            parent_id = trans_id
 
628
            while parent_id != ROOT_PARENT:
 
629
                seen.add(parent_id)
 
630
                try:
 
631
                    parent_id = self.final_parent(parent_id)
 
632
                except KeyError:
 
633
                    break
 
634
                if parent_id == trans_id:
 
635
                    conflicts.append(('parent loop', trans_id))
 
636
                if parent_id in seen:
 
637
                    break
 
638
        return conflicts
 
639
 
 
640
    def _unversioned_parents(self, by_parent):
 
641
        """If parent directories are versioned, children must be versioned."""
 
642
        conflicts = []
 
643
        for parent_id, children in viewitems(by_parent):
 
644
            if parent_id == ROOT_PARENT:
 
645
                continue
 
646
            if self.final_file_id(parent_id) is not None:
 
647
                continue
 
648
            for child_id in children:
 
649
                if self.final_file_id(child_id) is not None:
 
650
                    conflicts.append(('unversioned parent', parent_id))
 
651
                    break;
 
652
        return conflicts
 
653
 
 
654
    def _improper_versioning(self):
 
655
        """Cannot version a file with no contents, or a bad type.
 
656
 
 
657
        However, existing entries with no contents are okay.
 
658
        """
 
659
        conflicts = []
 
660
        for trans_id in self._new_id:
 
661
            kind = self.final_kind(trans_id)
 
662
            if kind is None:
 
663
                conflicts.append(('versioning no contents', trans_id))
 
664
                continue
 
665
            if not inventory.InventoryEntry.versionable_kind(kind):
 
666
                conflicts.append(('versioning bad kind', trans_id, kind))
 
667
        return conflicts
 
668
 
 
669
    def _executability_conflicts(self):
 
670
        """Check for bad executability changes.
 
671
 
 
672
        Only versioned files may have their executability set, because
 
673
        1. only versioned entries can have executability under windows
 
674
        2. only files can be executable.  (The execute bit on a directory
 
675
           does not indicate searchability)
 
676
        """
 
677
        conflicts = []
 
678
        for trans_id in self._new_executability:
 
679
            if self.final_file_id(trans_id) is None:
 
680
                conflicts.append(('unversioned executability', trans_id))
 
681
            else:
 
682
                if self.final_kind(trans_id) != "file":
 
683
                    conflicts.append(('non-file executability', trans_id))
 
684
        return conflicts
 
685
 
 
686
    def _overwrite_conflicts(self):
 
687
        """Check for overwrites (not permitted on Win32)"""
 
688
        conflicts = []
 
689
        for trans_id in self._new_contents:
 
690
            if self.tree_kind(trans_id) is None:
 
691
                continue
 
692
            if trans_id not in self._removed_contents:
 
693
                conflicts.append(('overwrite', trans_id,
 
694
                                 self.final_name(trans_id)))
 
695
        return conflicts
 
696
 
 
697
    def _duplicate_entries(self, by_parent):
 
698
        """No directory may have two entries with the same name."""
 
699
        conflicts = []
 
700
        if (self._new_name, self._new_parent) == ({}, {}):
 
701
            return conflicts
 
702
        for children in viewvalues(by_parent):
 
703
            name_ids = []
 
704
            for child_tid in children:
 
705
                name = self.final_name(child_tid)
 
706
                if name is not None:
 
707
                    # Keep children only if they still exist in the end
 
708
                    if not self._case_sensitive_target:
 
709
                        name = name.lower()
 
710
                    name_ids.append((name, child_tid))
 
711
            name_ids.sort()
 
712
            last_name = None
 
713
            last_trans_id = None
 
714
            for name, trans_id in name_ids:
 
715
                kind = self.final_kind(trans_id)
 
716
                file_id = self.final_file_id(trans_id)
 
717
                if kind is None and file_id is None:
 
718
                    continue
 
719
                if name == last_name:
 
720
                    conflicts.append(('duplicate', last_trans_id, trans_id,
 
721
                    name))
 
722
                last_name = name
 
723
                last_trans_id = trans_id
 
724
        return conflicts
 
725
 
 
726
    def _duplicate_ids(self):
 
727
        """Each inventory id may only be used once"""
 
728
        conflicts = []
 
729
        removed_tree_ids = set((self.tree_file_id(trans_id) for trans_id in
 
730
                                self._removed_id))
 
731
        all_ids = self._tree.all_file_ids()
 
732
        active_tree_ids = all_ids.difference(removed_tree_ids)
 
733
        for trans_id, file_id in viewitems(self._new_id):
 
734
            if file_id in active_tree_ids:
 
735
                old_trans_id = self.trans_id_tree_file_id(file_id)
 
736
                conflicts.append(('duplicate id', old_trans_id, trans_id))
 
737
        return conflicts
 
738
 
 
739
    def _parent_type_conflicts(self, by_parent):
 
740
        """Children must have a directory parent"""
 
741
        conflicts = []
 
742
        for parent_id, children in viewitems(by_parent):
 
743
            if parent_id == ROOT_PARENT:
 
744
                continue
 
745
            no_children = True
 
746
            for child_id in children:
 
747
                if self.final_kind(child_id) is not None:
 
748
                    no_children = False
 
749
                    break
 
750
            if no_children:
 
751
                continue
 
752
            # There is at least a child, so we need an existing directory to
 
753
            # contain it.
 
754
            kind = self.final_kind(parent_id)
 
755
            if kind is None:
 
756
                # The directory will be deleted
 
757
                conflicts.append(('missing parent', parent_id))
 
758
            elif kind != "directory":
 
759
                # Meh, we need a *directory* to put something in it
 
760
                conflicts.append(('non-directory parent', parent_id))
 
761
        return conflicts
 
762
 
 
763
    def _set_executability(self, path, trans_id):
 
764
        """Set the executability of versioned files """
 
765
        if self._tree._supports_executable():
 
766
            new_executability = self._new_executability[trans_id]
 
767
            abspath = self._tree.abspath(path)
 
768
            current_mode = os.stat(abspath).st_mode
 
769
            if new_executability:
 
770
                umask = os.umask(0)
 
771
                os.umask(umask)
 
772
                to_mode = current_mode | (0o100 & ~umask)
 
773
                # Enable x-bit for others only if they can read it.
 
774
                if current_mode & 0o004:
 
775
                    to_mode |= 0o001 & ~umask
 
776
                if current_mode & 0o040:
 
777
                    to_mode |= 0o010 & ~umask
 
778
            else:
 
779
                to_mode = current_mode & ~0o111
 
780
            osutils.chmod_if_possible(abspath, to_mode)
 
781
 
 
782
    def _new_entry(self, name, parent_id, file_id):
 
783
        """Helper function to create a new filesystem entry."""
 
784
        trans_id = self.create_path(name, parent_id)
 
785
        if file_id is not None:
 
786
            self.version_file(file_id, trans_id)
 
787
        return trans_id
398
788
 
399
789
    def new_file(self, name, parent_id, contents, file_id=None,
400
790
                 executable=None, sha1=None):
407
797
        :param file_id: The inventory ID of the file, if it is to be versioned.
408
798
        :param executable: Only valid when a file_id has been supplied.
409
799
        """
410
 
        raise NotImplementedError(self.new_file)
 
800
        trans_id = self._new_entry(name, parent_id, file_id)
 
801
        # TODO: rather than scheduling a set_executable call,
 
802
        # have create_file create the file with the right mode.
 
803
        self.create_file(contents, trans_id, sha1=sha1)
 
804
        if executable is not None:
 
805
            self.set_executability(executable, trans_id)
 
806
        return trans_id
411
807
 
412
808
    def new_directory(self, name, parent_id, file_id=None):
413
809
        """Convenience method to create directories.
417
813
        directory.
418
814
        file_id is the inventory ID of the directory, if it is to be versioned.
419
815
        """
420
 
        raise NotImplementedError(self.new_directory)
 
816
        trans_id = self._new_entry(name, parent_id, file_id)
 
817
        self.create_directory(trans_id)
 
818
        return trans_id
421
819
 
422
820
    def new_symlink(self, name, parent_id, target, file_id=None):
423
821
        """Convenience method to create symbolic link.
427
825
        target is a bytestring of the target of the symlink.
428
826
        file_id is the inventory ID of the file, if it is to be versioned.
429
827
        """
430
 
        raise NotImplementedError(self.new_symlink)
 
828
        trans_id = self._new_entry(name, parent_id, file_id)
 
829
        self.create_symlink(target, trans_id)
 
830
        return trans_id
431
831
 
432
832
    def new_orphan(self, trans_id, parent_id):
433
833
        """Schedule an item to be orphaned.
440
840
        """
441
841
        raise NotImplementedError(self.new_orphan)
442
842
 
 
843
    def _get_potential_orphans(self, dir_id):
 
844
        """Find the potential orphans in a directory.
 
845
 
 
846
        A directory can't be safely deleted if there are versioned files in it.
 
847
        If all the contained files are unversioned then they can be orphaned.
 
848
 
 
849
        The 'None' return value means that the directory contains at least one
 
850
        versioned file and should not be deleted.
 
851
 
 
852
        :param dir_id: The directory trans id.
 
853
 
 
854
        :return: A list of the orphan trans ids or None if at least one
 
855
             versioned file is present.
 
856
        """
 
857
        orphans = []
 
858
        # Find the potential orphans, stop if one item should be kept
 
859
        for child_tid in self.by_parent()[dir_id]:
 
860
            if child_tid in self._removed_contents:
 
861
                # The child is removed as part of the transform. Since it was
 
862
                # versioned before, it's not an orphan
 
863
                continue
 
864
            elif self.final_file_id(child_tid) is None:
 
865
                # The child is not versioned
 
866
                orphans.append(child_tid)
 
867
            else:
 
868
                # We have a versioned file here, searching for orphans is
 
869
                # meaningless.
 
870
                orphans = None
 
871
                break
 
872
        return orphans
 
873
 
 
874
    def _affected_ids(self):
 
875
        """Return the set of transform ids affected by the transform"""
 
876
        trans_ids = set(self._removed_id)
 
877
        trans_ids.update(self._new_id)
 
878
        trans_ids.update(self._removed_contents)
 
879
        trans_ids.update(self._new_contents)
 
880
        trans_ids.update(self._new_executability)
 
881
        trans_ids.update(self._new_name)
 
882
        trans_ids.update(self._new_parent)
 
883
        return trans_ids
 
884
 
 
885
    def _get_file_id_maps(self):
 
886
        """Return mapping of file_ids to trans_ids in the to and from states"""
 
887
        trans_ids = self._affected_ids()
 
888
        from_trans_ids = {}
 
889
        to_trans_ids = {}
 
890
        # Build up two dicts: trans_ids associated with file ids in the
 
891
        # FROM state, vs the TO state.
 
892
        for trans_id in trans_ids:
 
893
            from_file_id = self.tree_file_id(trans_id)
 
894
            if from_file_id is not None:
 
895
                from_trans_ids[from_file_id] = trans_id
 
896
            to_file_id = self.final_file_id(trans_id)
 
897
            if to_file_id is not None:
 
898
                to_trans_ids[to_file_id] = trans_id
 
899
        return from_trans_ids, to_trans_ids
 
900
 
 
901
    def _from_file_data(self, from_trans_id, from_versioned, file_id):
 
902
        """Get data about a file in the from (tree) state
 
903
 
 
904
        Return a (name, parent, kind, executable) tuple
 
905
        """
 
906
        from_path = self._tree_id_paths.get(from_trans_id)
 
907
        if from_versioned:
 
908
            # get data from working tree if versioned
 
909
            from_entry = self._tree.iter_entries_by_dir([file_id]).next()[1]
 
910
            from_name = from_entry.name
 
911
            from_parent = from_entry.parent_id
 
912
        else:
 
913
            from_entry = None
 
914
            if from_path is None:
 
915
                # File does not exist in FROM state
 
916
                from_name = None
 
917
                from_parent = None
 
918
            else:
 
919
                # File exists, but is not versioned.  Have to use path-
 
920
                # splitting stuff
 
921
                from_name = os.path.basename(from_path)
 
922
                tree_parent = self.get_tree_parent(from_trans_id)
 
923
                from_parent = self.tree_file_id(tree_parent)
 
924
        if from_path is not None:
 
925
            from_kind, from_executable, from_stats = \
 
926
                self._tree._comparison_data(from_entry, from_path)
 
927
        else:
 
928
            from_kind = None
 
929
            from_executable = False
 
930
        return from_name, from_parent, from_kind, from_executable
 
931
 
 
932
    def _to_file_data(self, to_trans_id, from_trans_id, from_executable):
 
933
        """Get data about a file in the to (target) state
 
934
 
 
935
        Return a (name, parent, kind, executable) tuple
 
936
        """
 
937
        to_name = self.final_name(to_trans_id)
 
938
        to_kind = self.final_kind(to_trans_id)
 
939
        to_parent = self.final_file_id(self.final_parent(to_trans_id))
 
940
        if to_trans_id in self._new_executability:
 
941
            to_executable = self._new_executability[to_trans_id]
 
942
        elif to_trans_id == from_trans_id:
 
943
            to_executable = from_executable
 
944
        else:
 
945
            to_executable = False
 
946
        return to_name, to_parent, to_kind, to_executable
 
947
 
443
948
    def iter_changes(self):
444
949
        """Produce output in the same format as Tree.iter_changes.
445
950
 
450
955
        file_id.  Files that are not versioned in either of the FROM or TO
451
956
        states are not reflected.
452
957
        """
453
 
        raise NotImplementedError(self.iter_changes)
 
958
        final_paths = FinalPaths(self)
 
959
        from_trans_ids, to_trans_ids = self._get_file_id_maps()
 
960
        results = []
 
961
        # Now iterate through all active file_ids
 
962
        for file_id in set(from_trans_ids).union(to_trans_ids):
 
963
            modified = False
 
964
            from_trans_id = from_trans_ids.get(file_id)
 
965
            # find file ids, and determine versioning state
 
966
            if from_trans_id is None:
 
967
                from_versioned = False
 
968
                from_trans_id = to_trans_ids[file_id]
 
969
            else:
 
970
                from_versioned = True
 
971
            to_trans_id = to_trans_ids.get(file_id)
 
972
            if to_trans_id is None:
 
973
                to_versioned = False
 
974
                to_trans_id = from_trans_id
 
975
            else:
 
976
                to_versioned = True
 
977
 
 
978
            from_name, from_parent, from_kind, from_executable = \
 
979
                self._from_file_data(from_trans_id, from_versioned, file_id)
 
980
 
 
981
            to_name, to_parent, to_kind, to_executable = \
 
982
                self._to_file_data(to_trans_id, from_trans_id, from_executable)
 
983
 
 
984
            if not from_versioned:
 
985
                from_path = None
 
986
            else:
 
987
                from_path = self._tree_id_paths.get(from_trans_id)
 
988
            if not to_versioned:
 
989
                to_path = None
 
990
            else:
 
991
                to_path = final_paths.get_path(to_trans_id)
 
992
            if from_kind != to_kind:
 
993
                modified = True
 
994
            elif to_kind in ('file', 'symlink') and (
 
995
                to_trans_id != from_trans_id or
 
996
                to_trans_id in self._new_contents):
 
997
                modified = True
 
998
            if (not modified and from_versioned == to_versioned and
 
999
                from_parent==to_parent and from_name == to_name and
 
1000
                from_executable == to_executable):
 
1001
                continue
 
1002
            results.append((file_id, (from_path, to_path), modified,
 
1003
                   (from_versioned, to_versioned),
 
1004
                   (from_parent, to_parent),
 
1005
                   (from_name, to_name),
 
1006
                   (from_kind, to_kind),
 
1007
                   (from_executable, to_executable)))
 
1008
        return iter(sorted(results, key=lambda x:x[1]))
454
1009
 
455
1010
    def get_preview_tree(self):
456
1011
        """Return a tree representing the result of the transform.
458
1013
        The tree is a snapshot, and altering the TreeTransform will invalidate
459
1014
        it.
460
1015
        """
461
 
        raise NotImplementedError(self.get_preview_tree)
 
1016
        return _PreviewTree(self)
462
1017
 
463
1018
    def commit(self, branch, message, merge_parents=None, strict=False,
464
1019
               timestamp=None, timezone=None, committer=None, authors=None,
483
1038
            may reduce performance for some non-native formats.)
484
1039
        :return: The revision_id of the revision committed.
485
1040
        """
486
 
        raise NotImplementedError(self.commit)
 
1041
        self._check_malformed()
 
1042
        if strict:
 
1043
            unversioned = set(self._new_contents).difference(set(self._new_id))
 
1044
            for trans_id in unversioned:
 
1045
                if self.final_file_id(trans_id) is None:
 
1046
                    raise errors.StrictCommitFailed()
 
1047
 
 
1048
        revno, last_rev_id = branch.last_revision_info()
 
1049
        if last_rev_id == _mod_revision.NULL_REVISION:
 
1050
            if merge_parents is not None:
 
1051
                raise ValueError('Cannot supply merge parents for first'
 
1052
                                 ' commit.')
 
1053
            parent_ids = []
 
1054
        else:
 
1055
            parent_ids = [last_rev_id]
 
1056
            if merge_parents is not None:
 
1057
                parent_ids.extend(merge_parents)
 
1058
        if self._tree.get_revision_id() != last_rev_id:
 
1059
            raise ValueError('TreeTransform not based on branch basis: %s' %
 
1060
                             self._tree.get_revision_id())
 
1061
        revprops = commit.Commit.update_revprops(revprops, branch, authors)
 
1062
        builder = branch.get_commit_builder(parent_ids,
 
1063
                                            timestamp=timestamp,
 
1064
                                            timezone=timezone,
 
1065
                                            committer=committer,
 
1066
                                            revprops=revprops,
 
1067
                                            revision_id=revision_id)
 
1068
        preview = self.get_preview_tree()
 
1069
        list(builder.record_iter_changes(preview, last_rev_id,
 
1070
                                         self.iter_changes()))
 
1071
        builder.finish_inventory()
 
1072
        revision_id = builder.commit(message)
 
1073
        branch.set_last_revision_info(revno + 1, revision_id)
 
1074
        return revision_id
 
1075
 
 
1076
    def _text_parent(self, trans_id):
 
1077
        file_id = self.tree_file_id(trans_id)
 
1078
        try:
 
1079
            if file_id is None or self._tree.kind(file_id) != 'file':
 
1080
                return None
 
1081
        except errors.NoSuchFile:
 
1082
            return None
 
1083
        return file_id
 
1084
 
 
1085
    def _get_parents_texts(self, trans_id):
 
1086
        """Get texts for compression parents of this file."""
 
1087
        file_id = self._text_parent(trans_id)
 
1088
        if file_id is None:
 
1089
            return ()
 
1090
        return (self._tree.get_file_text(file_id),)
 
1091
 
 
1092
    def _get_parents_lines(self, trans_id):
 
1093
        """Get lines for compression parents of this file."""
 
1094
        file_id = self._text_parent(trans_id)
 
1095
        if file_id is None:
 
1096
            return ()
 
1097
        return (self._tree.get_file_lines(file_id),)
 
1098
 
 
1099
    def serialize(self, serializer):
 
1100
        """Serialize this TreeTransform.
 
1101
 
 
1102
        :param serializer: A Serialiser like pack.ContainerSerializer.
 
1103
        """
 
1104
        new_name = dict((k, v.encode('utf-8')) for k, v in
 
1105
                        viewitems(self._new_name))
 
1106
        new_executability = dict((k, int(v)) for k, v in
 
1107
                                 viewitems(self._new_executability))
 
1108
        tree_path_ids = dict((k.encode('utf-8'), v)
 
1109
                             for k, v in viewitems(self._tree_path_ids))
 
1110
        attribs = {
 
1111
            '_id_number': self._id_number,
 
1112
            '_new_name': new_name,
 
1113
            '_new_parent': self._new_parent,
 
1114
            '_new_executability': new_executability,
 
1115
            '_new_id': self._new_id,
 
1116
            '_tree_path_ids': tree_path_ids,
 
1117
            '_removed_id': list(self._removed_id),
 
1118
            '_removed_contents': list(self._removed_contents),
 
1119
            '_non_present_ids': self._non_present_ids,
 
1120
            }
 
1121
        yield serializer.bytes_record(bencode.bencode(attribs),
 
1122
                                      (('attribs',),))
 
1123
        for trans_id, kind in viewitems(self._new_contents):
 
1124
            if kind == 'file':
 
1125
                lines = osutils.chunks_to_lines(
 
1126
                    self._read_file_chunks(trans_id))
 
1127
                parents = self._get_parents_lines(trans_id)
 
1128
                mpdiff = multiparent.MultiParent.from_lines(lines, parents)
 
1129
                content = ''.join(mpdiff.to_patch())
 
1130
            if kind == 'directory':
 
1131
                content = ''
 
1132
            if kind == 'symlink':
 
1133
                content = self._read_symlink_target(trans_id)
 
1134
            yield serializer.bytes_record(content, ((trans_id, kind),))
 
1135
 
 
1136
    def deserialize(self, records):
 
1137
        """Deserialize a stored TreeTransform.
 
1138
 
 
1139
        :param records: An iterable of (names, content) tuples, as per
 
1140
            pack.ContainerPushParser.
 
1141
        """
 
1142
        names, content = next(records)
 
1143
        attribs = bencode.bdecode(content)
 
1144
        self._id_number = attribs['_id_number']
 
1145
        self._new_name = dict((k, v.decode('utf-8'))
 
1146
                              for k, v in viewitems(attribs['_new_name']))
 
1147
        self._new_parent = attribs['_new_parent']
 
1148
        self._new_executability = dict((k, bool(v))
 
1149
            for k, v in viewitems(attribs['_new_executability']))
 
1150
        self._new_id = attribs['_new_id']
 
1151
        self._r_new_id = dict((v, k) for k, v in viewitems(self._new_id))
 
1152
        self._tree_path_ids = {}
 
1153
        self._tree_id_paths = {}
 
1154
        for bytepath, trans_id in viewitems(attribs['_tree_path_ids']):
 
1155
            path = bytepath.decode('utf-8')
 
1156
            self._tree_path_ids[path] = trans_id
 
1157
            self._tree_id_paths[trans_id] = path
 
1158
        self._removed_id = set(attribs['_removed_id'])
 
1159
        self._removed_contents = set(attribs['_removed_contents'])
 
1160
        self._non_present_ids = attribs['_non_present_ids']
 
1161
        for ((trans_id, kind),), content in records:
 
1162
            if kind == 'file':
 
1163
                mpdiff = multiparent.MultiParent.from_patch(content)
 
1164
                lines = mpdiff.to_lines(self._get_parents_texts(trans_id))
 
1165
                self.create_file(lines, trans_id)
 
1166
            if kind == 'directory':
 
1167
                self.create_directory(trans_id)
 
1168
            if kind == 'symlink':
 
1169
                self.create_symlink(content.decode('utf-8'), trans_id)
 
1170
 
 
1171
 
 
1172
class DiskTreeTransform(TreeTransformBase):
 
1173
    """Tree transform storing its contents on disk."""
 
1174
 
 
1175
    def __init__(self, tree, limbodir, pb=None,
 
1176
                 case_sensitive=True):
 
1177
        """Constructor.
 
1178
        :param tree: The tree that will be transformed, but not necessarily
 
1179
            the output tree.
 
1180
        :param limbodir: A directory where new files can be stored until
 
1181
            they are installed in their proper places
 
1182
        :param pb: ignored
 
1183
        :param case_sensitive: If True, the target of the transform is
 
1184
            case sensitive, not just case preserving.
 
1185
        """
 
1186
        TreeTransformBase.__init__(self, tree, pb, case_sensitive)
 
1187
        self._limbodir = limbodir
 
1188
        self._deletiondir = None
 
1189
        # A mapping of transform ids to their limbo filename
 
1190
        self._limbo_files = {}
 
1191
        self._possibly_stale_limbo_files = set()
 
1192
        # A mapping of transform ids to a set of the transform ids of children
 
1193
        # that their limbo directory has
 
1194
        self._limbo_children = {}
 
1195
        # Map transform ids to maps of child filename to child transform id
 
1196
        self._limbo_children_names = {}
 
1197
        # List of transform ids that need to be renamed from limbo into place
 
1198
        self._needs_rename = set()
 
1199
        self._creation_mtime = None
 
1200
 
 
1201
    def finalize(self):
 
1202
        """Release the working tree lock, if held, clean up limbo dir.
 
1203
 
 
1204
        This is required if apply has not been invoked, but can be invoked
 
1205
        even after apply.
 
1206
        """
 
1207
        if self._tree is None:
 
1208
            return
 
1209
        try:
 
1210
            limbo_paths = list(viewvalues(self._limbo_files))
 
1211
            limbo_paths.extend(self._possibly_stale_limbo_files)
 
1212
            limbo_paths.sort(reverse=True)
 
1213
            for path in limbo_paths:
 
1214
                try:
 
1215
                    delete_any(path)
 
1216
                except OSError as e:
 
1217
                    if e.errno != errno.ENOENT:
 
1218
                        raise
 
1219
                    # XXX: warn? perhaps we just got interrupted at an
 
1220
                    # inconvenient moment, but perhaps files are disappearing
 
1221
                    # from under us?
 
1222
            try:
 
1223
                delete_any(self._limbodir)
 
1224
            except OSError:
 
1225
                # We don't especially care *why* the dir is immortal.
 
1226
                raise ImmortalLimbo(self._limbodir)
 
1227
            try:
 
1228
                if self._deletiondir is not None:
 
1229
                    delete_any(self._deletiondir)
 
1230
            except OSError:
 
1231
                raise errors.ImmortalPendingDeletion(self._deletiondir)
 
1232
        finally:
 
1233
            TreeTransformBase.finalize(self)
 
1234
 
 
1235
    def _limbo_supports_executable(self):
 
1236
        """Check if the limbo path supports the executable bit."""
 
1237
        # FIXME: Check actual file system capabilities of limbodir
 
1238
        return osutils.supports_executable()
 
1239
 
 
1240
    def _limbo_name(self, trans_id):
 
1241
        """Generate the limbo name of a file"""
 
1242
        limbo_name = self._limbo_files.get(trans_id)
 
1243
        if limbo_name is None:
 
1244
            limbo_name = self._generate_limbo_path(trans_id)
 
1245
            self._limbo_files[trans_id] = limbo_name
 
1246
        return limbo_name
 
1247
 
 
1248
    def _generate_limbo_path(self, trans_id):
 
1249
        """Generate a limbo path using the trans_id as the relative path.
 
1250
 
 
1251
        This is suitable as a fallback, and when the transform should not be
 
1252
        sensitive to the path encoding of the limbo directory.
 
1253
        """
 
1254
        self._needs_rename.add(trans_id)
 
1255
        return pathjoin(self._limbodir, trans_id)
 
1256
 
 
1257
    def adjust_path(self, name, parent, trans_id):
 
1258
        previous_parent = self._new_parent.get(trans_id)
 
1259
        previous_name = self._new_name.get(trans_id)
 
1260
        TreeTransformBase.adjust_path(self, name, parent, trans_id)
 
1261
        if (trans_id in self._limbo_files and
 
1262
            trans_id not in self._needs_rename):
 
1263
            self._rename_in_limbo([trans_id])
 
1264
            if previous_parent != parent:
 
1265
                self._limbo_children[previous_parent].remove(trans_id)
 
1266
            if previous_parent != parent or previous_name != name:
 
1267
                del self._limbo_children_names[previous_parent][previous_name]
 
1268
 
 
1269
    def _rename_in_limbo(self, trans_ids):
 
1270
        """Fix limbo names so that the right final path is produced.
 
1271
 
 
1272
        This means we outsmarted ourselves-- we tried to avoid renaming
 
1273
        these files later by creating them with their final names in their
 
1274
        final parents.  But now the previous name or parent is no longer
 
1275
        suitable, so we have to rename them.
 
1276
 
 
1277
        Even for trans_ids that have no new contents, we must remove their
 
1278
        entries from _limbo_files, because they are now stale.
 
1279
        """
 
1280
        for trans_id in trans_ids:
 
1281
            old_path = self._limbo_files[trans_id]
 
1282
            self._possibly_stale_limbo_files.add(old_path)
 
1283
            del self._limbo_files[trans_id]
 
1284
            if trans_id not in self._new_contents:
 
1285
                continue
 
1286
            new_path = self._limbo_name(trans_id)
 
1287
            os.rename(old_path, new_path)
 
1288
            self._possibly_stale_limbo_files.remove(old_path)
 
1289
            for descendant in self._limbo_descendants(trans_id):
 
1290
                desc_path = self._limbo_files[descendant]
 
1291
                desc_path = new_path + desc_path[len(old_path):]
 
1292
                self._limbo_files[descendant] = desc_path
 
1293
 
 
1294
    def _limbo_descendants(self, trans_id):
 
1295
        """Return the set of trans_ids whose limbo paths descend from this."""
 
1296
        descendants = set(self._limbo_children.get(trans_id, []))
 
1297
        for descendant in list(descendants):
 
1298
            descendants.update(self._limbo_descendants(descendant))
 
1299
        return descendants
487
1300
 
488
1301
    def create_file(self, contents, trans_id, mode_id=None, sha1=None):
489
1302
        """Schedule creation of a new file.
499
1312
        :param sha1: If the sha1 of this content is already known, pass it in.
500
1313
            We can use it to prevent future sha1 computations.
501
1314
        """
502
 
        raise NotImplementedError(self.create_file)
 
1315
        name = self._limbo_name(trans_id)
 
1316
        f = open(name, 'wb')
 
1317
        try:
 
1318
            unique_add(self._new_contents, trans_id, 'file')
 
1319
            f.writelines(contents)
 
1320
        finally:
 
1321
            f.close()
 
1322
        self._set_mtime(name)
 
1323
        self._set_mode(trans_id, mode_id, S_ISREG)
 
1324
        # It is unfortunate we have to use lstat instead of fstat, but we just
 
1325
        # used utime and chmod on the file, so we need the accurate final
 
1326
        # details.
 
1327
        if sha1 is not None:
 
1328
            self._observed_sha1s[trans_id] = (sha1, osutils.lstat(name))
 
1329
 
 
1330
    def _read_file_chunks(self, trans_id):
 
1331
        cur_file = open(self._limbo_name(trans_id), 'rb')
 
1332
        try:
 
1333
            return cur_file.readlines()
 
1334
        finally:
 
1335
            cur_file.close()
 
1336
 
 
1337
    def _read_symlink_target(self, trans_id):
 
1338
        return os.readlink(self._limbo_name(trans_id))
 
1339
 
 
1340
    def _set_mtime(self, path):
 
1341
        """All files that are created get the same mtime.
 
1342
 
 
1343
        This time is set by the first object to be created.
 
1344
        """
 
1345
        if self._creation_mtime is None:
 
1346
            self._creation_mtime = time.time()
 
1347
        os.utime(path, (self._creation_mtime, self._creation_mtime))
 
1348
 
 
1349
    def create_hardlink(self, path, trans_id):
 
1350
        """Schedule creation of a hard link"""
 
1351
        name = self._limbo_name(trans_id)
 
1352
        try:
 
1353
            os.link(path, name)
 
1354
        except OSError as e:
 
1355
            if e.errno != errno.EPERM:
 
1356
                raise
 
1357
            raise errors.HardLinkNotSupported(path)
 
1358
        try:
 
1359
            unique_add(self._new_contents, trans_id, 'file')
 
1360
        except:
 
1361
            # Clean up the file, it never got registered so
 
1362
            # TreeTransform.finalize() won't clean it up.
 
1363
            os.unlink(name)
 
1364
            raise
503
1365
 
504
1366
    def create_directory(self, trans_id):
505
1367
        """Schedule creation of a new directory.
506
1368
 
507
1369
        See also new_directory.
508
1370
        """
509
 
        raise NotImplementedError(self.create_directory)
 
1371
        os.mkdir(self._limbo_name(trans_id))
 
1372
        unique_add(self._new_contents, trans_id, 'directory')
510
1373
 
511
1374
    def create_symlink(self, target, trans_id):
512
1375
        """Schedule creation of a new symbolic link.
514
1377
        target is a bytestring.
515
1378
        See also new_symlink.
516
1379
        """
517
 
        raise NotImplementedError(self.create_symlink)
518
 
 
519
 
    def create_hardlink(self, path, trans_id):
520
 
        """Schedule creation of a hard link"""
521
 
        raise NotImplementedError(self.create_hardlink)
 
1380
        if has_symlinks():
 
1381
            os.symlink(target, self._limbo_name(trans_id))
 
1382
            unique_add(self._new_contents, trans_id, 'symlink')
 
1383
        else:
 
1384
            try:
 
1385
                path = FinalPaths(self).get_path(trans_id)
 
1386
            except KeyError:
 
1387
                path = None
 
1388
            raise UnableCreateSymlink(path=path)
522
1389
 
523
1390
    def cancel_creation(self, trans_id):
524
1391
        """Cancel the creation of new file contents."""
525
 
        raise NotImplementedError(self.cancel_creation)
 
1392
        del self._new_contents[trans_id]
 
1393
        if trans_id in self._observed_sha1s:
 
1394
            del self._observed_sha1s[trans_id]
 
1395
        children = self._limbo_children.get(trans_id)
 
1396
        # if this is a limbo directory with children, move them before removing
 
1397
        # the directory
 
1398
        if children is not None:
 
1399
            self._rename_in_limbo(children)
 
1400
            del self._limbo_children[trans_id]
 
1401
            del self._limbo_children_names[trans_id]
 
1402
        delete_any(self._limbo_name(trans_id))
 
1403
 
 
1404
    def new_orphan(self, trans_id, parent_id):
 
1405
        conf = self._tree.get_config_stack()
 
1406
        handle_orphan = conf.get('bzr.transform.orphan_policy')
 
1407
        handle_orphan(self, trans_id, parent_id)
526
1408
 
527
1409
 
528
1410
class OrphaningError(errors.BzrError):
549
1431
def move_orphan(tt, orphan_id, parent_id):
550
1432
    """See TreeTransformBase.new_orphan.
551
1433
 
552
 
    This creates a new orphan in the `brz-orphans` dir at the root of the
 
1434
    This creates a new orphan in the `bzr-orphans` dir at the root of the
553
1435
    `TreeTransform`.
554
1436
 
555
1437
    :param tt: The TreeTransform orphaning `trans_id`.
559
1441
    :param parent_id: The orphan parent trans id.
560
1442
    """
561
1443
    # Add the orphan dir if it doesn't exist
562
 
    orphan_dir_basename = 'brz-orphans'
 
1444
    orphan_dir_basename = 'bzr-orphans'
563
1445
    od_id = tt.trans_id_tree_path(orphan_dir_basename)
564
1446
    if tt.final_kind(od_id) is None:
565
1447
        tt.create_directory(od_id)
582
1464
 
583
1465
orphaning_registry = registry.Registry()
584
1466
orphaning_registry.register(
585
 
    u'conflict', refuse_orphan,
 
1467
    'conflict', refuse_orphan,
586
1468
    'Leave orphans in place and create a conflict on the directory.')
587
1469
orphaning_registry.register(
588
 
    u'move', move_orphan,
589
 
    'Move orphans into the brz-orphans directory.')
590
 
orphaning_registry._set_default_key(u'conflict')
 
1470
    'move', move_orphan,
 
1471
    'Move orphans into the bzr-orphans directory.')
 
1472
orphaning_registry._set_default_key('conflict')
591
1473
 
592
1474
 
593
1475
opt_transform_orphan = _mod_config.RegistryOption(
594
 
    'transform.orphan_policy', orphaning_registry,
 
1476
    'bzr.transform.orphan_policy', orphaning_registry,
595
1477
    help='Policy for orphaned files during transform operations.',
596
1478
    invalid='warning')
597
1479
 
598
1480
 
 
1481
class TreeTransform(DiskTreeTransform):
 
1482
    """Represent a tree transformation.
 
1483
 
 
1484
    This object is designed to support incremental generation of the transform,
 
1485
    in any order.
 
1486
 
 
1487
    However, it gives optimum performance when parent directories are created
 
1488
    before their contents.  The transform is then able to put child files
 
1489
    directly in their parent directory, avoiding later renames.
 
1490
 
 
1491
    It is easy to produce malformed transforms, but they are generally
 
1492
    harmless.  Attempting to apply a malformed transform will cause an
 
1493
    exception to be raised before any modifications are made to the tree.
 
1494
 
 
1495
    Many kinds of malformed transforms can be corrected with the
 
1496
    resolve_conflicts function.  The remaining ones indicate programming error,
 
1497
    such as trying to create a file with no path.
 
1498
 
 
1499
    Two sets of file creation methods are supplied.  Convenience methods are:
 
1500
     * new_file
 
1501
     * new_directory
 
1502
     * new_symlink
 
1503
 
 
1504
    These are composed of the low-level methods:
 
1505
     * create_path
 
1506
     * create_file or create_directory or create_symlink
 
1507
     * version_file
 
1508
     * set_executability
 
1509
 
 
1510
    Transform/Transaction ids
 
1511
    -------------------------
 
1512
    trans_ids are temporary ids assigned to all files involved in a transform.
 
1513
    It's possible, even common, that not all files in the Tree have trans_ids.
 
1514
 
 
1515
    trans_ids are used because filenames and file_ids are not good enough
 
1516
    identifiers; filenames change, and not all files have file_ids.  File-ids
 
1517
    are also associated with trans-ids, so that moving a file moves its
 
1518
    file-id.
 
1519
 
 
1520
    trans_ids are only valid for the TreeTransform that generated them.
 
1521
 
 
1522
    Limbo
 
1523
    -----
 
1524
    Limbo is a temporary directory use to hold new versions of files.
 
1525
    Files are added to limbo by create_file, create_directory, create_symlink,
 
1526
    and their convenience variants (new_*).  Files may be removed from limbo
 
1527
    using cancel_creation.  Files are renamed from limbo into their final
 
1528
    location as part of TreeTransform.apply
 
1529
 
 
1530
    Limbo must be cleaned up, by either calling TreeTransform.apply or
 
1531
    calling TreeTransform.finalize.
 
1532
 
 
1533
    Files are placed into limbo inside their parent directories, where
 
1534
    possible.  This reduces subsequent renames, and makes operations involving
 
1535
    lots of files faster.  This optimization is only possible if the parent
 
1536
    directory is created *before* creating any of its children, so avoid
 
1537
    creating children before parents, where possible.
 
1538
 
 
1539
    Pending-deletion
 
1540
    ----------------
 
1541
    This temporary directory is used by _FileMover for storing files that are
 
1542
    about to be deleted.  In case of rollback, the files will be restored.
 
1543
    FileMover does not delete files until it is sure that a rollback will not
 
1544
    happen.
 
1545
    """
 
1546
    def __init__(self, tree, pb=None):
 
1547
        """Note: a tree_write lock is taken on the tree.
 
1548
 
 
1549
        Use TreeTransform.finalize() to release the lock (can be omitted if
 
1550
        TreeTransform.apply() called).
 
1551
        """
 
1552
        tree.lock_tree_write()
 
1553
 
 
1554
        try:
 
1555
            limbodir = urlutils.local_path_from_url(
 
1556
                tree._transport.abspath('limbo'))
 
1557
            osutils.ensure_empty_directory_exists(
 
1558
                limbodir,
 
1559
                errors.ExistingLimbo)
 
1560
            deletiondir = urlutils.local_path_from_url(
 
1561
                tree._transport.abspath('pending-deletion'))
 
1562
            osutils.ensure_empty_directory_exists(
 
1563
                deletiondir,
 
1564
                errors.ExistingPendingDeletion)
 
1565
        except:
 
1566
            tree.unlock()
 
1567
            raise
 
1568
 
 
1569
        # Cache of realpath results, to speed up canonical_path
 
1570
        self._realpaths = {}
 
1571
        # Cache of relpath results, to speed up canonical_path
 
1572
        self._relpaths = {}
 
1573
        DiskTreeTransform.__init__(self, tree, limbodir, pb,
 
1574
                                   tree.case_sensitive)
 
1575
        self._deletiondir = deletiondir
 
1576
 
 
1577
    def canonical_path(self, path):
 
1578
        """Get the canonical tree-relative path"""
 
1579
        # don't follow final symlinks
 
1580
        abs = self._tree.abspath(path)
 
1581
        if abs in self._relpaths:
 
1582
            return self._relpaths[abs]
 
1583
        dirname, basename = os.path.split(abs)
 
1584
        if dirname not in self._realpaths:
 
1585
            self._realpaths[dirname] = os.path.realpath(dirname)
 
1586
        dirname = self._realpaths[dirname]
 
1587
        abs = pathjoin(dirname, basename)
 
1588
        if dirname in self._relpaths:
 
1589
            relpath = pathjoin(self._relpaths[dirname], basename)
 
1590
            relpath = relpath.rstrip('/\\')
 
1591
        else:
 
1592
            relpath = self._tree.relpath(abs)
 
1593
        self._relpaths[abs] = relpath
 
1594
        return relpath
 
1595
 
 
1596
    def tree_kind(self, trans_id):
 
1597
        """Determine the file kind in the working tree.
 
1598
 
 
1599
        :returns: The file kind or None if the file does not exist
 
1600
        """
 
1601
        path = self._tree_id_paths.get(trans_id)
 
1602
        if path is None:
 
1603
            return None
 
1604
        try:
 
1605
            return file_kind(self._tree.abspath(path))
 
1606
        except errors.NoSuchFile:
 
1607
            return None
 
1608
 
 
1609
    def _set_mode(self, trans_id, mode_id, typefunc):
 
1610
        """Set the mode of new file contents.
 
1611
        The mode_id is the existing file to get the mode from (often the same
 
1612
        as trans_id).  The operation is only performed if there's a mode match
 
1613
        according to typefunc.
 
1614
        """
 
1615
        if mode_id is None:
 
1616
            mode_id = trans_id
 
1617
        try:
 
1618
            old_path = self._tree_id_paths[mode_id]
 
1619
        except KeyError:
 
1620
            return
 
1621
        try:
 
1622
            mode = os.stat(self._tree.abspath(old_path)).st_mode
 
1623
        except OSError as e:
 
1624
            if e.errno in (errno.ENOENT, errno.ENOTDIR):
 
1625
                # Either old_path doesn't exist, or the parent of the
 
1626
                # target is not a directory (but will be one eventually)
 
1627
                # Either way, we know it doesn't exist *right now*
 
1628
                # See also bug #248448
 
1629
                return
 
1630
            else:
 
1631
                raise
 
1632
        if typefunc(mode):
 
1633
            osutils.chmod_if_possible(self._limbo_name(trans_id), mode)
 
1634
 
 
1635
    def iter_tree_children(self, parent_id):
 
1636
        """Iterate through the entry's tree children, if any"""
 
1637
        try:
 
1638
            path = self._tree_id_paths[parent_id]
 
1639
        except KeyError:
 
1640
            return
 
1641
        try:
 
1642
            children = os.listdir(self._tree.abspath(path))
 
1643
        except OSError as e:
 
1644
            if not (osutils._is_error_enotdir(e)
 
1645
                    or e.errno in (errno.ENOENT, errno.ESRCH)):
 
1646
                raise
 
1647
            return
 
1648
 
 
1649
        for child in children:
 
1650
            childpath = joinpath(path, child)
 
1651
            if self._tree.is_control_filename(childpath):
 
1652
                continue
 
1653
            yield self.trans_id_tree_path(childpath)
 
1654
 
 
1655
    def _generate_limbo_path(self, trans_id):
 
1656
        """Generate a limbo path using the final path if possible.
 
1657
 
 
1658
        This optimizes the performance of applying the tree transform by
 
1659
        avoiding renames.  These renames can be avoided only when the parent
 
1660
        directory is already scheduled for creation.
 
1661
 
 
1662
        If the final path cannot be used, falls back to using the trans_id as
 
1663
        the relpath.
 
1664
        """
 
1665
        parent = self._new_parent.get(trans_id)
 
1666
        # if the parent directory is already in limbo (e.g. when building a
 
1667
        # tree), choose a limbo name inside the parent, to reduce further
 
1668
        # renames.
 
1669
        use_direct_path = False
 
1670
        if self._new_contents.get(parent) == 'directory':
 
1671
            filename = self._new_name.get(trans_id)
 
1672
            if filename is not None:
 
1673
                if parent not in self._limbo_children:
 
1674
                    self._limbo_children[parent] = set()
 
1675
                    self._limbo_children_names[parent] = {}
 
1676
                    use_direct_path = True
 
1677
                # the direct path can only be used if no other file has
 
1678
                # already taken this pathname, i.e. if the name is unused, or
 
1679
                # if it is already associated with this trans_id.
 
1680
                elif self._case_sensitive_target:
 
1681
                    if (self._limbo_children_names[parent].get(filename)
 
1682
                        in (trans_id, None)):
 
1683
                        use_direct_path = True
 
1684
                else:
 
1685
                    for l_filename, l_trans_id in viewitems(
 
1686
                            self._limbo_children_names[parent]):
 
1687
                        if l_trans_id == trans_id:
 
1688
                            continue
 
1689
                        if l_filename.lower() == filename.lower():
 
1690
                            break
 
1691
                    else:
 
1692
                        use_direct_path = True
 
1693
 
 
1694
        if not use_direct_path:
 
1695
            return DiskTreeTransform._generate_limbo_path(self, trans_id)
 
1696
 
 
1697
        limbo_name = pathjoin(self._limbo_files[parent], filename)
 
1698
        self._limbo_children[parent].add(trans_id)
 
1699
        self._limbo_children_names[parent][filename] = trans_id
 
1700
        return limbo_name
 
1701
 
 
1702
 
 
1703
    def apply(self, no_conflicts=False, precomputed_delta=None, _mover=None):
 
1704
        """Apply all changes to the inventory and filesystem.
 
1705
 
 
1706
        If filesystem or inventory conflicts are present, MalformedTransform
 
1707
        will be thrown.
 
1708
 
 
1709
        If apply succeeds, finalize is not necessary.
 
1710
 
 
1711
        :param no_conflicts: if True, the caller guarantees there are no
 
1712
            conflicts, so no check is made.
 
1713
        :param precomputed_delta: An inventory delta to use instead of
 
1714
            calculating one.
 
1715
        :param _mover: Supply an alternate FileMover, for testing
 
1716
        """
 
1717
        for hook in MutableTree.hooks['pre_transform']:
 
1718
            hook(self._tree, self)
 
1719
        if not no_conflicts:
 
1720
            self._check_malformed()
 
1721
        child_pb = ui.ui_factory.nested_progress_bar()
 
1722
        try:
 
1723
            if precomputed_delta is None:
 
1724
                child_pb.update(gettext('Apply phase'), 0, 2)
 
1725
                inventory_delta = self._generate_inventory_delta()
 
1726
                offset = 1
 
1727
            else:
 
1728
                inventory_delta = precomputed_delta
 
1729
                offset = 0
 
1730
            if _mover is None:
 
1731
                mover = _FileMover()
 
1732
            else:
 
1733
                mover = _mover
 
1734
            try:
 
1735
                child_pb.update(gettext('Apply phase'), 0 + offset, 2 + offset)
 
1736
                self._apply_removals(mover)
 
1737
                child_pb.update(gettext('Apply phase'), 1 + offset, 2 + offset)
 
1738
                modified_paths = self._apply_insertions(mover)
 
1739
            except:
 
1740
                mover.rollback()
 
1741
                raise
 
1742
            else:
 
1743
                mover.apply_deletions()
 
1744
        finally:
 
1745
            child_pb.finished()
 
1746
        if self.final_file_id(self.root) is None:
 
1747
            inventory_delta = [e for e in inventory_delta if e[0] != '']
 
1748
        self._tree.apply_inventory_delta(inventory_delta)
 
1749
        self._apply_observed_sha1s()
 
1750
        self._done = True
 
1751
        self.finalize()
 
1752
        return _TransformResults(modified_paths, self.rename_count)
 
1753
 
 
1754
    def _generate_inventory_delta(self):
 
1755
        """Generate an inventory delta for the current transform."""
 
1756
        inventory_delta = []
 
1757
        child_pb = ui.ui_factory.nested_progress_bar()
 
1758
        new_paths = self._inventory_altered()
 
1759
        total_entries = len(new_paths) + len(self._removed_id)
 
1760
        try:
 
1761
            for num, trans_id in enumerate(self._removed_id):
 
1762
                if (num % 10) == 0:
 
1763
                    child_pb.update(gettext('removing file'), num, total_entries)
 
1764
                if trans_id == self._new_root:
 
1765
                    file_id = self._tree.get_root_id()
 
1766
                else:
 
1767
                    file_id = self.tree_file_id(trans_id)
 
1768
                # File-id isn't really being deleted, just moved
 
1769
                if file_id in self._r_new_id:
 
1770
                    continue
 
1771
                path = self._tree_id_paths[trans_id]
 
1772
                inventory_delta.append((path, None, file_id, None))
 
1773
            new_path_file_ids = dict((t, self.final_file_id(t)) for p, t in
 
1774
                                     new_paths)
 
1775
            entries = self._tree.iter_entries_by_dir(
 
1776
                viewvalues(new_path_file_ids))
 
1777
            old_paths = dict((e.file_id, p) for p, e in entries)
 
1778
            final_kinds = {}
 
1779
            for num, (path, trans_id) in enumerate(new_paths):
 
1780
                if (num % 10) == 0:
 
1781
                    child_pb.update(gettext('adding file'),
 
1782
                                    num + len(self._removed_id), total_entries)
 
1783
                file_id = new_path_file_ids[trans_id]
 
1784
                if file_id is None:
 
1785
                    continue
 
1786
                needs_entry = False
 
1787
                kind = self.final_kind(trans_id)
 
1788
                if kind is None:
 
1789
                    kind = self._tree.stored_kind(file_id)
 
1790
                parent_trans_id = self.final_parent(trans_id)
 
1791
                parent_file_id = new_path_file_ids.get(parent_trans_id)
 
1792
                if parent_file_id is None:
 
1793
                    parent_file_id = self.final_file_id(parent_trans_id)
 
1794
                if trans_id in self._new_reference_revision:
 
1795
                    new_entry = inventory.TreeReference(
 
1796
                        file_id,
 
1797
                        self._new_name[trans_id],
 
1798
                        self.final_file_id(self._new_parent[trans_id]),
 
1799
                        None, self._new_reference_revision[trans_id])
 
1800
                else:
 
1801
                    new_entry = inventory.make_entry(kind,
 
1802
                        self.final_name(trans_id),
 
1803
                        parent_file_id, file_id)
 
1804
                old_path = old_paths.get(new_entry.file_id)
 
1805
                new_executability = self._new_executability.get(trans_id)
 
1806
                if new_executability is not None:
 
1807
                    new_entry.executable = new_executability
 
1808
                inventory_delta.append(
 
1809
                    (old_path, path, new_entry.file_id, new_entry))
 
1810
        finally:
 
1811
            child_pb.finished()
 
1812
        return inventory_delta
 
1813
 
 
1814
    def _apply_removals(self, mover):
 
1815
        """Perform tree operations that remove directory/inventory names.
 
1816
 
 
1817
        That is, delete files that are to be deleted, and put any files that
 
1818
        need renaming into limbo.  This must be done in strict child-to-parent
 
1819
        order.
 
1820
 
 
1821
        If inventory_delta is None, no inventory delta generation is performed.
 
1822
        """
 
1823
        tree_paths = sorted(viewitems(self._tree_path_ids), reverse=True)
 
1824
        child_pb = ui.ui_factory.nested_progress_bar()
 
1825
        try:
 
1826
            for num, (path, trans_id) in enumerate(tree_paths):
 
1827
                # do not attempt to move root into a subdirectory of itself.
 
1828
                if path == '':
 
1829
                    continue
 
1830
                child_pb.update(gettext('removing file'), num, len(tree_paths))
 
1831
                full_path = self._tree.abspath(path)
 
1832
                if trans_id in self._removed_contents:
 
1833
                    delete_path = os.path.join(self._deletiondir, trans_id)
 
1834
                    mover.pre_delete(full_path, delete_path)
 
1835
                elif (trans_id in self._new_name
 
1836
                      or trans_id in self._new_parent):
 
1837
                    try:
 
1838
                        mover.rename(full_path, self._limbo_name(trans_id))
 
1839
                    except errors.TransformRenameFailed as e:
 
1840
                        if e.errno != errno.ENOENT:
 
1841
                            raise
 
1842
                    else:
 
1843
                        self.rename_count += 1
 
1844
        finally:
 
1845
            child_pb.finished()
 
1846
 
 
1847
    def _apply_insertions(self, mover):
 
1848
        """Perform tree operations that insert directory/inventory names.
 
1849
 
 
1850
        That is, create any files that need to be created, and restore from
 
1851
        limbo any files that needed renaming.  This must be done in strict
 
1852
        parent-to-child order.
 
1853
 
 
1854
        If inventory_delta is None, no inventory delta is calculated, and
 
1855
        no list of modified paths is returned.
 
1856
        """
 
1857
        new_paths = self.new_paths(filesystem_only=True)
 
1858
        modified_paths = []
 
1859
        new_path_file_ids = dict((t, self.final_file_id(t)) for p, t in
 
1860
                                 new_paths)
 
1861
        child_pb = ui.ui_factory.nested_progress_bar()
 
1862
        try:
 
1863
            for num, (path, trans_id) in enumerate(new_paths):
 
1864
                if (num % 10) == 0:
 
1865
                    child_pb.update(gettext('adding file'), num, len(new_paths))
 
1866
                full_path = self._tree.abspath(path)
 
1867
                if trans_id in self._needs_rename:
 
1868
                    try:
 
1869
                        mover.rename(self._limbo_name(trans_id), full_path)
 
1870
                    except errors.TransformRenameFailed as e:
 
1871
                        # We may be renaming a dangling inventory id
 
1872
                        if e.errno != errno.ENOENT:
 
1873
                            raise
 
1874
                    else:
 
1875
                        self.rename_count += 1
 
1876
                    # TODO: if trans_id in self._observed_sha1s, we should
 
1877
                    #       re-stat the final target, since ctime will be
 
1878
                    #       updated by the change.
 
1879
                if (trans_id in self._new_contents or
 
1880
                    self.path_changed(trans_id)):
 
1881
                    if trans_id in self._new_contents:
 
1882
                        modified_paths.append(full_path)
 
1883
                if trans_id in self._new_executability:
 
1884
                    self._set_executability(path, trans_id)
 
1885
                if trans_id in self._observed_sha1s:
 
1886
                    o_sha1, o_st_val = self._observed_sha1s[trans_id]
 
1887
                    st = osutils.lstat(full_path)
 
1888
                    self._observed_sha1s[trans_id] = (o_sha1, st)
 
1889
        finally:
 
1890
            child_pb.finished()
 
1891
        for path, trans_id in new_paths:
 
1892
            # new_paths includes stuff like workingtree conflicts. Only the
 
1893
            # stuff in new_contents actually comes from limbo.
 
1894
            if trans_id in self._limbo_files:
 
1895
                del self._limbo_files[trans_id]
 
1896
        self._new_contents.clear()
 
1897
        return modified_paths
 
1898
 
 
1899
    def _apply_observed_sha1s(self):
 
1900
        """After we have finished renaming everything, update observed sha1s
 
1901
 
 
1902
        This has to be done after self._tree.apply_inventory_delta, otherwise
 
1903
        it doesn't know anything about the files we are updating. Also, we want
 
1904
        to do this as late as possible, so that most entries end up cached.
 
1905
        """
 
1906
        # TODO: this doesn't update the stat information for directories. So
 
1907
        #       the first 'bzr status' will still need to rewrite
 
1908
        #       .bzr/checkout/dirstate. However, we at least don't need to
 
1909
        #       re-read all of the files.
 
1910
        # TODO: If the operation took a while, we could do a time.sleep(3) here
 
1911
        #       to allow the clock to tick over and ensure we won't have any
 
1912
        #       problems. (we could observe start time, and finish time, and if
 
1913
        #       it is less than eg 10% overhead, add a sleep call.)
 
1914
        paths = FinalPaths(self)
 
1915
        for trans_id, observed in viewitems(self._observed_sha1s):
 
1916
            path = paths.get_path(trans_id)
 
1917
            # We could get the file_id, but dirstate prefers to use the path
 
1918
            # anyway, and it is 'cheaper' to determine.
 
1919
            # file_id = self._new_id[trans_id]
 
1920
            self._tree._observed_sha1(None, path, observed)
 
1921
 
 
1922
 
 
1923
class TransformPreview(DiskTreeTransform):
 
1924
    """A TreeTransform for generating preview trees.
 
1925
 
 
1926
    Unlike TreeTransform, this version works when the input tree is a
 
1927
    RevisionTree, rather than a WorkingTree.  As a result, it tends to ignore
 
1928
    unversioned files in the input tree.
 
1929
    """
 
1930
 
 
1931
    def __init__(self, tree, pb=None, case_sensitive=True):
 
1932
        tree.lock_read()
 
1933
        limbodir = osutils.mkdtemp(prefix='bzr-limbo-')
 
1934
        DiskTreeTransform.__init__(self, tree, limbodir, pb, case_sensitive)
 
1935
 
 
1936
    def canonical_path(self, path):
 
1937
        return path
 
1938
 
 
1939
    def tree_kind(self, trans_id):
 
1940
        path = self._tree_id_paths.get(trans_id)
 
1941
        if path is None:
 
1942
            return None
 
1943
        kind = self._tree.path_content_summary(path)[0]
 
1944
        if kind == 'missing':
 
1945
            kind = None
 
1946
        return kind
 
1947
 
 
1948
    def _set_mode(self, trans_id, mode_id, typefunc):
 
1949
        """Set the mode of new file contents.
 
1950
        The mode_id is the existing file to get the mode from (often the same
 
1951
        as trans_id).  The operation is only performed if there's a mode match
 
1952
        according to typefunc.
 
1953
        """
 
1954
        # is it ok to ignore this?  probably
 
1955
        pass
 
1956
 
 
1957
    def iter_tree_children(self, parent_id):
 
1958
        """Iterate through the entry's tree children, if any"""
 
1959
        try:
 
1960
            path = self._tree_id_paths[parent_id]
 
1961
        except KeyError:
 
1962
            return
 
1963
        file_id = self.tree_file_id(parent_id)
 
1964
        if file_id is None:
 
1965
            return
 
1966
        entry = self._tree.iter_entries_by_dir([file_id]).next()[1]
 
1967
        children = getattr(entry, 'children', {})
 
1968
        for child in children:
 
1969
            childpath = joinpath(path, child)
 
1970
            yield self.trans_id_tree_path(childpath)
 
1971
 
 
1972
    def new_orphan(self, trans_id, parent_id):
 
1973
        raise NotImplementedError(self.new_orphan)
 
1974
 
 
1975
 
 
1976
class _PreviewTree(tree.InventoryTree):
 
1977
    """Partial implementation of Tree to support show_diff_trees"""
 
1978
 
 
1979
    def __init__(self, transform):
 
1980
        self._transform = transform
 
1981
        self._final_paths = FinalPaths(transform)
 
1982
        self.__by_parent = None
 
1983
        self._parent_ids = []
 
1984
        self._all_children_cache = {}
 
1985
        self._path2trans_id_cache = {}
 
1986
        self._final_name_cache = {}
 
1987
        self._iter_changes_cache = dict((c[0], c) for c in
 
1988
                                        self._transform.iter_changes())
 
1989
 
 
1990
    def _content_change(self, file_id):
 
1991
        """Return True if the content of this file changed"""
 
1992
        changes = self._iter_changes_cache.get(file_id)
 
1993
        # changes[2] is true if the file content changed.  See
 
1994
        # InterTree.iter_changes.
 
1995
        return (changes is not None and changes[2])
 
1996
 
 
1997
    def _get_repository(self):
 
1998
        repo = getattr(self._transform._tree, '_repository', None)
 
1999
        if repo is None:
 
2000
            repo = self._transform._tree.branch.repository
 
2001
        return repo
 
2002
 
 
2003
    def _iter_parent_trees(self):
 
2004
        for revision_id in self.get_parent_ids():
 
2005
            try:
 
2006
                yield self.revision_tree(revision_id)
 
2007
            except errors.NoSuchRevisionInTree:
 
2008
                yield self._get_repository().revision_tree(revision_id)
 
2009
 
 
2010
    def _get_file_revision(self, file_id, vf, tree_revision):
 
2011
        parent_keys = [(file_id, t.get_file_revision(file_id)) for t in
 
2012
                       self._iter_parent_trees()]
 
2013
        vf.add_lines((file_id, tree_revision), parent_keys,
 
2014
                     self.get_file_lines(file_id))
 
2015
        repo = self._get_repository()
 
2016
        base_vf = repo.texts
 
2017
        if base_vf not in vf.fallback_versionedfiles:
 
2018
            vf.fallback_versionedfiles.append(base_vf)
 
2019
        return tree_revision
 
2020
 
 
2021
    def _stat_limbo_file(self, file_id=None, trans_id=None):
 
2022
        if trans_id is None:
 
2023
            trans_id = self._transform.trans_id_file_id(file_id)
 
2024
        name = self._transform._limbo_name(trans_id)
 
2025
        return os.lstat(name)
 
2026
 
 
2027
    @property
 
2028
    def _by_parent(self):
 
2029
        if self.__by_parent is None:
 
2030
            self.__by_parent = self._transform.by_parent()
 
2031
        return self.__by_parent
 
2032
 
 
2033
    def _comparison_data(self, entry, path):
 
2034
        kind, size, executable, link_or_sha1 = self.path_content_summary(path)
 
2035
        if kind == 'missing':
 
2036
            kind = None
 
2037
            executable = False
 
2038
        else:
 
2039
            file_id = self._transform.final_file_id(self._path2trans_id(path))
 
2040
            executable = self.is_executable(file_id, path)
 
2041
        return kind, executable, None
 
2042
 
 
2043
    def is_locked(self):
 
2044
        return False
 
2045
 
 
2046
    def lock_read(self):
 
2047
        # Perhaps in theory, this should lock the TreeTransform?
 
2048
        return self
 
2049
 
 
2050
    def unlock(self):
 
2051
        pass
 
2052
 
 
2053
    @property
 
2054
    def root_inventory(self):
 
2055
        """This Tree does not use inventory as its backing data."""
 
2056
        raise NotImplementedError(_PreviewTree.root_inventory)
 
2057
 
 
2058
    def get_root_id(self):
 
2059
        return self._transform.final_file_id(self._transform.root)
 
2060
 
 
2061
    def all_file_ids(self):
 
2062
        tree_ids = set(self._transform._tree.all_file_ids())
 
2063
        tree_ids.difference_update(self._transform.tree_file_id(t)
 
2064
                                   for t in self._transform._removed_id)
 
2065
        tree_ids.update(viewvalues(self._transform._new_id))
 
2066
        return tree_ids
 
2067
 
 
2068
    def __iter__(self):
 
2069
        return iter(self.all_file_ids())
 
2070
 
 
2071
    def _has_id(self, file_id, fallback_check):
 
2072
        if file_id in self._transform._r_new_id:
 
2073
            return True
 
2074
        elif file_id in {self._transform.tree_file_id(trans_id) for
 
2075
            trans_id in self._transform._removed_id}:
 
2076
            return False
 
2077
        else:
 
2078
            return fallback_check(file_id)
 
2079
 
 
2080
    def has_id(self, file_id):
 
2081
        return self._has_id(file_id, self._transform._tree.has_id)
 
2082
 
 
2083
    def has_or_had_id(self, file_id):
 
2084
        return self._has_id(file_id, self._transform._tree.has_or_had_id)
 
2085
 
 
2086
    def _path2trans_id(self, path):
 
2087
        # We must not use None here, because that is a valid value to store.
 
2088
        trans_id = self._path2trans_id_cache.get(path, object)
 
2089
        if trans_id is not object:
 
2090
            return trans_id
 
2091
        segments = splitpath(path)
 
2092
        cur_parent = self._transform.root
 
2093
        for cur_segment in segments:
 
2094
            for child in self._all_children(cur_parent):
 
2095
                final_name = self._final_name_cache.get(child)
 
2096
                if final_name is None:
 
2097
                    final_name = self._transform.final_name(child)
 
2098
                    self._final_name_cache[child] = final_name
 
2099
                if final_name == cur_segment:
 
2100
                    cur_parent = child
 
2101
                    break
 
2102
            else:
 
2103
                self._path2trans_id_cache[path] = None
 
2104
                return None
 
2105
        self._path2trans_id_cache[path] = cur_parent
 
2106
        return cur_parent
 
2107
 
 
2108
    def path2id(self, path):
 
2109
        if isinstance(path, list):
 
2110
            if path == []:
 
2111
                path = [""]
 
2112
            path = osutils.pathjoin(*path)
 
2113
        return self._transform.final_file_id(self._path2trans_id(path))
 
2114
 
 
2115
    def id2path(self, file_id):
 
2116
        trans_id = self._transform.trans_id_file_id(file_id)
 
2117
        try:
 
2118
            return self._final_paths._determine_path(trans_id)
 
2119
        except NoFinalPath:
 
2120
            raise errors.NoSuchId(self, file_id)
 
2121
 
 
2122
    def _all_children(self, trans_id):
 
2123
        children = self._all_children_cache.get(trans_id)
 
2124
        if children is not None:
 
2125
            return children
 
2126
        children = set(self._transform.iter_tree_children(trans_id))
 
2127
        # children in the _new_parent set are provided by _by_parent.
 
2128
        children.difference_update(self._transform._new_parent)
 
2129
        children.update(self._by_parent.get(trans_id, []))
 
2130
        self._all_children_cache[trans_id] = children
 
2131
        return children
 
2132
 
 
2133
    def iter_children(self, file_id):
 
2134
        trans_id = self._transform.trans_id_file_id(file_id)
 
2135
        for child_trans_id in self._all_children(trans_id):
 
2136
            yield self._transform.final_file_id(child_trans_id)
 
2137
 
 
2138
    def extras(self):
 
2139
        possible_extras = set(self._transform.trans_id_tree_path(p) for p
 
2140
                              in self._transform._tree.extras())
 
2141
        possible_extras.update(self._transform._new_contents)
 
2142
        possible_extras.update(self._transform._removed_id)
 
2143
        for trans_id in possible_extras:
 
2144
            if self._transform.final_file_id(trans_id) is None:
 
2145
                yield self._final_paths._determine_path(trans_id)
 
2146
 
 
2147
    def _make_inv_entries(self, ordered_entries, specific_file_ids=None,
 
2148
        yield_parents=False):
 
2149
        for trans_id, parent_file_id in ordered_entries:
 
2150
            file_id = self._transform.final_file_id(trans_id)
 
2151
            if file_id is None:
 
2152
                continue
 
2153
            if (specific_file_ids is not None
 
2154
                and file_id not in specific_file_ids):
 
2155
                continue
 
2156
            kind = self._transform.final_kind(trans_id)
 
2157
            if kind is None:
 
2158
                kind = self._transform._tree.stored_kind(file_id)
 
2159
            new_entry = inventory.make_entry(
 
2160
                kind,
 
2161
                self._transform.final_name(trans_id),
 
2162
                parent_file_id, file_id)
 
2163
            yield new_entry, trans_id
 
2164
 
 
2165
    def _list_files_by_dir(self):
 
2166
        todo = [ROOT_PARENT]
 
2167
        ordered_ids = []
 
2168
        while len(todo) > 0:
 
2169
            parent = todo.pop()
 
2170
            parent_file_id = self._transform.final_file_id(parent)
 
2171
            children = list(self._all_children(parent))
 
2172
            paths = dict(zip(children, self._final_paths.get_paths(children)))
 
2173
            children.sort(key=paths.get)
 
2174
            todo.extend(reversed(children))
 
2175
            for trans_id in children:
 
2176
                ordered_ids.append((trans_id, parent_file_id))
 
2177
        return ordered_ids
 
2178
 
 
2179
    def iter_child_entries(self, file_id, path=None):
 
2180
        self.id2path(file_id)
 
2181
        trans_id = self._transform.trans_id_file_id(file_id)
 
2182
        todo = [(child_trans_id, trans_id) for child_trans_id in
 
2183
                self._all_children(trans_id)]
 
2184
        for entry, trans_id in self._make_inv_entries(todo):
 
2185
            yield entry
 
2186
 
 
2187
    def iter_entries_by_dir(self, specific_file_ids=None, yield_parents=False):
 
2188
        # This may not be a maximally efficient implementation, but it is
 
2189
        # reasonably straightforward.  An implementation that grafts the
 
2190
        # TreeTransform changes onto the tree's iter_entries_by_dir results
 
2191
        # might be more efficient, but requires tricky inferences about stack
 
2192
        # position.
 
2193
        ordered_ids = self._list_files_by_dir()
 
2194
        for entry, trans_id in self._make_inv_entries(ordered_ids,
 
2195
            specific_file_ids, yield_parents=yield_parents):
 
2196
            yield unicode(self._final_paths.get_path(trans_id)), entry
 
2197
 
 
2198
    def _iter_entries_for_dir(self, dir_path):
 
2199
        """Return path, entry for items in a directory without recursing down."""
 
2200
        dir_file_id = self.path2id(dir_path)
 
2201
        ordered_ids = []
 
2202
        for file_id in self.iter_children(dir_file_id):
 
2203
            trans_id = self._transform.trans_id_file_id(file_id)
 
2204
            ordered_ids.append((trans_id, file_id))
 
2205
        for entry, trans_id in self._make_inv_entries(ordered_ids):
 
2206
            yield unicode(self._final_paths.get_path(trans_id)), entry
 
2207
 
 
2208
    def list_files(self, include_root=False, from_dir=None, recursive=True):
 
2209
        """See WorkingTree.list_files."""
 
2210
        # XXX This should behave like WorkingTree.list_files, but is really
 
2211
        # more like RevisionTree.list_files.
 
2212
        if recursive:
 
2213
            prefix = None
 
2214
            if from_dir:
 
2215
                prefix = from_dir + '/'
 
2216
            entries = self.iter_entries_by_dir()
 
2217
            for path, entry in entries:
 
2218
                if entry.name == '' and not include_root:
 
2219
                    continue
 
2220
                if prefix:
 
2221
                    if not path.startswith(prefix):
 
2222
                        continue
 
2223
                    path = path[len(prefix):]
 
2224
                yield path, 'V', entry.kind, entry.file_id, entry
 
2225
        else:
 
2226
            if from_dir is None and include_root is True:
 
2227
                root_entry = inventory.make_entry('directory', '',
 
2228
                    ROOT_PARENT, self.get_root_id())
 
2229
                yield '', 'V', 'directory', root_entry.file_id, root_entry
 
2230
            entries = self._iter_entries_for_dir(from_dir or '')
 
2231
            for path, entry in entries:
 
2232
                yield path, 'V', entry.kind, entry.file_id, entry
 
2233
 
 
2234
    def kind(self, file_id):
 
2235
        trans_id = self._transform.trans_id_file_id(file_id)
 
2236
        return self._transform.final_kind(trans_id)
 
2237
 
 
2238
    def stored_kind(self, file_id):
 
2239
        trans_id = self._transform.trans_id_file_id(file_id)
 
2240
        try:
 
2241
            return self._transform._new_contents[trans_id]
 
2242
        except KeyError:
 
2243
            return self._transform._tree.stored_kind(file_id)
 
2244
 
 
2245
    def get_file_mtime(self, file_id, path=None):
 
2246
        """See Tree.get_file_mtime"""
 
2247
        if not self._content_change(file_id):
 
2248
            return self._transform._tree.get_file_mtime(file_id)
 
2249
        return self._stat_limbo_file(file_id).st_mtime
 
2250
 
 
2251
    def _file_size(self, entry, stat_value):
 
2252
        return self.get_file_size(entry.file_id)
 
2253
 
 
2254
    def get_file_size(self, file_id):
 
2255
        """See Tree.get_file_size"""
 
2256
        trans_id = self._transform.trans_id_file_id(file_id)
 
2257
        kind = self._transform.final_kind(trans_id)
 
2258
        if kind != 'file':
 
2259
            return None
 
2260
        if trans_id in self._transform._new_contents:
 
2261
            return self._stat_limbo_file(trans_id=trans_id).st_size
 
2262
        if self.kind(file_id) == 'file':
 
2263
            return self._transform._tree.get_file_size(file_id)
 
2264
        else:
 
2265
            return None
 
2266
 
 
2267
    def get_file_verifier(self, file_id, path=None, stat_value=None):
 
2268
        trans_id = self._transform.trans_id_file_id(file_id)
 
2269
        kind = self._transform._new_contents.get(trans_id)
 
2270
        if kind is None:
 
2271
            return self._transform._tree.get_file_verifier(file_id)
 
2272
        if kind == 'file':
 
2273
            fileobj = self.get_file(file_id)
 
2274
            try:
 
2275
                return ("SHA1", sha_file(fileobj))
 
2276
            finally:
 
2277
                fileobj.close()
 
2278
 
 
2279
    def get_file_sha1(self, file_id, path=None, stat_value=None):
 
2280
        trans_id = self._transform.trans_id_file_id(file_id)
 
2281
        kind = self._transform._new_contents.get(trans_id)
 
2282
        if kind is None:
 
2283
            return self._transform._tree.get_file_sha1(file_id)
 
2284
        if kind == 'file':
 
2285
            fileobj = self.get_file(file_id)
 
2286
            try:
 
2287
                return sha_file(fileobj)
 
2288
            finally:
 
2289
                fileobj.close()
 
2290
 
 
2291
    def is_executable(self, file_id, path=None):
 
2292
        if file_id is None:
 
2293
            return False
 
2294
        trans_id = self._transform.trans_id_file_id(file_id)
 
2295
        try:
 
2296
            return self._transform._new_executability[trans_id]
 
2297
        except KeyError:
 
2298
            try:
 
2299
                return self._transform._tree.is_executable(file_id, path)
 
2300
            except OSError as e:
 
2301
                if e.errno == errno.ENOENT:
 
2302
                    return False
 
2303
                raise
 
2304
            except errors.NoSuchId:
 
2305
                return False
 
2306
 
 
2307
    def has_filename(self, path):
 
2308
        trans_id = self._path2trans_id(path)
 
2309
        if trans_id in self._transform._new_contents:
 
2310
            return True
 
2311
        elif trans_id in self._transform._removed_contents:
 
2312
            return False
 
2313
        else:
 
2314
            return self._transform._tree.has_filename(path)
 
2315
 
 
2316
    def path_content_summary(self, path):
 
2317
        trans_id = self._path2trans_id(path)
 
2318
        tt = self._transform
 
2319
        tree_path = tt._tree_id_paths.get(trans_id)
 
2320
        kind = tt._new_contents.get(trans_id)
 
2321
        if kind is None:
 
2322
            if tree_path is None or trans_id in tt._removed_contents:
 
2323
                return 'missing', None, None, None
 
2324
            summary = tt._tree.path_content_summary(tree_path)
 
2325
            kind, size, executable, link_or_sha1 = summary
 
2326
        else:
 
2327
            link_or_sha1 = None
 
2328
            limbo_name = tt._limbo_name(trans_id)
 
2329
            if trans_id in tt._new_reference_revision:
 
2330
                kind = 'tree-reference'
 
2331
            if kind == 'file':
 
2332
                statval = os.lstat(limbo_name)
 
2333
                size = statval.st_size
 
2334
                if not tt._limbo_supports_executable():
 
2335
                    executable = False
 
2336
                else:
 
2337
                    executable = statval.st_mode & S_IEXEC
 
2338
            else:
 
2339
                size = None
 
2340
                executable = None
 
2341
            if kind == 'symlink':
 
2342
                link_or_sha1 = os.readlink(limbo_name).decode(osutils._fs_enc)
 
2343
        executable = tt._new_executability.get(trans_id, executable)
 
2344
        return kind, size, executable, link_or_sha1
 
2345
 
 
2346
    def iter_changes(self, from_tree, include_unchanged=False,
 
2347
                      specific_files=None, pb=None, extra_trees=None,
 
2348
                      require_versioned=True, want_unversioned=False):
 
2349
        """See InterTree.iter_changes.
 
2350
 
 
2351
        This has a fast path that is only used when the from_tree matches
 
2352
        the transform tree, and no fancy options are supplied.
 
2353
        """
 
2354
        if (from_tree is not self._transform._tree or include_unchanged or
 
2355
            specific_files or want_unversioned):
 
2356
            return tree.InterTree(from_tree, self).iter_changes(
 
2357
                include_unchanged=include_unchanged,
 
2358
                specific_files=specific_files,
 
2359
                pb=pb,
 
2360
                extra_trees=extra_trees,
 
2361
                require_versioned=require_versioned,
 
2362
                want_unversioned=want_unversioned)
 
2363
        if want_unversioned:
 
2364
            raise ValueError('want_unversioned is not supported')
 
2365
        return self._transform.iter_changes()
 
2366
 
 
2367
    def get_file(self, file_id, path=None):
 
2368
        """See Tree.get_file"""
 
2369
        if not self._content_change(file_id):
 
2370
            return self._transform._tree.get_file(file_id, path)
 
2371
        trans_id = self._transform.trans_id_file_id(file_id)
 
2372
        name = self._transform._limbo_name(trans_id)
 
2373
        return open(name, 'rb')
 
2374
 
 
2375
    def get_file_with_stat(self, file_id, path=None):
 
2376
        return self.get_file(file_id, path), None
 
2377
 
 
2378
    def annotate_iter(self, file_id,
 
2379
                      default_revision=_mod_revision.CURRENT_REVISION):
 
2380
        changes = self._iter_changes_cache.get(file_id)
 
2381
        if changes is None:
 
2382
            get_old = True
 
2383
        else:
 
2384
            changed_content, versioned, kind = (changes[2], changes[3],
 
2385
                                                changes[6])
 
2386
            if kind[1] is None:
 
2387
                return None
 
2388
            get_old = (kind[0] == 'file' and versioned[0])
 
2389
        if get_old:
 
2390
            old_annotation = self._transform._tree.annotate_iter(file_id,
 
2391
                default_revision=default_revision)
 
2392
        else:
 
2393
            old_annotation = []
 
2394
        if changes is None:
 
2395
            return old_annotation
 
2396
        if not changed_content:
 
2397
            return old_annotation
 
2398
        # TODO: This is doing something similar to what WT.annotate_iter is
 
2399
        #       doing, however it fails slightly because it doesn't know what
 
2400
        #       the *other* revision_id is, so it doesn't know how to give the
 
2401
        #       other as the origin for some lines, they all get
 
2402
        #       'default_revision'
 
2403
        #       It would be nice to be able to use the new Annotator based
 
2404
        #       approach, as well.
 
2405
        return annotate.reannotate([old_annotation],
 
2406
                                   self.get_file(file_id).readlines(),
 
2407
                                   default_revision)
 
2408
 
 
2409
    def get_symlink_target(self, file_id, path=None):
 
2410
        """See Tree.get_symlink_target"""
 
2411
        if not self._content_change(file_id):
 
2412
            return self._transform._tree.get_symlink_target(file_id)
 
2413
        trans_id = self._transform.trans_id_file_id(file_id)
 
2414
        name = self._transform._limbo_name(trans_id)
 
2415
        return osutils.readlink(name)
 
2416
 
 
2417
    def walkdirs(self, prefix=''):
 
2418
        pending = [self._transform.root]
 
2419
        while len(pending) > 0:
 
2420
            parent_id = pending.pop()
 
2421
            children = []
 
2422
            subdirs = []
 
2423
            prefix = prefix.rstrip('/')
 
2424
            parent_path = self._final_paths.get_path(parent_id)
 
2425
            parent_file_id = self._transform.final_file_id(parent_id)
 
2426
            for child_id in self._all_children(parent_id):
 
2427
                path_from_root = self._final_paths.get_path(child_id)
 
2428
                basename = self._transform.final_name(child_id)
 
2429
                file_id = self._transform.final_file_id(child_id)
 
2430
                kind  = self._transform.final_kind(child_id)
 
2431
                if kind is not None:
 
2432
                    versioned_kind = kind
 
2433
                else:
 
2434
                    kind = 'unknown'
 
2435
                    versioned_kind = self._transform._tree.stored_kind(file_id)
 
2436
                if versioned_kind == 'directory':
 
2437
                    subdirs.append(child_id)
 
2438
                children.append((path_from_root, basename, kind, None,
 
2439
                                 file_id, versioned_kind))
 
2440
            children.sort()
 
2441
            if parent_path.startswith(prefix):
 
2442
                yield (parent_path, parent_file_id), children
 
2443
            pending.extend(sorted(subdirs, key=self._final_paths.get_path,
 
2444
                                  reverse=True))
 
2445
 
 
2446
    def get_parent_ids(self):
 
2447
        return self._parent_ids
 
2448
 
 
2449
    def set_parent_ids(self, parent_ids):
 
2450
        self._parent_ids = parent_ids
 
2451
 
 
2452
    def get_revision_tree(self, revision_id):
 
2453
        return self._transform._tree.get_revision_tree(revision_id)
 
2454
 
 
2455
 
599
2456
def joinpath(parent, child):
600
2457
    """Join tree-relative paths, handling the tree root specially"""
601
2458
    if parent is None or parent == "":
610
2467
    The underlying tree must not be manipulated between calls, or else
611
2468
    the results will likely be incorrect.
612
2469
    """
613
 
 
614
2470
    def __init__(self, transform):
615
2471
        object.__init__(self)
616
2472
        self._known_paths = {}
618
2474
 
619
2475
    def _determine_path(self, trans_id):
620
2476
        if (trans_id == self.transform.root or trans_id == ROOT_PARENT):
621
 
            return u""
 
2477
            return ""
622
2478
        name = self.transform.final_name(trans_id)
623
2479
        parent_id = self.transform.final_parent(trans_id)
624
2480
        if parent_id == self.transform.root:
636
2492
        return [(self.get_path(t), t) for t in trans_ids]
637
2493
 
638
2494
 
 
2495
 
 
2496
def topology_sorted_ids(tree):
 
2497
    """Determine the topological order of the ids in a tree"""
 
2498
    file_ids = list(tree)
 
2499
    file_ids.sort(key=tree.id2path)
 
2500
    return file_ids
 
2501
 
 
2502
 
639
2503
def build_tree(tree, wt, accelerator_tree=None, hardlink=False,
640
2504
               delta_from_tree=False):
641
2505
    """Create working tree for a branch, using a TreeTransform.
662
2526
    :param delta_from_tree: If true, build_tree may use the input Tree to
663
2527
        generate the inventory delta.
664
2528
    """
665
 
    with contextlib.ExitStack() as exit_stack:
666
 
        exit_stack.enter_context(wt.lock_tree_write())
667
 
        exit_stack.enter_context(tree.lock_read())
668
 
        if accelerator_tree is not None:
669
 
            exit_stack.enter_context(accelerator_tree.lock_read())
670
 
        return _build_tree(tree, wt, accelerator_tree, hardlink,
671
 
                           delta_from_tree)
 
2529
    wt.lock_tree_write()
 
2530
    try:
 
2531
        tree.lock_read()
 
2532
        try:
 
2533
            if accelerator_tree is not None:
 
2534
                accelerator_tree.lock_read()
 
2535
            try:
 
2536
                return _build_tree(tree, wt, accelerator_tree, hardlink,
 
2537
                                   delta_from_tree)
 
2538
            finally:
 
2539
                if accelerator_tree is not None:
 
2540
                    accelerator_tree.unlock()
 
2541
        finally:
 
2542
            tree.unlock()
 
2543
    finally:
 
2544
        wt.unlock()
672
2545
 
673
2546
 
674
2547
def _build_tree(tree, wt, accelerator_tree, hardlink, delta_from_tree):
675
2548
    """See build_tree."""
676
 
    for num, _unused in enumerate(wt.all_versioned_paths()):
 
2549
    for num, _unused in enumerate(wt.all_file_ids()):
677
2550
        if num > 0:  # more than just a root
678
2551
            raise errors.WorkingTreeAlreadyPopulated(base=wt.basedir)
679
2552
    file_trans_id = {}
680
2553
    top_pb = ui.ui_factory.nested_progress_bar()
681
2554
    pp = ProgressPhase("Build phase", 2, top_pb)
682
 
    if tree.path2id('') is not None:
 
2555
    if tree.get_root_id() is not None:
683
2556
        # This is kind of a hack: we should be altering the root
684
2557
        # as part of the regular tree shape diff logic.
685
2558
        # The conditional test here is to avoid doing an
687
2560
        # is set within the tree, nor setting the root and thus
688
2561
        # marking the tree as dirty, because we use two different
689
2562
        # idioms here: tree interfaces and inventory interfaces.
690
 
        if wt.path2id('') != tree.path2id(''):
691
 
            wt.set_root_id(tree.path2id(''))
 
2563
        if wt.get_root_id() != tree.get_root_id():
 
2564
            wt.set_root_id(tree.get_root_id())
692
2565
            wt.flush()
693
 
    tt = wt.transform()
 
2566
    tt = TreeTransform(wt)
694
2567
    divert = set()
695
2568
    try:
696
2569
        pp.next_phase()
697
 
        file_trans_id[find_previous_path(wt, tree, '')] = tt.trans_id_tree_path('')
698
 
        with ui.ui_factory.nested_progress_bar() as pb:
 
2570
        file_trans_id[wt.get_root_id()] = \
 
2571
            tt.trans_id_tree_file_id(wt.get_root_id())
 
2572
        pb = ui.ui_factory.nested_progress_bar()
 
2573
        try:
699
2574
            deferred_contents = []
700
2575
            num = 0
701
 
            total = len(tree.all_versioned_paths())
 
2576
            total = len(tree.all_file_ids())
702
2577
            if delta_from_tree:
703
2578
                precomputed_delta = []
704
2579
            else:
713
2588
                for dir, files in wt.walkdirs():
714
2589
                    existing_files.update(f[0] for f in files)
715
2590
            for num, (tree_path, entry) in \
716
 
                    enumerate(tree.iter_entries_by_dir()):
717
 
                pb.update(gettext("Building tree"), num
718
 
                          - len(deferred_contents), total)
 
2591
                enumerate(tree.iter_entries_by_dir()):
 
2592
                pb.update(gettext("Building tree"), num - len(deferred_contents), total)
719
2593
                if entry.parent_id is None:
720
2594
                    continue
721
2595
                reparent = False
731
2605
                        except errors.NotBranchError:
732
2606
                            pass
733
2607
                        else:
734
 
                            divert.add(tree_path)
735
 
                    if (tree_path not in divert
736
 
                        and _content_match(
737
 
                            tree, entry, tree_path, kind, target_path)):
 
2608
                            divert.add(file_id)
 
2609
                    if (file_id not in divert and
 
2610
                        _content_match(tree, entry, file_id, kind,
 
2611
                        target_path)):
738
2612
                        tt.delete_contents(tt.trans_id_tree_path(tree_path))
739
2613
                        if kind == 'directory':
740
2614
                            reparent = True
741
 
                parent_id = file_trans_id[osutils.dirname(tree_path)]
 
2615
                parent_id = file_trans_id[entry.parent_id]
742
2616
                if entry.kind == 'file':
743
2617
                    # We *almost* replicate new_by_entry, so that we can defer
744
2618
                    # getting the file text, and get them all at once.
745
2619
                    trans_id = tt.create_path(entry.name, parent_id)
746
 
                    file_trans_id[tree_path] = trans_id
747
 
                    tt.version_file(trans_id, file_id=file_id)
748
 
                    executable = tree.is_executable(tree_path)
 
2620
                    file_trans_id[file_id] = trans_id
 
2621
                    tt.version_file(file_id, trans_id)
 
2622
                    executable = tree.is_executable(file_id, tree_path)
749
2623
                    if executable:
750
2624
                        tt.set_executability(executable, trans_id)
751
2625
                    trans_data = (trans_id, tree_path, entry.text_sha1)
752
 
                    deferred_contents.append((tree_path, trans_data))
 
2626
                    deferred_contents.append((file_id, trans_data))
753
2627
                else:
754
 
                    file_trans_id[tree_path] = new_by_entry(
755
 
                        tree_path, tt, entry, parent_id, tree)
 
2628
                    file_trans_id[file_id] = new_by_entry(tt, entry, parent_id,
 
2629
                                                          tree)
756
2630
                if reparent:
757
 
                    new_trans_id = file_trans_id[tree_path]
 
2631
                    new_trans_id = file_trans_id[file_id]
758
2632
                    old_parent = tt.trans_id_tree_path(tree_path)
759
2633
                    _reparent_children(tt, old_parent, new_trans_id)
760
2634
            offset = num + 1 - len(deferred_contents)
761
2635
            _create_files(tt, tree, deferred_contents, pb, offset,
762
2636
                          accelerator_tree, hardlink)
 
2637
        finally:
 
2638
            pb.finished()
763
2639
        pp.next_phase()
764
2640
        divert_trans = set(file_trans_id[f] for f in divert)
765
 
 
766
 
        def resolver(t, c):
767
 
            return resolve_checkout(t, c, divert_trans)
 
2641
        resolver = lambda t, c: resolve_checkout(t, c, divert_trans)
768
2642
        raw_conflicts = resolve_conflicts(tt, pass_func=resolver)
769
2643
        if len(raw_conflicts) > 0:
770
2644
            precomputed_delta = None
771
2645
        conflicts = cook_conflicts(raw_conflicts, tt)
772
2646
        for conflict in conflicts:
773
 
            trace.warning(str(conflict))
 
2647
            trace.warning(unicode(conflict))
774
2648
        try:
775
2649
            wt.add_conflicts(conflicts)
776
2650
        except errors.UnsupportedOperation:
791
2665
        new_desired_files = desired_files
792
2666
    else:
793
2667
        iter = accelerator_tree.iter_changes(tree, include_unchanged=True)
794
 
        unchanged = [
795
 
            change.path for change in iter
796
 
            if not (change.changed_content or change.executable[0] != change.executable[1])]
 
2668
        unchanged = [(f, p[1]) for (f, p, c, v, d, n, k, e)
 
2669
                     in iter if not (c or e[0] != e[1])]
797
2670
        if accelerator_tree.supports_content_filtering():
798
 
            unchanged = [(tp, ap) for (tp, ap) in unchanged
799
 
                         if not next(accelerator_tree.iter_search_rules([ap]))]
 
2671
            unchanged = [(f, p) for (f, p) in unchanged
 
2672
                         if not next(accelerator_tree.iter_search_rules([p]))]
800
2673
        unchanged = dict(unchanged)
801
2674
        new_desired_files = []
802
2675
        count = 0
803
 
        for unused_tree_path, (trans_id, tree_path, text_sha1) in desired_files:
804
 
            accelerator_path = unchanged.get(tree_path)
 
2676
        for file_id, (trans_id, tree_path, text_sha1) in desired_files:
 
2677
            accelerator_path = unchanged.get(file_id)
805
2678
            if accelerator_path is None:
806
 
                new_desired_files.append((tree_path,
807
 
                                          (trans_id, tree_path, text_sha1)))
 
2679
                new_desired_files.append((file_id,
 
2680
                    (trans_id, tree_path, text_sha1)))
808
2681
                continue
809
2682
            pb.update(gettext('Adding file contents'), count + offset, total)
810
2683
            if hardlink:
811
2684
                tt.create_hardlink(accelerator_tree.abspath(accelerator_path),
812
2685
                                   trans_id)
813
2686
            else:
814
 
                with accelerator_tree.get_file(accelerator_path) as f:
815
 
                    chunks = osutils.file_iterator(f)
816
 
                    if wt.supports_content_filtering():
817
 
                        filters = wt._content_filter_stack(tree_path)
818
 
                        chunks = filtered_output_bytes(chunks, filters,
819
 
                                                       ContentFilterContext(tree_path, tree))
820
 
                    tt.create_file(chunks, trans_id, sha1=text_sha1)
 
2687
                contents = accelerator_tree.get_file(file_id, accelerator_path)
 
2688
                if wt.supports_content_filtering():
 
2689
                    filters = wt._content_filter_stack(tree_path)
 
2690
                    contents = filtered_output_bytes(contents, filters,
 
2691
                        ContentFilterContext(tree_path, tree))
 
2692
                try:
 
2693
                    tt.create_file(contents, trans_id, sha1=text_sha1)
 
2694
                finally:
 
2695
                    try:
 
2696
                        contents.close()
 
2697
                    except AttributeError:
 
2698
                        # after filtering, contents may no longer be file-like
 
2699
                        pass
821
2700
            count += 1
822
2701
        offset += count
823
2702
    for count, ((trans_id, tree_path, text_sha1), contents) in enumerate(
825
2704
        if wt.supports_content_filtering():
826
2705
            filters = wt._content_filter_stack(tree_path)
827
2706
            contents = filtered_output_bytes(contents, filters,
828
 
                                             ContentFilterContext(tree_path, tree))
 
2707
                ContentFilterContext(tree_path, tree))
829
2708
        tt.create_file(contents, trans_id, sha1=text_sha1)
830
2709
        pb.update(gettext('Adding file contents'), count + offset, total)
831
2710
 
842
2721
    return by_parent[old_parent]
843
2722
 
844
2723
 
845
 
def _content_match(tree, entry, tree_path, kind, target_path):
 
2724
def _content_match(tree, entry, file_id, kind, target_path):
846
2725
    if entry.kind != kind:
847
2726
        return False
848
2727
    if entry.kind == "directory":
849
2728
        return True
850
2729
    if entry.kind == "file":
851
 
        with open(target_path, 'rb') as f1, \
852
 
                tree.get_file(tree_path) as f2:
853
 
            if osutils.compare_files(f1, f2):
 
2730
        f = file(target_path, 'rb')
 
2731
        try:
 
2732
            if tree.get_file_text(file_id) == f.read():
854
2733
                return True
 
2734
        finally:
 
2735
            f.close()
855
2736
    elif entry.kind == "symlink":
856
 
        if tree.get_symlink_target(tree_path) == os.readlink(target_path):
 
2737
        if tree.get_symlink_target(file_id) == os.readlink(target_path):
857
2738
            return True
858
2739
    return False
859
2740
 
876
2757
        # resolved
877
2758
        final_parent = tt.final_parent(old_file)
878
2759
        if new_file in divert:
879
 
            new_name = tt.final_name(old_file) + '.diverted'
 
2760
            new_name = tt.final_name(old_file)+'.diverted'
880
2761
            tt.adjust_path(new_name, final_parent, new_file)
881
2762
            new_conflicts.add((c_type, 'Diverted to',
882
2763
                               new_file, old_file))
883
2764
        else:
884
 
            new_name = tt.final_name(old_file) + '.moved'
 
2765
            new_name = tt.final_name(old_file)+'.moved'
885
2766
            tt.adjust_path(new_name, final_parent, old_file)
886
2767
            new_conflicts.add((c_type, 'Moved existing file to',
887
2768
                               old_file, new_file))
888
2769
    return new_conflicts
889
2770
 
890
2771
 
891
 
def new_by_entry(path, tt, entry, parent_id, tree):
 
2772
def new_by_entry(tt, entry, parent_id, tree):
892
2773
    """Create a new file according to its inventory entry"""
893
2774
    name = entry.name
894
2775
    kind = entry.kind
895
2776
    if kind == 'file':
896
 
        with tree.get_file(path) as f:
897
 
            executable = tree.is_executable(path)
898
 
            return tt.new_file(
899
 
                name, parent_id, osutils.file_iterator(f), entry.file_id,
900
 
                executable)
 
2777
        contents = tree.get_file(entry.file_id).readlines()
 
2778
        executable = tree.is_executable(entry.file_id)
 
2779
        return tt.new_file(name, parent_id, contents, entry.file_id,
 
2780
                           executable)
901
2781
    elif kind in ('directory', 'tree-reference'):
902
2782
        trans_id = tt.new_directory(name, parent_id, entry.file_id)
903
2783
        if kind == 'tree-reference':
904
2784
            tt.set_tree_reference(entry.reference_revision, trans_id)
905
2785
        return trans_id
906
2786
    elif kind == 'symlink':
907
 
        target = tree.get_symlink_target(path)
 
2787
        target = tree.get_symlink_target(entry.file_id)
908
2788
        return tt.new_symlink(name, parent_id, target, entry.file_id)
909
2789
    else:
910
2790
        raise errors.BadFileKindError(name, kind)
911
2791
 
912
2792
 
913
 
def create_from_tree(tt, trans_id, tree, path, chunks=None,
914
 
                     filter_tree_path=None):
 
2793
def create_from_tree(tt, trans_id, tree, file_id, bytes=None,
 
2794
    filter_tree_path=None):
915
2795
    """Create new file contents according to tree contents.
916
 
 
 
2796
    
917
2797
    :param filter_tree_path: the tree path to use to lookup
918
2798
      content filters to apply to the bytes output in the working tree.
919
2799
      This only applies if the working tree supports content filtering.
920
2800
    """
921
 
    kind = tree.kind(path)
 
2801
    kind = tree.kind(file_id)
922
2802
    if kind == 'directory':
923
2803
        tt.create_directory(trans_id)
924
2804
    elif kind == "file":
925
 
        if chunks is None:
926
 
            f = tree.get_file(path)
927
 
            chunks = osutils.file_iterator(f)
928
 
        else:
929
 
            f = None
930
 
        try:
931
 
            wt = tt._tree
932
 
            if wt.supports_content_filtering() and filter_tree_path is not None:
933
 
                filters = wt._content_filter_stack(filter_tree_path)
934
 
                chunks = filtered_output_bytes(
935
 
                    chunks, filters,
936
 
                    ContentFilterContext(filter_tree_path, tree))
937
 
            tt.create_file(chunks, trans_id)
938
 
        finally:
939
 
            if f is not None:
940
 
                f.close()
 
2805
        if bytes is None:
 
2806
            tree_file = tree.get_file(file_id)
 
2807
            try:
 
2808
                bytes = tree_file.readlines()
 
2809
            finally:
 
2810
                tree_file.close()
 
2811
        wt = tt._tree
 
2812
        if wt.supports_content_filtering() and filter_tree_path is not None:
 
2813
            filters = wt._content_filter_stack(filter_tree_path)
 
2814
            bytes = filtered_output_bytes(bytes, filters,
 
2815
                ContentFilterContext(filter_tree_path, tree))
 
2816
        tt.create_file(bytes, trans_id)
941
2817
    elif kind == "symlink":
942
 
        tt.create_symlink(tree.get_symlink_target(path), trans_id)
 
2818
        tt.create_symlink(tree.get_symlink_target(file_id), trans_id)
943
2819
    else:
944
2820
        raise AssertionError('Unknown kind %r' % kind)
945
2821
 
953
2829
def revert(working_tree, target_tree, filenames, backups=False,
954
2830
           pb=None, change_reporter=None):
955
2831
    """Revert a working tree's contents to those of a target tree."""
 
2832
    target_tree.lock_read()
956
2833
    pb = ui.ui_factory.nested_progress_bar()
 
2834
    tt = TreeTransform(working_tree, pb)
957
2835
    try:
958
 
        with target_tree.lock_read(), working_tree.transform(pb) as tt:
959
 
            pp = ProgressPhase("Revert phase", 3, pb)
960
 
            conflicts, merge_modified = _prepare_revert_transform(
961
 
                working_tree, target_tree, tt, filenames, backups, pp)
962
 
            if change_reporter:
963
 
                from . import delta
964
 
                change_reporter = delta._ChangeReporter(
965
 
                    unversioned_filter=working_tree.is_ignored)
966
 
                delta.report_changes(tt.iter_changes(), change_reporter)
967
 
            for conflict in conflicts:
968
 
                trace.warning(str(conflict))
969
 
            pp.next_phase()
970
 
            tt.apply()
971
 
            if working_tree.supports_merge_modified():
972
 
                working_tree.set_merge_modified(merge_modified)
 
2836
        pp = ProgressPhase("Revert phase", 3, pb)
 
2837
        conflicts, merge_modified = _prepare_revert_transform(
 
2838
            working_tree, target_tree, tt, filenames, backups, pp)
 
2839
        if change_reporter:
 
2840
            change_reporter = delta._ChangeReporter(
 
2841
                unversioned_filter=working_tree.is_ignored)
 
2842
            delta.report_changes(tt.iter_changes(), change_reporter)
 
2843
        for conflict in conflicts:
 
2844
            trace.warning(unicode(conflict))
 
2845
        pp.next_phase()
 
2846
        tt.apply()
 
2847
        working_tree.set_merge_modified(merge_modified)
973
2848
    finally:
 
2849
        target_tree.unlock()
 
2850
        tt.finalize()
974
2851
        pb.clear()
975
2852
    return conflicts
976
2853
 
978
2855
def _prepare_revert_transform(working_tree, target_tree, tt, filenames,
979
2856
                              backups, pp, basis_tree=None,
980
2857
                              merge_modified=None):
981
 
    with ui.ui_factory.nested_progress_bar() as child_pb:
 
2858
    child_pb = ui.ui_factory.nested_progress_bar()
 
2859
    try:
982
2860
        if merge_modified is None:
983
2861
            merge_modified = working_tree.merge_modified()
984
2862
        merge_modified = _alter_files(working_tree, target_tree, tt,
985
2863
                                      child_pb, filenames, backups,
986
2864
                                      merge_modified, basis_tree)
987
 
    with ui.ui_factory.nested_progress_bar() as child_pb:
988
 
        raw_conflicts = resolve_conflicts(
989
 
            tt, child_pb, lambda t, c: conflict_pass(t, c, target_tree))
 
2865
    finally:
 
2866
        child_pb.finished()
 
2867
    child_pb = ui.ui_factory.nested_progress_bar()
 
2868
    try:
 
2869
        raw_conflicts = resolve_conflicts(tt, child_pb,
 
2870
            lambda t, c: conflict_pass(t, c, target_tree))
 
2871
    finally:
 
2872
        child_pb.finished()
990
2873
    conflicts = cook_conflicts(raw_conflicts, tt)
991
2874
    return conflicts, merge_modified
992
2875
 
999
2882
    # than the target changes relative to the working tree. Because WT4 has an
1000
2883
    # optimizer to compare itself to a target, but no optimizer for the
1001
2884
    # reverse.
1002
 
    change_list = working_tree.iter_changes(
1003
 
        target_tree, specific_files=specific_files, pb=pb)
1004
 
    if not target_tree.is_versioned(u''):
 
2885
    change_list = working_tree.iter_changes(target_tree,
 
2886
        specific_files=specific_files, pb=pb)
 
2887
    if target_tree.get_root_id() is None:
1005
2888
        skip_root = True
1006
2889
    else:
1007
2890
        skip_root = False
1008
2891
    try:
1009
2892
        deferred_files = []
1010
 
        for id_num, change in enumerate(change_list):
1011
 
            file_id = change.file_id
1012
 
            target_path, wt_path = change.path
1013
 
            target_versioned, wt_versioned = change.versioned
1014
 
            target_parent, wt_parent = change.parent_id
1015
 
            target_name, wt_name = change.name
1016
 
            target_kind, wt_kind = change.kind
1017
 
            target_executable, wt_executable = change.executable
 
2893
        for id_num, (file_id, path, changed_content, versioned, parent, name,
 
2894
                kind, executable) in enumerate(change_list):
 
2895
            target_path, wt_path = path
 
2896
            target_versioned, wt_versioned = versioned
 
2897
            target_parent, wt_parent = parent
 
2898
            target_name, wt_name = name
 
2899
            target_kind, wt_kind = kind
 
2900
            target_executable, wt_executable = executable
1018
2901
            if skip_root and wt_parent is None:
1019
2902
                continue
1020
2903
            trans_id = tt.trans_id_file_id(file_id)
1021
2904
            mode_id = None
1022
 
            if change.changed_content:
 
2905
            if changed_content:
1023
2906
                keep_content = False
1024
2907
                if wt_kind == 'file' and (backups or target_kind is None):
1025
 
                    wt_sha1 = working_tree.get_file_sha1(wt_path)
1026
 
                    if merge_modified.get(wt_path) != wt_sha1:
 
2908
                    wt_sha1 = working_tree.get_file_sha1(file_id)
 
2909
                    if merge_modified.get(file_id) != wt_sha1:
1027
2910
                        # acquire the basis tree lazily to prevent the
1028
2911
                        # expense of accessing it when it's not needed ?
1029
2912
                        # (Guessing, RBC, 200702)
1030
2913
                        if basis_tree is None:
1031
2914
                            basis_tree = working_tree.basis_tree()
1032
2915
                            basis_tree.lock_read()
1033
 
                        basis_inter = InterTree.get(basis_tree, working_tree)
1034
 
                        basis_path = basis_inter.find_source_path(wt_path)
1035
 
                        if basis_path is None:
1036
 
                            if target_kind is None and not target_versioned:
1037
 
                                keep_content = True
1038
 
                        else:
1039
 
                            if wt_sha1 != basis_tree.get_file_sha1(basis_path):
1040
 
                                keep_content = True
 
2916
                        if basis_tree.has_id(file_id):
 
2917
                            if wt_sha1 != basis_tree.get_file_sha1(file_id):
 
2918
                                keep_content = True
 
2919
                        elif target_kind is None and not target_versioned:
 
2920
                            keep_content = True
1041
2921
                if wt_kind is not None:
1042
2922
                    if not keep_content:
1043
2923
                        tt.delete_contents(trans_id)
1049
2929
                        new_trans_id = tt.create_path(wt_name, parent_trans_id)
1050
2930
                        if wt_versioned and target_versioned:
1051
2931
                            tt.unversion_file(trans_id)
1052
 
                            tt.version_file(new_trans_id, file_id=file_id)
 
2932
                            tt.version_file(file_id, new_trans_id)
1053
2933
                        # New contents should have the same unix perms as old
1054
2934
                        # contents
1055
2935
                        mode_id = trans_id
1057
2937
                if target_kind in ('directory', 'tree-reference'):
1058
2938
                    tt.create_directory(trans_id)
1059
2939
                    if target_kind == 'tree-reference':
1060
 
                        revision = target_tree.get_reference_revision(
1061
 
                            target_path)
 
2940
                        revision = target_tree.get_reference_revision(file_id,
 
2941
                                                                      target_path)
1062
2942
                        tt.set_tree_reference(revision, trans_id)
1063
2943
                elif target_kind == 'symlink':
1064
 
                    tt.create_symlink(target_tree.get_symlink_target(
1065
 
                        target_path), trans_id)
 
2944
                    tt.create_symlink(target_tree.get_symlink_target(file_id),
 
2945
                                      trans_id)
1066
2946
                elif target_kind == 'file':
1067
 
                    deferred_files.append(
1068
 
                        (target_path, (trans_id, mode_id, file_id)))
 
2947
                    deferred_files.append((file_id, (trans_id, mode_id)))
1069
2948
                    if basis_tree is None:
1070
2949
                        basis_tree = working_tree.basis_tree()
1071
2950
                        basis_tree.lock_read()
1072
 
                    new_sha1 = target_tree.get_file_sha1(target_path)
1073
 
                    basis_inter = InterTree.get(basis_tree, target_tree)
1074
 
                    basis_path = basis_inter.find_source_path(target_path)
1075
 
                    if (basis_path is not None and
1076
 
                            new_sha1 == basis_tree.get_file_sha1(basis_path)):
1077
 
                        # If the new contents of the file match what is in basis,
1078
 
                        # then there is no need to store in merge_modified.
1079
 
                        if basis_path in merge_modified:
1080
 
                            del merge_modified[basis_path]
 
2951
                    new_sha1 = target_tree.get_file_sha1(file_id)
 
2952
                    if (basis_tree.has_id(file_id) and
 
2953
                        new_sha1 == basis_tree.get_file_sha1(file_id)):
 
2954
                        if file_id in merge_modified:
 
2955
                            del merge_modified[file_id]
1081
2956
                    else:
1082
 
                        merge_modified[target_path] = new_sha1
 
2957
                        merge_modified[file_id] = new_sha1
1083
2958
 
1084
2959
                    # preserve the execute bit when backing up
1085
2960
                    if keep_content and wt_executable == target_executable:
1087
2962
                elif target_kind is not None:
1088
2963
                    raise AssertionError(target_kind)
1089
2964
            if not wt_versioned and target_versioned:
1090
 
                tt.version_file(trans_id, file_id=file_id)
 
2965
                tt.version_file(file_id, trans_id)
1091
2966
            if wt_versioned and not target_versioned:
1092
2967
                tt.unversion_file(trans_id)
1093
 
            if (target_name is not None
1094
 
                    and (wt_name != target_name or wt_parent != target_parent)):
 
2968
            if (target_name is not None and
 
2969
                (wt_name != target_name or wt_parent != target_parent)):
1095
2970
                if target_name == '' and target_parent is None:
1096
2971
                    parent_trans = ROOT_PARENT
1097
2972
                else:
1103
2978
            if wt_executable != target_executable and target_kind == "file":
1104
2979
                tt.set_executability(target_executable, trans_id)
1105
2980
        if working_tree.supports_content_filtering():
1106
 
            for (trans_id, mode_id, file_id), bytes in (
1107
 
                    target_tree.iter_files_bytes(deferred_files)):
 
2981
            for index, ((trans_id, mode_id), bytes) in enumerate(
 
2982
                target_tree.iter_files_bytes(deferred_files)):
 
2983
                file_id = deferred_files[index][0]
1108
2984
                # We're reverting a tree to the target tree so using the
1109
2985
                # target tree to find the file path seems the best choice
1110
2986
                # here IMO - Ian C 27/Oct/2009
1111
2987
                filter_tree_path = target_tree.id2path(file_id)
1112
2988
                filters = working_tree._content_filter_stack(filter_tree_path)
1113
 
                bytes = filtered_output_bytes(
1114
 
                    bytes, filters,
 
2989
                bytes = filtered_output_bytes(bytes, filters,
1115
2990
                    ContentFilterContext(filter_tree_path, working_tree))
1116
2991
                tt.create_file(bytes, trans_id, mode_id)
1117
2992
        else:
1118
 
            for (trans_id, mode_id, file_id), bytes in target_tree.iter_files_bytes(
1119
 
                    deferred_files):
 
2993
            for (trans_id, mode_id), bytes in target_tree.iter_files_bytes(
 
2994
                deferred_files):
1120
2995
                tt.create_file(bytes, trans_id, mode_id)
1121
2996
        tt.fixup_new_roots()
1122
2997
    finally:
1130
3005
    if pass_func is None:
1131
3006
        pass_func = conflict_pass
1132
3007
    new_conflicts = set()
1133
 
    with ui.ui_factory.nested_progress_bar() as pb:
 
3008
    pb = ui.ui_factory.nested_progress_bar()
 
3009
    try:
1134
3010
        for n in range(10):
1135
 
            pb.update(gettext('Resolution pass'), n + 1, 10)
 
3011
            pb.update(gettext('Resolution pass'), n+1, 10)
1136
3012
            conflicts = tt.find_conflicts()
1137
3013
            if len(conflicts) == 0:
1138
3014
                return new_conflicts
1139
3015
            new_conflicts.update(pass_func(tt, conflicts))
1140
3016
        raise MalformedTransform(conflicts=conflicts)
 
3017
    finally:
 
3018
        pb.finished()
1141
3019
 
1142
3020
 
1143
3021
def conflict_pass(tt, conflicts, path_tree=None):
1208
3086
                        if file_id is None:
1209
3087
                            file_id = tt.inactive_file_id(trans_id)
1210
3088
                        _, entry = next(path_tree.iter_entries_by_dir(
1211
 
                            specific_files=[path_tree.id2path(file_id)]))
 
3089
                            [file_id]))
1212
3090
                        # special-case the other tree root (move its
1213
3091
                        # children to current root)
1214
3092
                        if entry.parent_id is None:
1229
3107
        elif c_type == 'unversioned parent':
1230
3108
            file_id = tt.inactive_file_id(conflict[1])
1231
3109
            # special-case the other tree root (move its children instead)
1232
 
            if path_tree and path_tree.path2id('') == file_id:
1233
 
                # This is the root entry, skip it
1234
 
                continue
1235
 
            tt.version_file(conflict[1], file_id=file_id)
 
3110
            if path_tree and path_tree.has_id(file_id):
 
3111
                if path_tree.path2id('') == file_id:
 
3112
                    # This is the root entry, skip it
 
3113
                    continue
 
3114
            tt.version_file(file_id, conflict[1])
1236
3115
            new_conflicts.add((c_type, 'Versioned directory', conflict[1]))
1237
3116
        elif c_type == 'non-directory parent':
1238
3117
            parent_id = conflict[1]
1240
3119
            parent_name = tt.final_name(parent_id)
1241
3120
            parent_file_id = tt.final_file_id(parent_id)
1242
3121
            new_parent_id = tt.new_directory(parent_name + '.new',
1243
 
                                             parent_parent, parent_file_id)
 
3122
                parent_parent, parent_file_id)
1244
3123
            _reparent_transform_children(tt, parent_id, new_parent_id)
1245
3124
            if parent_file_id is not None:
1246
3125
                tt.unversion_file(parent_id)
1293
3172
                raise errors.FileExists(to, str(e))
1294
3173
            # normal OSError doesn't include filenames so it's hard to see where
1295
3174
            # the problem is, see https://bugs.launchpad.net/bzr/+bug/491763
1296
 
            raise TransformRenameFailed(from_, to, str(e), e.errno)
 
3175
            raise errors.TransformRenameFailed(from_, to, str(e), e.errno)
1297
3176
        self.past_renames.append((from_, to))
1298
3177
 
1299
3178
    def pre_delete(self, from_, to):
1312
3191
            try:
1313
3192
                os.rename(to, from_)
1314
3193
            except OSError as e:
1315
 
                raise TransformRenameFailed(to, from_, str(e), e.errno)
 
3194
                raise errors.TransformRenameFailed(to, from_, str(e), e.errno)
1316
3195
        # after rollback, don't reuse _FileMover
1317
 
        self.past_renames = None
1318
 
        self.pending_deletions = None
 
3196
        past_renames = None
 
3197
        pending_deletions = None
1319
3198
 
1320
3199
    def apply_deletions(self):
1321
3200
        """Apply all marked deletions"""
1322
3201
        for path in self.pending_deletions:
1323
3202
            delete_any(path)
1324
3203
        # after apply_deletions, don't reuse _FileMover
1325
 
        self.past_renames = None
1326
 
        self.pending_deletions = None
1327
 
 
1328
 
 
1329
 
def link_tree(target_tree, source_tree):
1330
 
    """Where possible, hard-link files in a tree to those in another tree.
1331
 
 
1332
 
    :param target_tree: Tree to change
1333
 
    :param source_tree: Tree to hard-link from
1334
 
    """
1335
 
    with target_tree.transform() as tt:
1336
 
        for change in target_tree.iter_changes(source_tree, include_unchanged=True):
1337
 
            if change.changed_content:
1338
 
                continue
1339
 
            if change.kind != ('file', 'file'):
1340
 
                continue
1341
 
            if change.executable[0] != change.executable[1]:
1342
 
                continue
1343
 
            trans_id = tt.trans_id_tree_path(change.path[1])
1344
 
            tt.delete_contents(trans_id)
1345
 
            tt.create_hardlink(source_tree.abspath(change.path[0]), trans_id)
1346
 
        tt.apply()
1347
 
 
1348
 
 
1349
 
class PreviewTree(object):
1350
 
    """Preview tree."""
1351
 
 
1352
 
    def __init__(self, transform):
1353
 
        self._transform = transform
1354
 
        self._parent_ids = []
1355
 
        self.__by_parent = None
1356
 
        self._path2trans_id_cache = {}
1357
 
        self._all_children_cache = {}
1358
 
        self._final_name_cache = {}
1359
 
 
1360
 
    @property
1361
 
    def _by_parent(self):
1362
 
        if self.__by_parent is None:
1363
 
            self.__by_parent = self._transform.by_parent()
1364
 
        return self.__by_parent
1365
 
 
1366
 
    def get_parent_ids(self):
1367
 
        return self._parent_ids
1368
 
 
1369
 
    def set_parent_ids(self, parent_ids):
1370
 
        self._parent_ids = parent_ids
1371
 
 
1372
 
    def get_revision_tree(self, revision_id):
1373
 
        return self._transform._tree.get_revision_tree(revision_id)
1374
 
 
1375
 
    def is_locked(self):
1376
 
        return False
1377
 
 
1378
 
    def lock_read(self):
1379
 
        # Perhaps in theory, this should lock the TreeTransform?
1380
 
        return lock.LogicalLockResult(self.unlock)
1381
 
 
1382
 
    def unlock(self):
1383
 
        pass
1384
 
 
1385
 
    def _path2trans_id(self, path):
1386
 
        # We must not use None here, because that is a valid value to store.
1387
 
        trans_id = self._path2trans_id_cache.get(path, object)
1388
 
        if trans_id is not object:
1389
 
            return trans_id
1390
 
        segments = osutils.splitpath(path)
1391
 
        cur_parent = self._transform.root
1392
 
        for cur_segment in segments:
1393
 
            for child in self._all_children(cur_parent):
1394
 
                final_name = self._final_name_cache.get(child)
1395
 
                if final_name is None:
1396
 
                    final_name = self._transform.final_name(child)
1397
 
                    self._final_name_cache[child] = final_name
1398
 
                if final_name == cur_segment:
1399
 
                    cur_parent = child
1400
 
                    break
1401
 
            else:
1402
 
                self._path2trans_id_cache[path] = None
1403
 
                return None
1404
 
        self._path2trans_id_cache[path] = cur_parent
1405
 
        return cur_parent
1406
 
 
1407
 
    def _all_children(self, trans_id):
1408
 
        children = self._all_children_cache.get(trans_id)
1409
 
        if children is not None:
1410
 
            return children
1411
 
        children = set(self._transform.iter_tree_children(trans_id))
1412
 
        # children in the _new_parent set are provided by _by_parent.
1413
 
        children.difference_update(self._transform._new_parent)
1414
 
        children.update(self._by_parent.get(trans_id, []))
1415
 
        self._all_children_cache[trans_id] = children
1416
 
        return children
1417
 
 
1418
 
    def get_file_with_stat(self, path):
1419
 
        return self.get_file(path), None
1420
 
 
1421
 
    def is_executable(self, path):
1422
 
        trans_id = self._path2trans_id(path)
1423
 
        if trans_id is None:
1424
 
            return False
1425
 
        try:
1426
 
            return self._transform._new_executability[trans_id]
1427
 
        except KeyError:
1428
 
            try:
1429
 
                return self._transform._tree.is_executable(path)
1430
 
            except OSError as e:
1431
 
                if e.errno == errno.ENOENT:
1432
 
                    return False
1433
 
                raise
1434
 
            except errors.NoSuchFile:
1435
 
                return False
1436
 
 
1437
 
    def has_filename(self, path):
1438
 
        trans_id = self._path2trans_id(path)
1439
 
        if trans_id in self._transform._new_contents:
1440
 
            return True
1441
 
        elif trans_id in self._transform._removed_contents:
1442
 
            return False
1443
 
        else:
1444
 
            return self._transform._tree.has_filename(path)
1445
 
 
1446
 
    def get_file_sha1(self, path, stat_value=None):
1447
 
        trans_id = self._path2trans_id(path)
1448
 
        if trans_id is None:
1449
 
            raise errors.NoSuchFile(path)
1450
 
        kind = self._transform._new_contents.get(trans_id)
1451
 
        if kind is None:
1452
 
            return self._transform._tree.get_file_sha1(path)
1453
 
        if kind == 'file':
1454
 
            with self.get_file(path) as fileobj:
1455
 
                return osutils.sha_file(fileobj)
1456
 
 
1457
 
    def get_file_verifier(self, path, stat_value=None):
1458
 
        trans_id = self._path2trans_id(path)
1459
 
        if trans_id is None:
1460
 
            raise errors.NoSuchFile(path)
1461
 
        kind = self._transform._new_contents.get(trans_id)
1462
 
        if kind is None:
1463
 
            return self._transform._tree.get_file_verifier(path)
1464
 
        if kind == 'file':
1465
 
            with self.get_file(path) as fileobj:
1466
 
                return ("SHA1", osutils.sha_file(fileobj))
1467
 
 
1468
 
    def kind(self, path):
1469
 
        trans_id = self._path2trans_id(path)
1470
 
        if trans_id is None:
1471
 
            raise errors.NoSuchFile(path)
1472
 
        return self._transform.final_kind(trans_id)
1473
 
 
1474
 
    def stored_kind(self, path):
1475
 
        trans_id = self._path2trans_id(path)
1476
 
        if trans_id is None:
1477
 
            raise errors.NoSuchFile(path)
1478
 
        try:
1479
 
            return self._transform._new_contents[trans_id]
1480
 
        except KeyError:
1481
 
            return self._transform._tree.stored_kind(path)
1482
 
 
1483
 
    def _get_repository(self):
1484
 
        repo = getattr(self._transform._tree, '_repository', None)
1485
 
        if repo is None:
1486
 
            repo = self._transform._tree.branch.repository
1487
 
        return repo
1488
 
 
1489
 
    def _iter_parent_trees(self):
1490
 
        for revision_id in self.get_parent_ids():
1491
 
            try:
1492
 
                yield self.revision_tree(revision_id)
1493
 
            except errors.NoSuchRevisionInTree:
1494
 
                yield self._get_repository().revision_tree(revision_id)
1495
 
 
1496
 
    def get_file_size(self, path):
1497
 
        """See Tree.get_file_size"""
1498
 
        trans_id = self._path2trans_id(path)
1499
 
        if trans_id is None:
1500
 
            raise errors.NoSuchFile(path)
1501
 
        kind = self._transform.final_kind(trans_id)
1502
 
        if kind != 'file':
1503
 
            return None
1504
 
        if trans_id in self._transform._new_contents:
1505
 
            return self._stat_limbo_file(trans_id).st_size
1506
 
        if self.kind(path) == 'file':
1507
 
            return self._transform._tree.get_file_size(path)
1508
 
        else:
1509
 
            return None
1510
 
 
1511
 
    def get_reference_revision(self, path):
1512
 
        trans_id = self._path2trans_id(path)
1513
 
        if trans_id is None:
1514
 
            raise errors.NoSuchFile(path)
1515
 
        reference_revision = self._transform._new_reference_revision.get(trans_id)
1516
 
        if reference_revision is None:
1517
 
            return self._transform._tree.get_reference_revision(path)
1518
 
        return reference_revision
1519
 
 
1520
 
    def tree_kind(self, trans_id):
1521
 
        path = self._tree_id_paths.get(trans_id)
1522
 
        if path is None:
1523
 
            return None
1524
 
        kind = self._tree.path_content_summary(path)[0]
1525
 
        if kind == 'missing':
1526
 
            kind = None
1527
 
        return kind
 
3204
        past_renames = None
 
3205
        pending_deletions = None