/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: 2020-05-24 00:42:36 UTC
  • mto: This revision was merged to the branch mainline in revision 7505.
  • Revision ID: jelmer@jelmer.uk-20200524004236-jdj6obo4k5lznqw2
Cleanup Windows functions.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/transform.py
22
22
 
23
23
from . import (
24
24
    config as _mod_config,
25
 
    controldir,
26
25
    errors,
27
26
    lazy_import,
28
 
    lock,
29
 
    osutils,
30
27
    registry,
31
28
    trace,
 
29
    tree,
32
30
    )
33
31
lazy_import.lazy_import(globals(), """
34
32
from breezy import (
 
33
    annotate,
 
34
    bencode,
 
35
    controldir,
 
36
    commit,
35
37
    conflicts,
 
38
    delta,
 
39
    lock,
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
    inventorytree,
 
49
    )
41
50
from breezy.i18n import gettext
42
51
""")
43
 
 
44
 
from .errors import (DuplicateKey,
45
 
                     BzrError, InternalBzrError)
 
52
from .errors import (DuplicateKey, MalformedTransform,
 
53
                     ReusingTransform, CantMoveRoot,
 
54
                     ImmortalLimbo, NoFinalPath)
46
55
from .filters import filtered_output_bytes, ContentFilterContext
47
56
from .mutabletree import MutableTree
48
57
from .osutils import (
57
66
from .tree import (
58
67
    InterTree,
59
68
    TreeChange,
60
 
    find_previous_path,
61
69
    )
62
70
 
63
71
 
64
72
ROOT_PARENT = "root-parent"
65
73
 
66
74
 
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
75
def unique_add(map, key, value):
117
76
    if key in map:
118
77
        raise DuplicateKey(key=key)
120
79
 
121
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, case_sensitive=True):
 
92
        """Constructor.
 
93
 
 
94
        :param tree: The tree that will be transformed, but not necessarily
 
95
            the output tree.
 
96
        :param pb: ignored
 
97
        :param case_sensitive: If True, the target of the transform is
 
98
            case sensitive, not just case preserving.
 
99
        """
 
100
        object.__init__(self)
168
101
        self._tree = tree
169
 
        # A progress bar
170
 
        self._pb = pb
171
102
        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
103
        # mapping of trans_id -> new basename
177
104
        self._new_name = {}
178
105
        # mapping of trans_id -> new parent trans_id
179
106
        self._new_parent = {}
180
107
        # mapping of trans_id with new contents -> new file_kind
181
108
        self._new_contents = {}
 
109
        # mapping of trans_id => (sha1 of content, stat_value)
 
110
        self._observed_sha1s = {}
182
111
        # Set of trans_ids whose contents will be removed
183
112
        self._removed_contents = set()
184
113
        # Mapping of trans_id -> new execute-bit value
185
114
        self._new_executability = {}
186
115
        # Mapping of trans_id -> new tree-reference value
187
116
        self._new_reference_revision = {}
 
117
        # Mapping of trans_id -> new file_id
 
118
        self._new_id = {}
 
119
        # Mapping of old file-id -> trans_id
 
120
        self._non_present_ids = {}
 
121
        # Mapping of new file_id -> trans_id
 
122
        self._r_new_id = {}
188
123
        # Set of trans_ids that will be removed
189
124
        self._removed_id = set()
 
125
        # Mapping of path in old tree -> trans_id
 
126
        self._tree_path_ids = {}
 
127
        # Mapping trans_id -> path in old tree
 
128
        self._tree_id_paths = {}
 
129
        # The trans_id that will be used as the tree root
 
130
        if tree.is_versioned(''):
 
131
            self._new_root = self.trans_id_tree_path('')
 
132
        else:
 
133
            self._new_root = None
190
134
        # Indicator of whether the transform has been applied
191
135
        self._done = False
 
136
        # A progress bar
 
137
        self._pb = pb
 
138
        # Whether the target is case sensitive
 
139
        self._case_sensitive_target = case_sensitive
 
140
        # A counter of how many files have been renamed
 
141
        self.rename_count = 0
192
142
 
193
143
    def __enter__(self):
194
144
        """Support Context Manager API."""
198
148
        """Support Context Manager API."""
199
149
        self.finalize()
200
150
 
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
151
    def finalize(self):
231
152
        """Release the working tree lock, if held.
232
153
 
233
154
        This is required if apply has not been invoked, but can be invoked
234
155
        even after apply.
235
156
        """
236
 
        raise NotImplementedError(self.finalize)
 
157
        if self._tree is None:
 
158
            return
 
159
        for hook in MutableTree.hooks['post_transform']:
 
160
            hook(self._tree, self)
 
161
        self._tree.unlock()
 
162
        self._tree = None
 
163
 
 
164
    def __get_root(self):
 
165
        return self._new_root
 
166
 
 
167
    root = property(__get_root)
 
168
 
 
169
    def _assign_id(self):
 
170
        """Produce a new tranform id"""
 
171
        new_id = "new-%s" % self._id_number
 
172
        self._id_number += 1
 
173
        return new_id
237
174
 
238
175
    def create_path(self, name, parent):
239
176
        """Assign a transaction id to a new path"""
260
197
        physically new directory, and hope someone versions the tree root
261
198
        later.
262
199
        """
263
 
        raise NotImplementedError(self.adjust_root_path)
 
200
        old_root = self._new_root
 
201
        old_root_file_id = self.final_file_id(old_root)
 
202
        # force moving all children of root
 
203
        for child_id in self.iter_tree_children(old_root):
 
204
            if child_id != parent:
 
205
                self.adjust_path(self.final_name(child_id),
 
206
                                 self.final_parent(child_id), child_id)
 
207
            file_id = self.final_file_id(child_id)
 
208
            if file_id is not None:
 
209
                self.unversion_file(child_id)
 
210
            self.version_file(file_id, child_id)
 
211
 
 
212
        # the physical root needs a new transaction id
 
213
        self._tree_path_ids.pop("")
 
214
        self._tree_id_paths.pop(old_root)
 
215
        self._new_root = self.trans_id_tree_path('')
 
216
        if parent == old_root:
 
217
            parent = self._new_root
 
218
        self.adjust_path(name, parent, old_root)
 
219
        self.create_directory(old_root)
 
220
        self.version_file(old_root_file_id, old_root)
 
221
        self.unversion_file(self._new_root)
264
222
 
265
223
    def fixup_new_roots(self):
266
224
        """Reinterpret requests to change the root directory
272
230
        This means that the old root trans-id becomes obsolete, so it is
273
231
        recommended only to invoke this after the root trans-id has become
274
232
        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
 
233
 
 
234
        """
 
235
        new_roots = [k for k, v in self._new_parent.items()
 
236
                     if v == ROOT_PARENT]
 
237
        if len(new_roots) < 1:
 
238
            return
 
239
        if len(new_roots) != 1:
 
240
            raise ValueError('A tree cannot have two roots!')
 
241
        if self._new_root is None:
 
242
            self._new_root = new_roots[0]
 
243
            return
 
244
        old_new_root = new_roots[0]
 
245
        # unversion the new root's directory.
 
246
        if self.final_kind(self._new_root) is None:
 
247
            file_id = self.final_file_id(old_new_root)
 
248
        else:
 
249
            file_id = self.final_file_id(self._new_root)
 
250
        if old_new_root in self._new_id:
 
251
            self.cancel_versioning(old_new_root)
 
252
        else:
 
253
            self.unversion_file(old_new_root)
 
254
        # if, at this stage, root still has an old file_id, zap it so we can
 
255
        # stick a new one in.
 
256
        if (self.tree_file_id(self._new_root) is not None
 
257
                and self._new_root not in self._removed_id):
 
258
            self.unversion_file(self._new_root)
 
259
        if file_id is not None:
 
260
            self.version_file(file_id, self._new_root)
 
261
 
 
262
        # Now move children of new root into old root directory.
 
263
        # Ensure all children are registered with the transaction, but don't
 
264
        # use directly-- some tree children have new parents
 
265
        list(self.iter_tree_children(old_new_root))
 
266
        # Move all children of new root into old root directory.
 
267
        for child in self.by_parent().get(old_new_root, []):
 
268
            self.adjust_path(self.final_name(child), self._new_root, child)
 
269
 
 
270
        # Ensure old_new_root has no directory.
 
271
        if old_new_root in self._new_contents:
 
272
            self.cancel_creation(old_new_root)
 
273
        else:
 
274
            self.delete_contents(old_new_root)
 
275
 
 
276
        # prevent deletion of root directory.
 
277
        if self._new_root in self._removed_contents:
 
278
            self.cancel_deletion(self._new_root)
 
279
 
 
280
        # destroy path info for old_new_root.
 
281
        del self._new_parent[old_new_root]
 
282
        del self._new_name[old_new_root]
 
283
 
 
284
    def trans_id_file_id(self, file_id):
 
285
        """Determine or set the transaction id associated with a file ID.
 
286
        A new id is only created for file_ids that were never present.  If
 
287
        a transaction has been unversioned, it is deliberately still returned.
 
288
        (this will likely lead to an unversioned parent conflict.)
 
289
        """
 
290
        if file_id is None:
 
291
            raise ValueError('None is not a valid file id')
 
292
        if file_id in self._r_new_id and self._r_new_id[file_id] is not None:
 
293
            return self._r_new_id[file_id]
 
294
        else:
 
295
            try:
 
296
                path = self._tree.id2path(file_id)
 
297
            except errors.NoSuchId:
 
298
                if file_id in self._non_present_ids:
 
299
                    return self._non_present_ids[file_id]
 
300
                else:
 
301
                    trans_id = self._assign_id()
 
302
                    self._non_present_ids[file_id] = trans_id
 
303
                    return trans_id
 
304
            else:
 
305
                return self.trans_id_tree_path(path)
283
306
 
284
307
    def trans_id_tree_path(self, path):
285
308
        """Determine (and maybe set) the transaction ID for a tree path."""
306
329
        """Cancel a scheduled deletion"""
307
330
        self._removed_contents.remove(trans_id)
308
331
 
 
332
    def unversion_file(self, trans_id):
 
333
        """Schedule a path entry to become unversioned"""
 
334
        self._removed_id.add(trans_id)
 
335
 
309
336
    def delete_versioned(self, trans_id):
310
337
        """Delete and unversion a versioned file"""
311
338
        self.delete_contents(trans_id)
324
351
        """Set the reference associated with a directory"""
325
352
        unique_add(self._new_reference_revision, trans_id, revision_id)
326
353
 
327
 
    def version_file(self, trans_id, file_id=None):
 
354
    def version_file(self, file_id, trans_id):
328
355
        """Schedule a file to become versioned."""
329
 
        raise NotImplementedError(self.version_file)
 
356
        if file_id is None:
 
357
            raise ValueError()
 
358
        unique_add(self._new_id, trans_id, file_id)
 
359
        unique_add(self._r_new_id, file_id, trans_id)
330
360
 
331
361
    def cancel_versioning(self, trans_id):
332
362
        """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)
 
363
        file_id = self._new_id[trans_id]
 
364
        del self._new_id[trans_id]
 
365
        del self._r_new_id[file_id]
338
366
 
339
367
    def new_paths(self, filesystem_only=False):
340
368
        """Determine the paths of all new and changed files.
342
370
        :param filesystem_only: if True, only calculate values for files
343
371
            that require renames or execute bit changes.
344
372
        """
345
 
        raise NotImplementedError(self.new_paths)
 
373
        new_ids = set()
 
374
        if filesystem_only:
 
375
            stale_ids = self._needs_rename.difference(self._new_name)
 
376
            stale_ids.difference_update(self._new_parent)
 
377
            stale_ids.difference_update(self._new_contents)
 
378
            stale_ids.difference_update(self._new_id)
 
379
            needs_rename = self._needs_rename.difference(stale_ids)
 
380
            id_sets = (needs_rename, self._new_executability)
 
381
        else:
 
382
            id_sets = (self._new_name, self._new_parent, self._new_contents,
 
383
                       self._new_id, self._new_executability)
 
384
        for id_set in id_sets:
 
385
            new_ids.update(id_set)
 
386
        return sorted(FinalPaths(self).get_paths(new_ids))
 
387
 
 
388
    def _inventory_altered(self):
 
389
        """Determine which trans_ids need new Inventory entries.
 
390
 
 
391
        An new entry is needed when anything that would be reflected by an
 
392
        inventory entry changes, including file name, file_id, parent file_id,
 
393
        file kind, and the execute bit.
 
394
 
 
395
        Some care is taken to return entries with real changes, not cases
 
396
        where the value is deleted and then restored to its original value,
 
397
        but some actually unchanged values may be returned.
 
398
 
 
399
        :returns: A list of (path, trans_id) for all items requiring an
 
400
            inventory change. Ordered by path.
 
401
        """
 
402
        changed_ids = set()
 
403
        # Find entries whose file_ids are new (or changed).
 
404
        new_file_id = set(t for t in self._new_id
 
405
                          if self._new_id[t] != self.tree_file_id(t))
 
406
        for id_set in [self._new_name, self._new_parent, new_file_id,
 
407
                       self._new_executability]:
 
408
            changed_ids.update(id_set)
 
409
        # removing implies a kind change
 
410
        changed_kind = set(self._removed_contents)
 
411
        # so does adding
 
412
        changed_kind.intersection_update(self._new_contents)
 
413
        # Ignore entries that are already known to have changed.
 
414
        changed_kind.difference_update(changed_ids)
 
415
        #  to keep only the truly changed ones
 
416
        changed_kind = (t for t in changed_kind
 
417
                        if self.tree_kind(t) != self.final_kind(t))
 
418
        # all kind changes will alter the inventory
 
419
        changed_ids.update(changed_kind)
 
420
        # To find entries with changed parent_ids, find parents which existed,
 
421
        # but changed file_id.
 
422
        # Now add all their children to the set.
 
423
        for parent_trans_id in new_file_id:
 
424
            changed_ids.update(self.iter_tree_children(parent_trans_id))
 
425
        return sorted(FinalPaths(self).get_paths(changed_ids))
346
426
 
347
427
    def final_kind(self, trans_id):
348
428
        """Determine the final file kind, after any changes applied.
362
442
        """Determine the tree path associated with the trans_id."""
363
443
        return self._tree_id_paths.get(trans_id)
364
444
 
365
 
    def final_is_versioned(self, trans_id):
366
 
        raise NotImplementedError(self.final_is_versioned)
 
445
    def tree_file_id(self, trans_id):
 
446
        """Determine the file id associated with the trans_id in the tree"""
 
447
        path = self.tree_path(trans_id)
 
448
        if path is None:
 
449
            return None
 
450
        # the file is old; the old id is still valid
 
451
        if self._new_root == trans_id:
 
452
            return self._tree.path2id('')
 
453
        return self._tree.path2id(path)
 
454
 
 
455
    def final_file_id(self, trans_id):
 
456
        """Determine the file id after any changes are applied, or None.
 
457
 
 
458
        None indicates that the file will not be versioned after changes are
 
459
        applied.
 
460
        """
 
461
        try:
 
462
            return self._new_id[trans_id]
 
463
        except KeyError:
 
464
            if trans_id in self._removed_id:
 
465
                return None
 
466
        return self.tree_file_id(trans_id)
 
467
 
 
468
    def inactive_file_id(self, trans_id):
 
469
        """Return the inactive file_id associated with a transaction id.
 
470
        That is, the one in the tree or in non_present_ids.
 
471
        The file_id may actually be active, too.
 
472
        """
 
473
        file_id = self.tree_file_id(trans_id)
 
474
        if file_id is not None:
 
475
            return file_id
 
476
        for key, value in self._non_present_ids.items():
 
477
            if value == trans_id:
 
478
                return key
367
479
 
368
480
    def final_parent(self, trans_id):
369
481
        """Determine the parent file_id, after any changes are applied.
385
497
            except KeyError:
386
498
                raise NoFinalPath(trans_id, self)
387
499
 
 
500
    def by_parent(self):
 
501
        """Return a map of parent: children for known parents.
 
502
 
 
503
        Only new paths and parents of tree files with assigned ids are used.
 
504
        """
 
505
        by_parent = {}
 
506
        items = list(self._new_parent.items())
 
507
        items.extend((t, self.final_parent(t))
 
508
                     for t in list(self._tree_id_paths))
 
509
        for trans_id, parent_id in items:
 
510
            if parent_id not in by_parent:
 
511
                by_parent[parent_id] = set()
 
512
            by_parent[parent_id].add(trans_id)
 
513
        return by_parent
 
514
 
388
515
    def path_changed(self, trans_id):
389
516
        """Return True if a trans_id's path has changed."""
390
517
        return (trans_id in self._new_name) or (trans_id in self._new_parent)
394
521
 
395
522
    def find_conflicts(self):
396
523
        """Find any violations of inventory or filesystem invariants"""
397
 
        raise NotImplementedError(self.find_conflicts)
 
524
        if self._done is True:
 
525
            raise ReusingTransform()
 
526
        conflicts = []
 
527
        # ensure all children of all existent parents are known
 
528
        # all children of non-existent parents are known, by definition.
 
529
        self._add_tree_children()
 
530
        by_parent = self.by_parent()
 
531
        conflicts.extend(self._unversioned_parents(by_parent))
 
532
        conflicts.extend(self._parent_loops())
 
533
        conflicts.extend(self._duplicate_entries(by_parent))
 
534
        conflicts.extend(self._duplicate_ids())
 
535
        conflicts.extend(self._parent_type_conflicts(by_parent))
 
536
        conflicts.extend(self._improper_versioning())
 
537
        conflicts.extend(self._executability_conflicts())
 
538
        conflicts.extend(self._overwrite_conflicts())
 
539
        return conflicts
 
540
 
 
541
    def _check_malformed(self):
 
542
        conflicts = self.find_conflicts()
 
543
        if len(conflicts) != 0:
 
544
            raise MalformedTransform(conflicts=conflicts)
 
545
 
 
546
    def _add_tree_children(self):
 
547
        """Add all the children of all active parents to the known paths.
 
548
 
 
549
        Active parents are those which gain children, and those which are
 
550
        removed.  This is a necessary first step in detecting conflicts.
 
551
        """
 
552
        parents = list(self.by_parent())
 
553
        parents.extend([t for t in self._removed_contents if
 
554
                        self.tree_kind(t) == 'directory'])
 
555
        for trans_id in self._removed_id:
 
556
            path = self.tree_path(trans_id)
 
557
            if path is not None:
 
558
                if self._tree.stored_kind(path) == 'directory':
 
559
                    parents.append(trans_id)
 
560
            elif self.tree_kind(trans_id) == 'directory':
 
561
                parents.append(trans_id)
 
562
 
 
563
        for parent_id in parents:
 
564
            # ensure that all children are registered with the transaction
 
565
            list(self.iter_tree_children(parent_id))
 
566
 
 
567
    def _has_named_child(self, name, parent_id, known_children):
 
568
        """Does a parent already have a name child.
 
569
 
 
570
        :param name: The searched for name.
 
571
 
 
572
        :param parent_id: The parent for which the check is made.
 
573
 
 
574
        :param known_children: The already known children. This should have
 
575
            been recently obtained from `self.by_parent.get(parent_id)`
 
576
            (or will be if None is passed).
 
577
        """
 
578
        if known_children is None:
 
579
            known_children = self.by_parent().get(parent_id, [])
 
580
        for child in known_children:
 
581
            if self.final_name(child) == name:
 
582
                return True
 
583
        parent_path = self._tree_id_paths.get(parent_id, None)
 
584
        if parent_path is None:
 
585
            # No parent... no children
 
586
            return False
 
587
        child_path = joinpath(parent_path, name)
 
588
        child_id = self._tree_path_ids.get(child_path, None)
 
589
        if child_id is None:
 
590
            # Not known by the tree transform yet, check the filesystem
 
591
            return osutils.lexists(self._tree.abspath(child_path))
 
592
        else:
 
593
            raise AssertionError('child_id is missing: %s, %s, %s'
 
594
                                 % (name, parent_id, child_id))
 
595
 
 
596
    def _available_backup_name(self, name, target_id):
 
597
        """Find an available backup name.
 
598
 
 
599
        :param name: The basename of the file.
 
600
 
 
601
        :param target_id: The directory trans_id where the backup should
 
602
            be placed.
 
603
        """
 
604
        known_children = self.by_parent().get(target_id, [])
 
605
        return osutils.available_backup_name(
 
606
            name,
 
607
            lambda base: self._has_named_child(
 
608
                base, target_id, known_children))
 
609
 
 
610
    def _parent_loops(self):
 
611
        """No entry should be its own ancestor"""
 
612
        conflicts = []
 
613
        for trans_id in self._new_parent:
 
614
            seen = set()
 
615
            parent_id = trans_id
 
616
            while parent_id != ROOT_PARENT:
 
617
                seen.add(parent_id)
 
618
                try:
 
619
                    parent_id = self.final_parent(parent_id)
 
620
                except KeyError:
 
621
                    break
 
622
                if parent_id == trans_id:
 
623
                    conflicts.append(('parent loop', trans_id))
 
624
                if parent_id in seen:
 
625
                    break
 
626
        return conflicts
 
627
 
 
628
    def _unversioned_parents(self, by_parent):
 
629
        """If parent directories are versioned, children must be versioned."""
 
630
        conflicts = []
 
631
        for parent_id, children in by_parent.items():
 
632
            if parent_id == ROOT_PARENT:
 
633
                continue
 
634
            if self.final_file_id(parent_id) is not None:
 
635
                continue
 
636
            for child_id in children:
 
637
                if self.final_file_id(child_id) is not None:
 
638
                    conflicts.append(('unversioned parent', parent_id))
 
639
                    break
 
640
        return conflicts
 
641
 
 
642
    def _improper_versioning(self):
 
643
        """Cannot version a file with no contents, or a bad type.
 
644
 
 
645
        However, existing entries with no contents are okay.
 
646
        """
 
647
        conflicts = []
 
648
        for trans_id in self._new_id:
 
649
            kind = self.final_kind(trans_id)
 
650
            if kind == 'symlink' and not self._tree.supports_symlinks():
 
651
                # Ignore symlinks as they are not supported on this platform
 
652
                continue
 
653
            if kind is None:
 
654
                conflicts.append(('versioning no contents', trans_id))
 
655
                continue
 
656
            if not self._tree.versionable_kind(kind):
 
657
                conflicts.append(('versioning bad kind', trans_id, kind))
 
658
        return conflicts
 
659
 
 
660
    def _executability_conflicts(self):
 
661
        """Check for bad executability changes.
 
662
 
 
663
        Only versioned files may have their executability set, because
 
664
        1. only versioned entries can have executability under windows
 
665
        2. only files can be executable.  (The execute bit on a directory
 
666
           does not indicate searchability)
 
667
        """
 
668
        conflicts = []
 
669
        for trans_id in self._new_executability:
 
670
            if self.final_file_id(trans_id) is None:
 
671
                conflicts.append(('unversioned executability', trans_id))
 
672
            else:
 
673
                if self.final_kind(trans_id) != "file":
 
674
                    conflicts.append(('non-file executability', trans_id))
 
675
        return conflicts
 
676
 
 
677
    def _overwrite_conflicts(self):
 
678
        """Check for overwrites (not permitted on Win32)"""
 
679
        conflicts = []
 
680
        for trans_id in self._new_contents:
 
681
            if self.tree_kind(trans_id) is None:
 
682
                continue
 
683
            if trans_id not in self._removed_contents:
 
684
                conflicts.append(('overwrite', trans_id,
 
685
                                  self.final_name(trans_id)))
 
686
        return conflicts
 
687
 
 
688
    def _duplicate_entries(self, by_parent):
 
689
        """No directory may have two entries with the same name."""
 
690
        conflicts = []
 
691
        if (self._new_name, self._new_parent) == ({}, {}):
 
692
            return conflicts
 
693
        for children in by_parent.values():
 
694
            name_ids = []
 
695
            for child_tid in children:
 
696
                name = self.final_name(child_tid)
 
697
                if name is not None:
 
698
                    # Keep children only if they still exist in the end
 
699
                    if not self._case_sensitive_target:
 
700
                        name = name.lower()
 
701
                    name_ids.append((name, child_tid))
 
702
            name_ids.sort()
 
703
            last_name = None
 
704
            last_trans_id = None
 
705
            for name, trans_id in name_ids:
 
706
                kind = self.final_kind(trans_id)
 
707
                file_id = self.final_file_id(trans_id)
 
708
                if kind is None and file_id is None:
 
709
                    continue
 
710
                if name == last_name:
 
711
                    conflicts.append(('duplicate', last_trans_id, trans_id,
 
712
                                      name))
 
713
                last_name = name
 
714
                last_trans_id = trans_id
 
715
        return conflicts
 
716
 
 
717
    def _duplicate_ids(self):
 
718
        """Each inventory id may only be used once"""
 
719
        conflicts = []
 
720
        try:
 
721
            all_ids = self._tree.all_file_ids()
 
722
        except errors.UnsupportedOperation:
 
723
            # it's okay for non-file-id trees to raise UnsupportedOperation.
 
724
            return []
 
725
        removed_tree_ids = set((self.tree_file_id(trans_id) for trans_id in
 
726
                                self._removed_id))
 
727
        active_tree_ids = all_ids.difference(removed_tree_ids)
 
728
        for trans_id, file_id in self._new_id.items():
 
729
            if file_id in active_tree_ids:
 
730
                path = self._tree.id2path(file_id)
 
731
                old_trans_id = self.trans_id_tree_path(path)
 
732
                conflicts.append(('duplicate id', old_trans_id, trans_id))
 
733
        return conflicts
 
734
 
 
735
    def _parent_type_conflicts(self, by_parent):
 
736
        """Children must have a directory parent"""
 
737
        conflicts = []
 
738
        for parent_id, children in by_parent.items():
 
739
            if parent_id == ROOT_PARENT:
 
740
                continue
 
741
            no_children = True
 
742
            for child_id in children:
 
743
                if self.final_kind(child_id) is not None:
 
744
                    no_children = False
 
745
                    break
 
746
            if no_children:
 
747
                continue
 
748
            # There is at least a child, so we need an existing directory to
 
749
            # contain it.
 
750
            kind = self.final_kind(parent_id)
 
751
            if kind is None:
 
752
                # The directory will be deleted
 
753
                conflicts.append(('missing parent', parent_id))
 
754
            elif kind != "directory":
 
755
                # Meh, we need a *directory* to put something in it
 
756
                conflicts.append(('non-directory parent', parent_id))
 
757
        return conflicts
 
758
 
 
759
    def _set_executability(self, path, trans_id):
 
760
        """Set the executability of versioned files """
 
761
        if self._tree._supports_executable():
 
762
            new_executability = self._new_executability[trans_id]
 
763
            abspath = self._tree.abspath(path)
 
764
            current_mode = os.stat(abspath).st_mode
 
765
            if new_executability:
 
766
                umask = os.umask(0)
 
767
                os.umask(umask)
 
768
                to_mode = current_mode | (0o100 & ~umask)
 
769
                # Enable x-bit for others only if they can read it.
 
770
                if current_mode & 0o004:
 
771
                    to_mode |= 0o001 & ~umask
 
772
                if current_mode & 0o040:
 
773
                    to_mode |= 0o010 & ~umask
 
774
            else:
 
775
                to_mode = current_mode & ~0o111
 
776
            osutils.chmod_if_possible(abspath, to_mode)
 
777
 
 
778
    def _new_entry(self, name, parent_id, file_id):
 
779
        """Helper function to create a new filesystem entry."""
 
780
        trans_id = self.create_path(name, parent_id)
 
781
        if file_id is not None:
 
782
            self.version_file(file_id, trans_id)
 
783
        return trans_id
398
784
 
399
785
    def new_file(self, name, parent_id, contents, file_id=None,
400
786
                 executable=None, sha1=None):
407
793
        :param file_id: The inventory ID of the file, if it is to be versioned.
408
794
        :param executable: Only valid when a file_id has been supplied.
409
795
        """
410
 
        raise NotImplementedError(self.new_file)
 
796
        trans_id = self._new_entry(name, parent_id, file_id)
 
797
        # TODO: rather than scheduling a set_executable call,
 
798
        # have create_file create the file with the right mode.
 
799
        self.create_file(contents, trans_id, sha1=sha1)
 
800
        if executable is not None:
 
801
            self.set_executability(executable, trans_id)
 
802
        return trans_id
411
803
 
412
804
    def new_directory(self, name, parent_id, file_id=None):
413
805
        """Convenience method to create directories.
417
809
        directory.
418
810
        file_id is the inventory ID of the directory, if it is to be versioned.
419
811
        """
420
 
        raise NotImplementedError(self.new_directory)
 
812
        trans_id = self._new_entry(name, parent_id, file_id)
 
813
        self.create_directory(trans_id)
 
814
        return trans_id
421
815
 
422
816
    def new_symlink(self, name, parent_id, target, file_id=None):
423
817
        """Convenience method to create symbolic link.
427
821
        target is a bytestring of the target of the symlink.
428
822
        file_id is the inventory ID of the file, if it is to be versioned.
429
823
        """
430
 
        raise NotImplementedError(self.new_symlink)
 
824
        trans_id = self._new_entry(name, parent_id, file_id)
 
825
        self.create_symlink(target, trans_id)
 
826
        return trans_id
431
827
 
432
828
    def new_orphan(self, trans_id, parent_id):
433
829
        """Schedule an item to be orphaned.
440
836
        """
441
837
        raise NotImplementedError(self.new_orphan)
442
838
 
 
839
    def _get_potential_orphans(self, dir_id):
 
840
        """Find the potential orphans in a directory.
 
841
 
 
842
        A directory can't be safely deleted if there are versioned files in it.
 
843
        If all the contained files are unversioned then they can be orphaned.
 
844
 
 
845
        The 'None' return value means that the directory contains at least one
 
846
        versioned file and should not be deleted.
 
847
 
 
848
        :param dir_id: The directory trans id.
 
849
 
 
850
        :return: A list of the orphan trans ids or None if at least one
 
851
             versioned file is present.
 
852
        """
 
853
        orphans = []
 
854
        # Find the potential orphans, stop if one item should be kept
 
855
        for child_tid in self.by_parent()[dir_id]:
 
856
            if child_tid in self._removed_contents:
 
857
                # The child is removed as part of the transform. Since it was
 
858
                # versioned before, it's not an orphan
 
859
                continue
 
860
            elif self.final_file_id(child_tid) is None:
 
861
                # The child is not versioned
 
862
                orphans.append(child_tid)
 
863
            else:
 
864
                # We have a versioned file here, searching for orphans is
 
865
                # meaningless.
 
866
                orphans = None
 
867
                break
 
868
        return orphans
 
869
 
 
870
    def _affected_ids(self):
 
871
        """Return the set of transform ids affected by the transform"""
 
872
        trans_ids = set(self._removed_id)
 
873
        trans_ids.update(self._new_id)
 
874
        trans_ids.update(self._removed_contents)
 
875
        trans_ids.update(self._new_contents)
 
876
        trans_ids.update(self._new_executability)
 
877
        trans_ids.update(self._new_name)
 
878
        trans_ids.update(self._new_parent)
 
879
        return trans_ids
 
880
 
 
881
    def _get_file_id_maps(self):
 
882
        """Return mapping of file_ids to trans_ids in the to and from states"""
 
883
        trans_ids = self._affected_ids()
 
884
        from_trans_ids = {}
 
885
        to_trans_ids = {}
 
886
        # Build up two dicts: trans_ids associated with file ids in the
 
887
        # FROM state, vs the TO state.
 
888
        for trans_id in trans_ids:
 
889
            from_file_id = self.tree_file_id(trans_id)
 
890
            if from_file_id is not None:
 
891
                from_trans_ids[from_file_id] = trans_id
 
892
            to_file_id = self.final_file_id(trans_id)
 
893
            if to_file_id is not None:
 
894
                to_trans_ids[to_file_id] = trans_id
 
895
        return from_trans_ids, to_trans_ids
 
896
 
 
897
    def _from_file_data(self, from_trans_id, from_versioned, from_path):
 
898
        """Get data about a file in the from (tree) state
 
899
 
 
900
        Return a (name, parent, kind, executable) tuple
 
901
        """
 
902
        from_path = self._tree_id_paths.get(from_trans_id)
 
903
        if from_versioned:
 
904
            # get data from working tree if versioned
 
905
            from_entry = next(self._tree.iter_entries_by_dir(
 
906
                specific_files=[from_path]))[1]
 
907
            from_name = from_entry.name
 
908
            from_parent = from_entry.parent_id
 
909
        else:
 
910
            from_entry = None
 
911
            if from_path is None:
 
912
                # File does not exist in FROM state
 
913
                from_name = None
 
914
                from_parent = None
 
915
            else:
 
916
                # File exists, but is not versioned.  Have to use path-
 
917
                # splitting stuff
 
918
                from_name = os.path.basename(from_path)
 
919
                tree_parent = self.get_tree_parent(from_trans_id)
 
920
                from_parent = self.tree_file_id(tree_parent)
 
921
        if from_path is not None:
 
922
            from_kind, from_executable, from_stats = \
 
923
                self._tree._comparison_data(from_entry, from_path)
 
924
        else:
 
925
            from_kind = None
 
926
            from_executable = False
 
927
        return from_name, from_parent, from_kind, from_executable
 
928
 
 
929
    def _to_file_data(self, to_trans_id, from_trans_id, from_executable):
 
930
        """Get data about a file in the to (target) state
 
931
 
 
932
        Return a (name, parent, kind, executable) tuple
 
933
        """
 
934
        to_name = self.final_name(to_trans_id)
 
935
        to_kind = self.final_kind(to_trans_id)
 
936
        to_parent = self.final_file_id(self.final_parent(to_trans_id))
 
937
        if to_trans_id in self._new_executability:
 
938
            to_executable = self._new_executability[to_trans_id]
 
939
        elif to_trans_id == from_trans_id:
 
940
            to_executable = from_executable
 
941
        else:
 
942
            to_executable = False
 
943
        return to_name, to_parent, to_kind, to_executable
 
944
 
443
945
    def iter_changes(self):
444
946
        """Produce output in the same format as Tree.iter_changes.
445
947
 
450
952
        file_id.  Files that are not versioned in either of the FROM or TO
451
953
        states are not reflected.
452
954
        """
453
 
        raise NotImplementedError(self.iter_changes)
 
955
        final_paths = FinalPaths(self)
 
956
        from_trans_ids, to_trans_ids = self._get_file_id_maps()
 
957
        results = []
 
958
        # Now iterate through all active file_ids
 
959
        for file_id in set(from_trans_ids).union(to_trans_ids):
 
960
            modified = False
 
961
            from_trans_id = from_trans_ids.get(file_id)
 
962
            # find file ids, and determine versioning state
 
963
            if from_trans_id is None:
 
964
                from_versioned = False
 
965
                from_trans_id = to_trans_ids[file_id]
 
966
            else:
 
967
                from_versioned = True
 
968
            to_trans_id = to_trans_ids.get(file_id)
 
969
            if to_trans_id is None:
 
970
                to_versioned = False
 
971
                to_trans_id = from_trans_id
 
972
            else:
 
973
                to_versioned = True
 
974
 
 
975
            if not from_versioned:
 
976
                from_path = None
 
977
            else:
 
978
                from_path = self._tree_id_paths.get(from_trans_id)
 
979
            if not to_versioned:
 
980
                to_path = None
 
981
            else:
 
982
                to_path = final_paths.get_path(to_trans_id)
 
983
 
 
984
            from_name, from_parent, from_kind, from_executable = \
 
985
                self._from_file_data(from_trans_id, from_versioned, from_path)
 
986
 
 
987
            to_name, to_parent, to_kind, to_executable = \
 
988
                self._to_file_data(to_trans_id, from_trans_id, from_executable)
 
989
 
 
990
            if from_kind != to_kind:
 
991
                modified = True
 
992
            elif to_kind in ('file', 'symlink') and (
 
993
                    to_trans_id != from_trans_id
 
994
                    or to_trans_id in self._new_contents):
 
995
                modified = True
 
996
            if (not modified and from_versioned == to_versioned
 
997
                and from_parent == to_parent and from_name == to_name
 
998
                    and from_executable == to_executable):
 
999
                continue
 
1000
            results.append(
 
1001
                TreeChange(
 
1002
                    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
 
 
1009
        def path_key(c):
 
1010
            return (c.path[0] or '', c.path[1] or '')
 
1011
        return iter(sorted(results, key=path_key))
454
1012
 
455
1013
    def get_preview_tree(self):
456
1014
        """Return a tree representing the result of the transform.
458
1016
        The tree is a snapshot, and altering the TreeTransform will invalidate
459
1017
        it.
460
1018
        """
461
 
        raise NotImplementedError(self.get_preview_tree)
 
1019
        return _PreviewTree(self)
462
1020
 
463
1021
    def commit(self, branch, message, merge_parents=None, strict=False,
464
1022
               timestamp=None, timezone=None, committer=None, authors=None,
483
1041
            may reduce performance for some non-native formats.)
484
1042
        :return: The revision_id of the revision committed.
485
1043
        """
486
 
        raise NotImplementedError(self.commit)
 
1044
        self._check_malformed()
 
1045
        if strict:
 
1046
            unversioned = set(self._new_contents).difference(set(self._new_id))
 
1047
            for trans_id in unversioned:
 
1048
                if self.final_file_id(trans_id) is None:
 
1049
                    raise errors.StrictCommitFailed()
 
1050
 
 
1051
        revno, last_rev_id = branch.last_revision_info()
 
1052
        if last_rev_id == _mod_revision.NULL_REVISION:
 
1053
            if merge_parents is not None:
 
1054
                raise ValueError('Cannot supply merge parents for first'
 
1055
                                 ' commit.')
 
1056
            parent_ids = []
 
1057
        else:
 
1058
            parent_ids = [last_rev_id]
 
1059
            if merge_parents is not None:
 
1060
                parent_ids.extend(merge_parents)
 
1061
        if self._tree.get_revision_id() != last_rev_id:
 
1062
            raise ValueError('TreeTransform not based on branch basis: %s' %
 
1063
                             self._tree.get_revision_id().decode('utf-8'))
 
1064
        revprops = commit.Commit.update_revprops(revprops, branch, authors)
 
1065
        builder = branch.get_commit_builder(parent_ids,
 
1066
                                            timestamp=timestamp,
 
1067
                                            timezone=timezone,
 
1068
                                            committer=committer,
 
1069
                                            revprops=revprops,
 
1070
                                            revision_id=revision_id)
 
1071
        preview = self.get_preview_tree()
 
1072
        list(builder.record_iter_changes(preview, last_rev_id,
 
1073
                                         self.iter_changes()))
 
1074
        builder.finish_inventory()
 
1075
        revision_id = builder.commit(message)
 
1076
        branch.set_last_revision_info(revno + 1, revision_id)
 
1077
        return revision_id
 
1078
 
 
1079
    def _text_parent(self, trans_id):
 
1080
        path = self.tree_path(trans_id)
 
1081
        try:
 
1082
            if path is None or self._tree.kind(path) != 'file':
 
1083
                return None
 
1084
        except errors.NoSuchFile:
 
1085
            return None
 
1086
        return path
 
1087
 
 
1088
    def _get_parents_texts(self, trans_id):
 
1089
        """Get texts for compression parents of this file."""
 
1090
        path = self._text_parent(trans_id)
 
1091
        if path is None:
 
1092
            return ()
 
1093
        return (self._tree.get_file_text(path),)
 
1094
 
 
1095
    def _get_parents_lines(self, trans_id):
 
1096
        """Get lines for compression parents of this file."""
 
1097
        path = self._text_parent(trans_id)
 
1098
        if path is None:
 
1099
            return ()
 
1100
        return (self._tree.get_file_lines(path),)
 
1101
 
 
1102
    def serialize(self, serializer):
 
1103
        """Serialize this TreeTransform.
 
1104
 
 
1105
        :param serializer: A Serialiser like pack.ContainerSerializer.
 
1106
        """
 
1107
        new_name = {k.encode('utf-8'): v.encode('utf-8')
 
1108
                    for k, v in self._new_name.items()}
 
1109
        new_parent = {k.encode('utf-8'): v.encode('utf-8')
 
1110
                      for k, v in self._new_parent.items()}
 
1111
        new_id = {k.encode('utf-8'): v
 
1112
                  for k, v in self._new_id.items()}
 
1113
        new_executability = {k.encode('utf-8'): int(v)
 
1114
                             for k, v in self._new_executability.items()}
 
1115
        tree_path_ids = {k.encode('utf-8'): v.encode('utf-8')
 
1116
                         for k, v in self._tree_path_ids.items()}
 
1117
        non_present_ids = {k: v.encode('utf-8')
 
1118
                           for k, v in self._non_present_ids.items()}
 
1119
        removed_contents = [trans_id.encode('utf-8')
 
1120
                            for trans_id in self._removed_contents]
 
1121
        removed_id = [trans_id.encode('utf-8')
 
1122
                      for trans_id in self._removed_id]
 
1123
        attribs = {
 
1124
            b'_id_number': self._id_number,
 
1125
            b'_new_name': new_name,
 
1126
            b'_new_parent': new_parent,
 
1127
            b'_new_executability': new_executability,
 
1128
            b'_new_id': new_id,
 
1129
            b'_tree_path_ids': tree_path_ids,
 
1130
            b'_removed_id': removed_id,
 
1131
            b'_removed_contents': removed_contents,
 
1132
            b'_non_present_ids': non_present_ids,
 
1133
            }
 
1134
        yield serializer.bytes_record(bencode.bencode(attribs),
 
1135
                                      ((b'attribs',),))
 
1136
        for trans_id, kind in sorted(self._new_contents.items()):
 
1137
            if kind == 'file':
 
1138
                with open(self._limbo_name(trans_id), 'rb') as cur_file:
 
1139
                    lines = cur_file.readlines()
 
1140
                parents = self._get_parents_lines(trans_id)
 
1141
                mpdiff = multiparent.MultiParent.from_lines(lines, parents)
 
1142
                content = b''.join(mpdiff.to_patch())
 
1143
            if kind == 'directory':
 
1144
                content = b''
 
1145
            if kind == 'symlink':
 
1146
                content = self._read_symlink_target(trans_id)
 
1147
                if not isinstance(content, bytes):
 
1148
                    content = content.encode('utf-8')
 
1149
            yield serializer.bytes_record(
 
1150
                content, ((trans_id.encode('utf-8'), kind.encode('ascii')),))
 
1151
 
 
1152
    def deserialize(self, records):
 
1153
        """Deserialize a stored TreeTransform.
 
1154
 
 
1155
        :param records: An iterable of (names, content) tuples, as per
 
1156
            pack.ContainerPushParser.
 
1157
        """
 
1158
        names, content = next(records)
 
1159
        attribs = bencode.bdecode(content)
 
1160
        self._id_number = attribs[b'_id_number']
 
1161
        self._new_name = {k.decode('utf-8'): v.decode('utf-8')
 
1162
                          for k, v in attribs[b'_new_name'].items()}
 
1163
        self._new_parent = {k.decode('utf-8'): v.decode('utf-8')
 
1164
                            for k, v in attribs[b'_new_parent'].items()}
 
1165
        self._new_executability = {
 
1166
            k.decode('utf-8'): bool(v)
 
1167
            for k, v in attribs[b'_new_executability'].items()}
 
1168
        self._new_id = {k.decode('utf-8'): v
 
1169
                        for k, v in attribs[b'_new_id'].items()}
 
1170
        self._r_new_id = {v: k for k, v in self._new_id.items()}
 
1171
        self._tree_path_ids = {}
 
1172
        self._tree_id_paths = {}
 
1173
        for bytepath, trans_id in attribs[b'_tree_path_ids'].items():
 
1174
            path = bytepath.decode('utf-8')
 
1175
            trans_id = trans_id.decode('utf-8')
 
1176
            self._tree_path_ids[path] = trans_id
 
1177
            self._tree_id_paths[trans_id] = path
 
1178
        self._removed_id = {trans_id.decode('utf-8')
 
1179
                            for trans_id in attribs[b'_removed_id']}
 
1180
        self._removed_contents = set(
 
1181
            trans_id.decode('utf-8')
 
1182
            for trans_id in attribs[b'_removed_contents'])
 
1183
        self._non_present_ids = {
 
1184
            k: v.decode('utf-8')
 
1185
            for k, v in attribs[b'_non_present_ids'].items()}
 
1186
        for ((trans_id, kind),), content in records:
 
1187
            trans_id = trans_id.decode('utf-8')
 
1188
            kind = kind.decode('ascii')
 
1189
            if kind == 'file':
 
1190
                mpdiff = multiparent.MultiParent.from_patch(content)
 
1191
                lines = mpdiff.to_lines(self._get_parents_texts(trans_id))
 
1192
                self.create_file(lines, trans_id)
 
1193
            if kind == 'directory':
 
1194
                self.create_directory(trans_id)
 
1195
            if kind == 'symlink':
 
1196
                self.create_symlink(content.decode('utf-8'), trans_id)
487
1197
 
488
1198
    def create_file(self, contents, trans_id, mode_id=None, sha1=None):
489
1199
        """Schedule creation of a new file.
525
1235
        raise NotImplementedError(self.cancel_creation)
526
1236
 
527
1237
 
 
1238
class DiskTreeTransform(TreeTransformBase):
 
1239
    """Tree transform storing its contents on disk."""
 
1240
 
 
1241
    def __init__(self, tree, limbodir, pb=None, case_sensitive=True):
 
1242
        """Constructor.
 
1243
        :param tree: The tree that will be transformed, but not necessarily
 
1244
            the output tree.
 
1245
        :param limbodir: A directory where new files can be stored until
 
1246
            they are installed in their proper places
 
1247
        :param pb: ignored
 
1248
        :param case_sensitive: If True, the target of the transform is
 
1249
            case sensitive, not just case preserving.
 
1250
        """
 
1251
        TreeTransformBase.__init__(self, tree, pb, case_sensitive)
 
1252
        self._limbodir = limbodir
 
1253
        self._deletiondir = None
 
1254
        # A mapping of transform ids to their limbo filename
 
1255
        self._limbo_files = {}
 
1256
        self._possibly_stale_limbo_files = set()
 
1257
        # A mapping of transform ids to a set of the transform ids of children
 
1258
        # that their limbo directory has
 
1259
        self._limbo_children = {}
 
1260
        # Map transform ids to maps of child filename to child transform id
 
1261
        self._limbo_children_names = {}
 
1262
        # List of transform ids that need to be renamed from limbo into place
 
1263
        self._needs_rename = set()
 
1264
        self._creation_mtime = None
 
1265
        self._create_symlinks = osutils.supports_symlinks(self._limbodir)
 
1266
 
 
1267
    def finalize(self):
 
1268
        """Release the working tree lock, if held, clean up limbo dir.
 
1269
 
 
1270
        This is required if apply has not been invoked, but can be invoked
 
1271
        even after apply.
 
1272
        """
 
1273
        if self._tree is None:
 
1274
            return
 
1275
        try:
 
1276
            limbo_paths = list(self._limbo_files.values())
 
1277
            limbo_paths.extend(self._possibly_stale_limbo_files)
 
1278
            limbo_paths.sort(reverse=True)
 
1279
            for path in limbo_paths:
 
1280
                try:
 
1281
                    delete_any(path)
 
1282
                except OSError as e:
 
1283
                    if e.errno != errno.ENOENT:
 
1284
                        raise
 
1285
                    # XXX: warn? perhaps we just got interrupted at an
 
1286
                    # inconvenient moment, but perhaps files are disappearing
 
1287
                    # from under us?
 
1288
            try:
 
1289
                delete_any(self._limbodir)
 
1290
            except OSError:
 
1291
                # We don't especially care *why* the dir is immortal.
 
1292
                raise ImmortalLimbo(self._limbodir)
 
1293
            try:
 
1294
                if self._deletiondir is not None:
 
1295
                    delete_any(self._deletiondir)
 
1296
            except OSError:
 
1297
                raise errors.ImmortalPendingDeletion(self._deletiondir)
 
1298
        finally:
 
1299
            TreeTransformBase.finalize(self)
 
1300
 
 
1301
    def _limbo_supports_executable(self):
 
1302
        """Check if the limbo path supports the executable bit."""
 
1303
        return osutils.supports_executable(self._limbodir)
 
1304
 
 
1305
    def _limbo_name(self, trans_id):
 
1306
        """Generate the limbo name of a file"""
 
1307
        limbo_name = self._limbo_files.get(trans_id)
 
1308
        if limbo_name is None:
 
1309
            limbo_name = self._generate_limbo_path(trans_id)
 
1310
            self._limbo_files[trans_id] = limbo_name
 
1311
        return limbo_name
 
1312
 
 
1313
    def _generate_limbo_path(self, trans_id):
 
1314
        """Generate a limbo path using the trans_id as the relative path.
 
1315
 
 
1316
        This is suitable as a fallback, and when the transform should not be
 
1317
        sensitive to the path encoding of the limbo directory.
 
1318
        """
 
1319
        self._needs_rename.add(trans_id)
 
1320
        return pathjoin(self._limbodir, trans_id)
 
1321
 
 
1322
    def adjust_path(self, name, parent, trans_id):
 
1323
        previous_parent = self._new_parent.get(trans_id)
 
1324
        previous_name = self._new_name.get(trans_id)
 
1325
        TreeTransformBase.adjust_path(self, name, parent, trans_id)
 
1326
        if (trans_id in self._limbo_files
 
1327
                and trans_id not in self._needs_rename):
 
1328
            self._rename_in_limbo([trans_id])
 
1329
            if previous_parent != parent:
 
1330
                self._limbo_children[previous_parent].remove(trans_id)
 
1331
            if previous_parent != parent or previous_name != name:
 
1332
                del self._limbo_children_names[previous_parent][previous_name]
 
1333
 
 
1334
    def _rename_in_limbo(self, trans_ids):
 
1335
        """Fix limbo names so that the right final path is produced.
 
1336
 
 
1337
        This means we outsmarted ourselves-- we tried to avoid renaming
 
1338
        these files later by creating them with their final names in their
 
1339
        final parents.  But now the previous name or parent is no longer
 
1340
        suitable, so we have to rename them.
 
1341
 
 
1342
        Even for trans_ids that have no new contents, we must remove their
 
1343
        entries from _limbo_files, because they are now stale.
 
1344
        """
 
1345
        for trans_id in trans_ids:
 
1346
            old_path = self._limbo_files[trans_id]
 
1347
            self._possibly_stale_limbo_files.add(old_path)
 
1348
            del self._limbo_files[trans_id]
 
1349
            if trans_id not in self._new_contents:
 
1350
                continue
 
1351
            new_path = self._limbo_name(trans_id)
 
1352
            os.rename(old_path, new_path)
 
1353
            self._possibly_stale_limbo_files.remove(old_path)
 
1354
            for descendant in self._limbo_descendants(trans_id):
 
1355
                desc_path = self._limbo_files[descendant]
 
1356
                desc_path = new_path + desc_path[len(old_path):]
 
1357
                self._limbo_files[descendant] = desc_path
 
1358
 
 
1359
    def _limbo_descendants(self, trans_id):
 
1360
        """Return the set of trans_ids whose limbo paths descend from this."""
 
1361
        descendants = set(self._limbo_children.get(trans_id, []))
 
1362
        for descendant in list(descendants):
 
1363
            descendants.update(self._limbo_descendants(descendant))
 
1364
        return descendants
 
1365
 
 
1366
    def create_file(self, contents, trans_id, mode_id=None, sha1=None):
 
1367
        """Schedule creation of a new file.
 
1368
 
 
1369
        :seealso: new_file.
 
1370
 
 
1371
        :param contents: an iterator of strings, all of which will be written
 
1372
            to the target destination.
 
1373
        :param trans_id: TreeTransform handle
 
1374
        :param mode_id: If not None, force the mode of the target file to match
 
1375
            the mode of the object referenced by mode_id.
 
1376
            Otherwise, we will try to preserve mode bits of an existing file.
 
1377
        :param sha1: If the sha1 of this content is already known, pass it in.
 
1378
            We can use it to prevent future sha1 computations.
 
1379
        """
 
1380
        name = self._limbo_name(trans_id)
 
1381
        with open(name, 'wb') as f:
 
1382
            unique_add(self._new_contents, trans_id, 'file')
 
1383
            f.writelines(contents)
 
1384
        self._set_mtime(name)
 
1385
        self._set_mode(trans_id, mode_id, S_ISREG)
 
1386
        # It is unfortunate we have to use lstat instead of fstat, but we just
 
1387
        # used utime and chmod on the file, so we need the accurate final
 
1388
        # details.
 
1389
        if sha1 is not None:
 
1390
            self._observed_sha1s[trans_id] = (sha1, osutils.lstat(name))
 
1391
 
 
1392
    def _read_symlink_target(self, trans_id):
 
1393
        return os.readlink(self._limbo_name(trans_id))
 
1394
 
 
1395
    def _set_mtime(self, path):
 
1396
        """All files that are created get the same mtime.
 
1397
 
 
1398
        This time is set by the first object to be created.
 
1399
        """
 
1400
        if self._creation_mtime is None:
 
1401
            self._creation_mtime = time.time()
 
1402
        os.utime(path, (self._creation_mtime, self._creation_mtime))
 
1403
 
 
1404
    def create_hardlink(self, path, trans_id):
 
1405
        """Schedule creation of a hard link"""
 
1406
        name = self._limbo_name(trans_id)
 
1407
        try:
 
1408
            os.link(path, name)
 
1409
        except OSError as e:
 
1410
            if e.errno != errno.EPERM:
 
1411
                raise
 
1412
            raise errors.HardLinkNotSupported(path)
 
1413
        try:
 
1414
            unique_add(self._new_contents, trans_id, 'file')
 
1415
        except BaseException:
 
1416
            # Clean up the file, it never got registered so
 
1417
            # TreeTransform.finalize() won't clean it up.
 
1418
            os.unlink(name)
 
1419
            raise
 
1420
 
 
1421
    def create_directory(self, trans_id):
 
1422
        """Schedule creation of a new directory.
 
1423
 
 
1424
        See also new_directory.
 
1425
        """
 
1426
        os.mkdir(self._limbo_name(trans_id))
 
1427
        unique_add(self._new_contents, trans_id, 'directory')
 
1428
 
 
1429
    def create_symlink(self, target, trans_id):
 
1430
        """Schedule creation of a new symbolic link.
 
1431
 
 
1432
        target is a bytestring.
 
1433
        See also new_symlink.
 
1434
        """
 
1435
        if self._create_symlinks:
 
1436
            os.symlink(target, self._limbo_name(trans_id))
 
1437
        else:
 
1438
            try:
 
1439
                path = FinalPaths(self).get_path(trans_id)
 
1440
            except KeyError:
 
1441
                path = None
 
1442
            trace.warning(
 
1443
                'Unable to create symlink "%s" on this filesystem.' % (path,))
 
1444
        # We add symlink to _new_contents even if they are unsupported
 
1445
        # and not created. These entries are subsequently used to avoid
 
1446
        # conflicts on platforms that don't support symlink
 
1447
        unique_add(self._new_contents, trans_id, 'symlink')
 
1448
 
 
1449
    def cancel_creation(self, trans_id):
 
1450
        """Cancel the creation of new file contents."""
 
1451
        del self._new_contents[trans_id]
 
1452
        if trans_id in self._observed_sha1s:
 
1453
            del self._observed_sha1s[trans_id]
 
1454
        children = self._limbo_children.get(trans_id)
 
1455
        # if this is a limbo directory with children, move them before removing
 
1456
        # the directory
 
1457
        if children is not None:
 
1458
            self._rename_in_limbo(children)
 
1459
            del self._limbo_children[trans_id]
 
1460
            del self._limbo_children_names[trans_id]
 
1461
        delete_any(self._limbo_name(trans_id))
 
1462
 
 
1463
    def new_orphan(self, trans_id, parent_id):
 
1464
        conf = self._tree.get_config_stack()
 
1465
        handle_orphan = conf.get('transform.orphan_policy')
 
1466
        handle_orphan(self, trans_id, parent_id)
 
1467
 
 
1468
 
528
1469
class OrphaningError(errors.BzrError):
529
1470
 
530
1471
    # Only bugs could lead to such exception being seen by the user
596
1537
    invalid='warning')
597
1538
 
598
1539
 
 
1540
class TreeTransform(DiskTreeTransform):
 
1541
    """Represent a tree transformation.
 
1542
 
 
1543
    This object is designed to support incremental generation of the transform,
 
1544
    in any order.
 
1545
 
 
1546
    However, it gives optimum performance when parent directories are created
 
1547
    before their contents.  The transform is then able to put child files
 
1548
    directly in their parent directory, avoiding later renames.
 
1549
 
 
1550
    It is easy to produce malformed transforms, but they are generally
 
1551
    harmless.  Attempting to apply a malformed transform will cause an
 
1552
    exception to be raised before any modifications are made to the tree.
 
1553
 
 
1554
    Many kinds of malformed transforms can be corrected with the
 
1555
    resolve_conflicts function.  The remaining ones indicate programming error,
 
1556
    such as trying to create a file with no path.
 
1557
 
 
1558
    Two sets of file creation methods are supplied.  Convenience methods are:
 
1559
     * new_file
 
1560
     * new_directory
 
1561
     * new_symlink
 
1562
 
 
1563
    These are composed of the low-level methods:
 
1564
     * create_path
 
1565
     * create_file or create_directory or create_symlink
 
1566
     * version_file
 
1567
     * set_executability
 
1568
 
 
1569
    Transform/Transaction ids
 
1570
    -------------------------
 
1571
    trans_ids are temporary ids assigned to all files involved in a transform.
 
1572
    It's possible, even common, that not all files in the Tree have trans_ids.
 
1573
 
 
1574
    trans_ids are used because filenames and file_ids are not good enough
 
1575
    identifiers; filenames change, and not all files have file_ids.  File-ids
 
1576
    are also associated with trans-ids, so that moving a file moves its
 
1577
    file-id.
 
1578
 
 
1579
    trans_ids are only valid for the TreeTransform that generated them.
 
1580
 
 
1581
    Limbo
 
1582
    -----
 
1583
    Limbo is a temporary directory use to hold new versions of files.
 
1584
    Files are added to limbo by create_file, create_directory, create_symlink,
 
1585
    and their convenience variants (new_*).  Files may be removed from limbo
 
1586
    using cancel_creation.  Files are renamed from limbo into their final
 
1587
    location as part of TreeTransform.apply
 
1588
 
 
1589
    Limbo must be cleaned up, by either calling TreeTransform.apply or
 
1590
    calling TreeTransform.finalize.
 
1591
 
 
1592
    Files are placed into limbo inside their parent directories, where
 
1593
    possible.  This reduces subsequent renames, and makes operations involving
 
1594
    lots of files faster.  This optimization is only possible if the parent
 
1595
    directory is created *before* creating any of its children, so avoid
 
1596
    creating children before parents, where possible.
 
1597
 
 
1598
    Pending-deletion
 
1599
    ----------------
 
1600
    This temporary directory is used by _FileMover for storing files that are
 
1601
    about to be deleted.  In case of rollback, the files will be restored.
 
1602
    FileMover does not delete files until it is sure that a rollback will not
 
1603
    happen.
 
1604
    """
 
1605
 
 
1606
    def __init__(self, tree, pb=None):
 
1607
        """Note: a tree_write lock is taken on the tree.
 
1608
 
 
1609
        Use TreeTransform.finalize() to release the lock (can be omitted if
 
1610
        TreeTransform.apply() called).
 
1611
        """
 
1612
        tree.lock_tree_write()
 
1613
        try:
 
1614
            limbodir = urlutils.local_path_from_url(
 
1615
                tree._transport.abspath('limbo'))
 
1616
            osutils.ensure_empty_directory_exists(
 
1617
                limbodir,
 
1618
                errors.ExistingLimbo)
 
1619
            deletiondir = urlutils.local_path_from_url(
 
1620
                tree._transport.abspath('pending-deletion'))
 
1621
            osutils.ensure_empty_directory_exists(
 
1622
                deletiondir,
 
1623
                errors.ExistingPendingDeletion)
 
1624
        except BaseException:
 
1625
            tree.unlock()
 
1626
            raise
 
1627
 
 
1628
        # Cache of realpath results, to speed up canonical_path
 
1629
        self._realpaths = {}
 
1630
        # Cache of relpath results, to speed up canonical_path
 
1631
        self._relpaths = {}
 
1632
        DiskTreeTransform.__init__(self, tree, limbodir, pb,
 
1633
                                   tree.case_sensitive)
 
1634
        self._deletiondir = deletiondir
 
1635
 
 
1636
    def canonical_path(self, path):
 
1637
        """Get the canonical tree-relative path"""
 
1638
        # don't follow final symlinks
 
1639
        abs = self._tree.abspath(path)
 
1640
        if abs in self._relpaths:
 
1641
            return self._relpaths[abs]
 
1642
        dirname, basename = os.path.split(abs)
 
1643
        if dirname not in self._realpaths:
 
1644
            self._realpaths[dirname] = os.path.realpath(dirname)
 
1645
        dirname = self._realpaths[dirname]
 
1646
        abs = pathjoin(dirname, basename)
 
1647
        if dirname in self._relpaths:
 
1648
            relpath = pathjoin(self._relpaths[dirname], basename)
 
1649
            relpath = relpath.rstrip('/\\')
 
1650
        else:
 
1651
            relpath = self._tree.relpath(abs)
 
1652
        self._relpaths[abs] = relpath
 
1653
        return relpath
 
1654
 
 
1655
    def tree_kind(self, trans_id):
 
1656
        """Determine the file kind in the working tree.
 
1657
 
 
1658
        :returns: The file kind or None if the file does not exist
 
1659
        """
 
1660
        path = self._tree_id_paths.get(trans_id)
 
1661
        if path is None:
 
1662
            return None
 
1663
        try:
 
1664
            return file_kind(self._tree.abspath(path))
 
1665
        except errors.NoSuchFile:
 
1666
            return None
 
1667
 
 
1668
    def _set_mode(self, trans_id, mode_id, typefunc):
 
1669
        """Set the mode of new file contents.
 
1670
        The mode_id is the existing file to get the mode from (often the same
 
1671
        as trans_id).  The operation is only performed if there's a mode match
 
1672
        according to typefunc.
 
1673
        """
 
1674
        if mode_id is None:
 
1675
            mode_id = trans_id
 
1676
        try:
 
1677
            old_path = self._tree_id_paths[mode_id]
 
1678
        except KeyError:
 
1679
            return
 
1680
        try:
 
1681
            mode = os.stat(self._tree.abspath(old_path)).st_mode
 
1682
        except OSError as e:
 
1683
            if e.errno in (errno.ENOENT, errno.ENOTDIR):
 
1684
                # Either old_path doesn't exist, or the parent of the
 
1685
                # target is not a directory (but will be one eventually)
 
1686
                # Either way, we know it doesn't exist *right now*
 
1687
                # See also bug #248448
 
1688
                return
 
1689
            else:
 
1690
                raise
 
1691
        if typefunc(mode):
 
1692
            osutils.chmod_if_possible(self._limbo_name(trans_id), mode)
 
1693
 
 
1694
    def iter_tree_children(self, parent_id):
 
1695
        """Iterate through the entry's tree children, if any"""
 
1696
        try:
 
1697
            path = self._tree_id_paths[parent_id]
 
1698
        except KeyError:
 
1699
            return
 
1700
        try:
 
1701
            children = os.listdir(self._tree.abspath(path))
 
1702
        except OSError as e:
 
1703
            if not (osutils._is_error_enotdir(e) or
 
1704
                    e.errno in (errno.ENOENT, errno.ESRCH)):
 
1705
                raise
 
1706
            return
 
1707
 
 
1708
        for child in children:
 
1709
            childpath = joinpath(path, child)
 
1710
            if self._tree.is_control_filename(childpath):
 
1711
                continue
 
1712
            yield self.trans_id_tree_path(childpath)
 
1713
 
 
1714
    def _generate_limbo_path(self, trans_id):
 
1715
        """Generate a limbo path using the final path if possible.
 
1716
 
 
1717
        This optimizes the performance of applying the tree transform by
 
1718
        avoiding renames.  These renames can be avoided only when the parent
 
1719
        directory is already scheduled for creation.
 
1720
 
 
1721
        If the final path cannot be used, falls back to using the trans_id as
 
1722
        the relpath.
 
1723
        """
 
1724
        parent = self._new_parent.get(trans_id)
 
1725
        # if the parent directory is already in limbo (e.g. when building a
 
1726
        # tree), choose a limbo name inside the parent, to reduce further
 
1727
        # renames.
 
1728
        use_direct_path = False
 
1729
        if self._new_contents.get(parent) == 'directory':
 
1730
            filename = self._new_name.get(trans_id)
 
1731
            if filename is not None:
 
1732
                if parent not in self._limbo_children:
 
1733
                    self._limbo_children[parent] = set()
 
1734
                    self._limbo_children_names[parent] = {}
 
1735
                    use_direct_path = True
 
1736
                # the direct path can only be used if no other file has
 
1737
                # already taken this pathname, i.e. if the name is unused, or
 
1738
                # if it is already associated with this trans_id.
 
1739
                elif self._case_sensitive_target:
 
1740
                    if (self._limbo_children_names[parent].get(filename)
 
1741
                            in (trans_id, None)):
 
1742
                        use_direct_path = True
 
1743
                else:
 
1744
                    for l_filename, l_trans_id in (
 
1745
                            self._limbo_children_names[parent].items()):
 
1746
                        if l_trans_id == trans_id:
 
1747
                            continue
 
1748
                        if l_filename.lower() == filename.lower():
 
1749
                            break
 
1750
                    else:
 
1751
                        use_direct_path = True
 
1752
 
 
1753
        if not use_direct_path:
 
1754
            return DiskTreeTransform._generate_limbo_path(self, trans_id)
 
1755
 
 
1756
        limbo_name = pathjoin(self._limbo_files[parent], filename)
 
1757
        self._limbo_children[parent].add(trans_id)
 
1758
        self._limbo_children_names[parent][filename] = trans_id
 
1759
        return limbo_name
 
1760
 
 
1761
    def apply(self, no_conflicts=False, precomputed_delta=None, _mover=None):
 
1762
        """Apply all changes to the inventory and filesystem.
 
1763
 
 
1764
        If filesystem or inventory conflicts are present, MalformedTransform
 
1765
        will be thrown.
 
1766
 
 
1767
        If apply succeeds, finalize is not necessary.
 
1768
 
 
1769
        :param no_conflicts: if True, the caller guarantees there are no
 
1770
            conflicts, so no check is made.
 
1771
        :param precomputed_delta: An inventory delta to use instead of
 
1772
            calculating one.
 
1773
        :param _mover: Supply an alternate FileMover, for testing
 
1774
        """
 
1775
        for hook in MutableTree.hooks['pre_transform']:
 
1776
            hook(self._tree, self)
 
1777
        if not no_conflicts:
 
1778
            self._check_malformed()
 
1779
        with ui.ui_factory.nested_progress_bar() as child_pb:
 
1780
            if precomputed_delta is None:
 
1781
                child_pb.update(gettext('Apply phase'), 0, 2)
 
1782
                inventory_delta = self._generate_inventory_delta()
 
1783
                offset = 1
 
1784
            else:
 
1785
                inventory_delta = precomputed_delta
 
1786
                offset = 0
 
1787
            if _mover is None:
 
1788
                mover = _FileMover()
 
1789
            else:
 
1790
                mover = _mover
 
1791
            try:
 
1792
                child_pb.update(gettext('Apply phase'), 0 + offset, 2 + offset)
 
1793
                self._apply_removals(mover)
 
1794
                child_pb.update(gettext('Apply phase'), 1 + offset, 2 + offset)
 
1795
                modified_paths = self._apply_insertions(mover)
 
1796
            except BaseException:
 
1797
                mover.rollback()
 
1798
                raise
 
1799
            else:
 
1800
                mover.apply_deletions()
 
1801
        if self.final_file_id(self.root) is None:
 
1802
            inventory_delta = [e for e in inventory_delta if e[0] != '']
 
1803
        self._tree.apply_inventory_delta(inventory_delta)
 
1804
        self._apply_observed_sha1s()
 
1805
        self._done = True
 
1806
        self.finalize()
 
1807
        return _TransformResults(modified_paths, self.rename_count)
 
1808
 
 
1809
    def _generate_inventory_delta(self):
 
1810
        """Generate an inventory delta for the current transform."""
 
1811
        inventory_delta = []
 
1812
        new_paths = self._inventory_altered()
 
1813
        total_entries = len(new_paths) + len(self._removed_id)
 
1814
        with ui.ui_factory.nested_progress_bar() as child_pb:
 
1815
            for num, trans_id in enumerate(self._removed_id):
 
1816
                if (num % 10) == 0:
 
1817
                    child_pb.update(gettext('removing file'),
 
1818
                                    num, total_entries)
 
1819
                if trans_id == self._new_root:
 
1820
                    file_id = self._tree.path2id('')
 
1821
                else:
 
1822
                    file_id = self.tree_file_id(trans_id)
 
1823
                # File-id isn't really being deleted, just moved
 
1824
                if file_id in self._r_new_id:
 
1825
                    continue
 
1826
                path = self._tree_id_paths[trans_id]
 
1827
                inventory_delta.append((path, None, file_id, None))
 
1828
            new_path_file_ids = dict((t, self.final_file_id(t)) for p, t in
 
1829
                                     new_paths)
 
1830
            for num, (path, trans_id) in enumerate(new_paths):
 
1831
                if (num % 10) == 0:
 
1832
                    child_pb.update(gettext('adding file'),
 
1833
                                    num + len(self._removed_id), total_entries)
 
1834
                file_id = new_path_file_ids[trans_id]
 
1835
                if file_id is None:
 
1836
                    continue
 
1837
                kind = self.final_kind(trans_id)
 
1838
                if kind is None:
 
1839
                    kind = self._tree.stored_kind(self._tree.id2path(file_id))
 
1840
                parent_trans_id = self.final_parent(trans_id)
 
1841
                parent_file_id = new_path_file_ids.get(parent_trans_id)
 
1842
                if parent_file_id is None:
 
1843
                    parent_file_id = self.final_file_id(parent_trans_id)
 
1844
                if trans_id in self._new_reference_revision:
 
1845
                    new_entry = inventory.TreeReference(
 
1846
                        file_id,
 
1847
                        self._new_name[trans_id],
 
1848
                        self.final_file_id(self._new_parent[trans_id]),
 
1849
                        None, self._new_reference_revision[trans_id])
 
1850
                else:
 
1851
                    new_entry = inventory.make_entry(kind,
 
1852
                                                     self.final_name(trans_id),
 
1853
                                                     parent_file_id, file_id)
 
1854
                try:
 
1855
                    old_path = self._tree.id2path(new_entry.file_id)
 
1856
                except errors.NoSuchId:
 
1857
                    old_path = None
 
1858
                new_executability = self._new_executability.get(trans_id)
 
1859
                if new_executability is not None:
 
1860
                    new_entry.executable = new_executability
 
1861
                inventory_delta.append(
 
1862
                    (old_path, path, new_entry.file_id, new_entry))
 
1863
        return inventory_delta
 
1864
 
 
1865
    def _apply_removals(self, mover):
 
1866
        """Perform tree operations that remove directory/inventory names.
 
1867
 
 
1868
        That is, delete files that are to be deleted, and put any files that
 
1869
        need renaming into limbo.  This must be done in strict child-to-parent
 
1870
        order.
 
1871
 
 
1872
        If inventory_delta is None, no inventory delta generation is performed.
 
1873
        """
 
1874
        tree_paths = sorted(self._tree_path_ids.items(), reverse=True)
 
1875
        with ui.ui_factory.nested_progress_bar() as child_pb:
 
1876
            for num, (path, trans_id) in enumerate(tree_paths):
 
1877
                # do not attempt to move root into a subdirectory of itself.
 
1878
                if path == '':
 
1879
                    continue
 
1880
                child_pb.update(gettext('removing file'), num, len(tree_paths))
 
1881
                full_path = self._tree.abspath(path)
 
1882
                if trans_id in self._removed_contents:
 
1883
                    delete_path = os.path.join(self._deletiondir, trans_id)
 
1884
                    mover.pre_delete(full_path, delete_path)
 
1885
                elif (trans_id in self._new_name or
 
1886
                      trans_id in self._new_parent):
 
1887
                    try:
 
1888
                        mover.rename(full_path, self._limbo_name(trans_id))
 
1889
                    except errors.TransformRenameFailed as e:
 
1890
                        if e.errno != errno.ENOENT:
 
1891
                            raise
 
1892
                    else:
 
1893
                        self.rename_count += 1
 
1894
 
 
1895
    def _apply_insertions(self, mover):
 
1896
        """Perform tree operations that insert directory/inventory names.
 
1897
 
 
1898
        That is, create any files that need to be created, and restore from
 
1899
        limbo any files that needed renaming.  This must be done in strict
 
1900
        parent-to-child order.
 
1901
 
 
1902
        If inventory_delta is None, no inventory delta is calculated, and
 
1903
        no list of modified paths is returned.
 
1904
        """
 
1905
        new_paths = self.new_paths(filesystem_only=True)
 
1906
        modified_paths = []
 
1907
        with ui.ui_factory.nested_progress_bar() as child_pb:
 
1908
            for num, (path, trans_id) in enumerate(new_paths):
 
1909
                if (num % 10) == 0:
 
1910
                    child_pb.update(gettext('adding file'),
 
1911
                                    num, len(new_paths))
 
1912
                full_path = self._tree.abspath(path)
 
1913
                if trans_id in self._needs_rename:
 
1914
                    try:
 
1915
                        mover.rename(self._limbo_name(trans_id), full_path)
 
1916
                    except errors.TransformRenameFailed as e:
 
1917
                        # We may be renaming a dangling inventory id
 
1918
                        if e.errno != errno.ENOENT:
 
1919
                            raise
 
1920
                    else:
 
1921
                        self.rename_count += 1
 
1922
                    # TODO: if trans_id in self._observed_sha1s, we should
 
1923
                    #       re-stat the final target, since ctime will be
 
1924
                    #       updated by the change.
 
1925
                if (trans_id in self._new_contents
 
1926
                        or self.path_changed(trans_id)):
 
1927
                    if trans_id in self._new_contents:
 
1928
                        modified_paths.append(full_path)
 
1929
                if trans_id in self._new_executability:
 
1930
                    self._set_executability(path, trans_id)
 
1931
                if trans_id in self._observed_sha1s:
 
1932
                    o_sha1, o_st_val = self._observed_sha1s[trans_id]
 
1933
                    st = osutils.lstat(full_path)
 
1934
                    self._observed_sha1s[trans_id] = (o_sha1, st)
 
1935
        for path, trans_id in new_paths:
 
1936
            # new_paths includes stuff like workingtree conflicts. Only the
 
1937
            # stuff in new_contents actually comes from limbo.
 
1938
            if trans_id in self._limbo_files:
 
1939
                del self._limbo_files[trans_id]
 
1940
        self._new_contents.clear()
 
1941
        return modified_paths
 
1942
 
 
1943
    def _apply_observed_sha1s(self):
 
1944
        """After we have finished renaming everything, update observed sha1s
 
1945
 
 
1946
        This has to be done after self._tree.apply_inventory_delta, otherwise
 
1947
        it doesn't know anything about the files we are updating. Also, we want
 
1948
        to do this as late as possible, so that most entries end up cached.
 
1949
        """
 
1950
        # TODO: this doesn't update the stat information for directories. So
 
1951
        #       the first 'bzr status' will still need to rewrite
 
1952
        #       .bzr/checkout/dirstate. However, we at least don't need to
 
1953
        #       re-read all of the files.
 
1954
        # TODO: If the operation took a while, we could do a time.sleep(3) here
 
1955
        #       to allow the clock to tick over and ensure we won't have any
 
1956
        #       problems. (we could observe start time, and finish time, and if
 
1957
        #       it is less than eg 10% overhead, add a sleep call.)
 
1958
        paths = FinalPaths(self)
 
1959
        for trans_id, observed in self._observed_sha1s.items():
 
1960
            path = paths.get_path(trans_id)
 
1961
            self._tree._observed_sha1(path, observed)
 
1962
 
 
1963
 
 
1964
class TransformPreview(DiskTreeTransform):
 
1965
    """A TreeTransform for generating preview trees.
 
1966
 
 
1967
    Unlike TreeTransform, this version works when the input tree is a
 
1968
    RevisionTree, rather than a WorkingTree.  As a result, it tends to ignore
 
1969
    unversioned files in the input tree.
 
1970
    """
 
1971
 
 
1972
    def __init__(self, tree, pb=None, case_sensitive=True):
 
1973
        tree.lock_read()
 
1974
        limbodir = osutils.mkdtemp(prefix='bzr-limbo-')
 
1975
        DiskTreeTransform.__init__(self, tree, limbodir, pb, case_sensitive)
 
1976
 
 
1977
    def canonical_path(self, path):
 
1978
        return path
 
1979
 
 
1980
    def tree_kind(self, trans_id):
 
1981
        path = self._tree_id_paths.get(trans_id)
 
1982
        if path is None:
 
1983
            return None
 
1984
        kind = self._tree.path_content_summary(path)[0]
 
1985
        if kind == 'missing':
 
1986
            kind = None
 
1987
        return kind
 
1988
 
 
1989
    def _set_mode(self, trans_id, mode_id, typefunc):
 
1990
        """Set the mode of new file contents.
 
1991
        The mode_id is the existing file to get the mode from (often the same
 
1992
        as trans_id).  The operation is only performed if there's a mode match
 
1993
        according to typefunc.
 
1994
        """
 
1995
        # is it ok to ignore this?  probably
 
1996
        pass
 
1997
 
 
1998
    def iter_tree_children(self, parent_id):
 
1999
        """Iterate through the entry's tree children, if any"""
 
2000
        try:
 
2001
            path = self._tree_id_paths[parent_id]
 
2002
        except KeyError:
 
2003
            return
 
2004
        try:
 
2005
            entry = next(self._tree.iter_entries_by_dir(
 
2006
                specific_files=[path]))[1]
 
2007
        except StopIteration:
 
2008
            return
 
2009
        children = getattr(entry, 'children', {})
 
2010
        for child in children:
 
2011
            childpath = joinpath(path, child)
 
2012
            yield self.trans_id_tree_path(childpath)
 
2013
 
 
2014
    def new_orphan(self, trans_id, parent_id):
 
2015
        raise NotImplementedError(self.new_orphan)
 
2016
 
 
2017
 
 
2018
class _PreviewTree(inventorytree.InventoryTree):
 
2019
    """Partial implementation of Tree to support show_diff_trees"""
 
2020
 
 
2021
    def __init__(self, transform):
 
2022
        self._transform = transform
 
2023
        self._final_paths = FinalPaths(transform)
 
2024
        self.__by_parent = None
 
2025
        self._parent_ids = []
 
2026
        self._all_children_cache = {}
 
2027
        self._path2trans_id_cache = {}
 
2028
        self._final_name_cache = {}
 
2029
        self._iter_changes_cache = dict((c.file_id, c) for c in
 
2030
                                        self._transform.iter_changes())
 
2031
 
 
2032
    def supports_tree_reference(self):
 
2033
        # TODO(jelmer): Support tree references in _PreviewTree.
 
2034
        # return self._transform._tree.supports_tree_reference()
 
2035
        return False
 
2036
 
 
2037
    def _content_change(self, file_id):
 
2038
        """Return True if the content of this file changed"""
 
2039
        changes = self._iter_changes_cache.get(file_id)
 
2040
        return (changes is not None and changes.changed_content)
 
2041
 
 
2042
    def _get_repository(self):
 
2043
        repo = getattr(self._transform._tree, '_repository', None)
 
2044
        if repo is None:
 
2045
            repo = self._transform._tree.branch.repository
 
2046
        return repo
 
2047
 
 
2048
    def _iter_parent_trees(self):
 
2049
        for revision_id in self.get_parent_ids():
 
2050
            try:
 
2051
                yield self.revision_tree(revision_id)
 
2052
            except errors.NoSuchRevisionInTree:
 
2053
                yield self._get_repository().revision_tree(revision_id)
 
2054
 
 
2055
    def _get_file_revision(self, path, file_id, vf, tree_revision):
 
2056
        parent_keys = [
 
2057
            (file_id, t.get_file_revision(t.id2path(file_id)))
 
2058
            for t in self._iter_parent_trees()]
 
2059
        vf.add_lines((file_id, tree_revision), parent_keys,
 
2060
                     self.get_file_lines(path))
 
2061
        repo = self._get_repository()
 
2062
        base_vf = repo.texts
 
2063
        if base_vf not in vf.fallback_versionedfiles:
 
2064
            vf.fallback_versionedfiles.append(base_vf)
 
2065
        return tree_revision
 
2066
 
 
2067
    def _stat_limbo_file(self, trans_id):
 
2068
        name = self._transform._limbo_name(trans_id)
 
2069
        return os.lstat(name)
 
2070
 
 
2071
    @property
 
2072
    def _by_parent(self):
 
2073
        if self.__by_parent is None:
 
2074
            self.__by_parent = self._transform.by_parent()
 
2075
        return self.__by_parent
 
2076
 
 
2077
    def _comparison_data(self, entry, path):
 
2078
        kind, size, executable, link_or_sha1 = self.path_content_summary(path)
 
2079
        if kind == 'missing':
 
2080
            kind = None
 
2081
            executable = False
 
2082
        else:
 
2083
            file_id = self._transform.final_file_id(self._path2trans_id(path))
 
2084
            executable = self.is_executable(path)
 
2085
        return kind, executable, None
 
2086
 
 
2087
    def is_locked(self):
 
2088
        return False
 
2089
 
 
2090
    def lock_read(self):
 
2091
        # Perhaps in theory, this should lock the TreeTransform?
 
2092
        return lock.LogicalLockResult(self.unlock)
 
2093
 
 
2094
    def unlock(self):
 
2095
        pass
 
2096
 
 
2097
    @property
 
2098
    def root_inventory(self):
 
2099
        """This Tree does not use inventory as its backing data."""
 
2100
        raise NotImplementedError(_PreviewTree.root_inventory)
 
2101
 
 
2102
    def all_file_ids(self):
 
2103
        tree_ids = set(self._transform._tree.all_file_ids())
 
2104
        tree_ids.difference_update(self._transform.tree_file_id(t)
 
2105
                                   for t in self._transform._removed_id)
 
2106
        tree_ids.update(self._transform._new_id.values())
 
2107
        return tree_ids
 
2108
 
 
2109
    def all_versioned_paths(self):
 
2110
        tree_paths = set(self._transform._tree.all_versioned_paths())
 
2111
 
 
2112
        tree_paths.difference_update(
 
2113
            self._transform.trans_id_tree_path(t)
 
2114
            for t in self._transform._removed_id)
 
2115
 
 
2116
        tree_paths.update(
 
2117
            self._final_paths._determine_path(t)
 
2118
            for t in self._transform._new_id)
 
2119
 
 
2120
        return tree_paths
 
2121
 
 
2122
    def _path2trans_id(self, path):
 
2123
        # We must not use None here, because that is a valid value to store.
 
2124
        trans_id = self._path2trans_id_cache.get(path, object)
 
2125
        if trans_id is not object:
 
2126
            return trans_id
 
2127
        segments = splitpath(path)
 
2128
        cur_parent = self._transform.root
 
2129
        for cur_segment in segments:
 
2130
            for child in self._all_children(cur_parent):
 
2131
                final_name = self._final_name_cache.get(child)
 
2132
                if final_name is None:
 
2133
                    final_name = self._transform.final_name(child)
 
2134
                    self._final_name_cache[child] = final_name
 
2135
                if final_name == cur_segment:
 
2136
                    cur_parent = child
 
2137
                    break
 
2138
            else:
 
2139
                self._path2trans_id_cache[path] = None
 
2140
                return None
 
2141
        self._path2trans_id_cache[path] = cur_parent
 
2142
        return cur_parent
 
2143
 
 
2144
    def path2id(self, path):
 
2145
        if isinstance(path, list):
 
2146
            if path == []:
 
2147
                path = [""]
 
2148
            path = osutils.pathjoin(*path)
 
2149
        return self._transform.final_file_id(self._path2trans_id(path))
 
2150
 
 
2151
    def id2path(self, file_id, recurse='down'):
 
2152
        trans_id = self._transform.trans_id_file_id(file_id)
 
2153
        try:
 
2154
            return self._final_paths._determine_path(trans_id)
 
2155
        except NoFinalPath:
 
2156
            raise errors.NoSuchId(self, file_id)
 
2157
 
 
2158
    def _all_children(self, trans_id):
 
2159
        children = self._all_children_cache.get(trans_id)
 
2160
        if children is not None:
 
2161
            return children
 
2162
        children = set(self._transform.iter_tree_children(trans_id))
 
2163
        # children in the _new_parent set are provided by _by_parent.
 
2164
        children.difference_update(self._transform._new_parent)
 
2165
        children.update(self._by_parent.get(trans_id, []))
 
2166
        self._all_children_cache[trans_id] = children
 
2167
        return children
 
2168
 
 
2169
    def extras(self):
 
2170
        possible_extras = set(self._transform.trans_id_tree_path(p) for p
 
2171
                              in self._transform._tree.extras())
 
2172
        possible_extras.update(self._transform._new_contents)
 
2173
        possible_extras.update(self._transform._removed_id)
 
2174
        for trans_id in possible_extras:
 
2175
            if self._transform.final_file_id(trans_id) is None:
 
2176
                yield self._final_paths._determine_path(trans_id)
 
2177
 
 
2178
    def _make_inv_entries(self, ordered_entries, specific_files=None):
 
2179
        for trans_id, parent_file_id in ordered_entries:
 
2180
            file_id = self._transform.final_file_id(trans_id)
 
2181
            if file_id is None:
 
2182
                continue
 
2183
            if (specific_files is not None
 
2184
                    and self._final_paths.get_path(trans_id) not in specific_files):
 
2185
                continue
 
2186
            kind = self._transform.final_kind(trans_id)
 
2187
            if kind is None:
 
2188
                kind = self._transform._tree.stored_kind(
 
2189
                    self._transform._tree.id2path(file_id))
 
2190
            new_entry = inventory.make_entry(
 
2191
                kind,
 
2192
                self._transform.final_name(trans_id),
 
2193
                parent_file_id, file_id)
 
2194
            yield new_entry, trans_id
 
2195
 
 
2196
    def _list_files_by_dir(self):
 
2197
        todo = [ROOT_PARENT]
 
2198
        ordered_ids = []
 
2199
        while len(todo) > 0:
 
2200
            parent = todo.pop()
 
2201
            parent_file_id = self._transform.final_file_id(parent)
 
2202
            children = list(self._all_children(parent))
 
2203
            paths = dict(zip(children, self._final_paths.get_paths(children)))
 
2204
            children.sort(key=paths.get)
 
2205
            todo.extend(reversed(children))
 
2206
            for trans_id in children:
 
2207
                ordered_ids.append((trans_id, parent_file_id))
 
2208
        return ordered_ids
 
2209
 
 
2210
    def iter_child_entries(self, path):
 
2211
        trans_id = self._path2trans_id(path)
 
2212
        if trans_id is None:
 
2213
            raise errors.NoSuchFile(path)
 
2214
        todo = [(child_trans_id, trans_id) for child_trans_id in
 
2215
                self._all_children(trans_id)]
 
2216
        for entry, trans_id in self._make_inv_entries(todo):
 
2217
            yield entry
 
2218
 
 
2219
    def iter_entries_by_dir(self, specific_files=None, recurse_nested=False):
 
2220
        if recurse_nested:
 
2221
            raise NotImplementedError(
 
2222
                'follow tree references not yet supported')
 
2223
 
 
2224
        # This may not be a maximally efficient implementation, but it is
 
2225
        # reasonably straightforward.  An implementation that grafts the
 
2226
        # TreeTransform changes onto the tree's iter_entries_by_dir results
 
2227
        # might be more efficient, but requires tricky inferences about stack
 
2228
        # position.
 
2229
        ordered_ids = self._list_files_by_dir()
 
2230
        for entry, trans_id in self._make_inv_entries(ordered_ids,
 
2231
                                                      specific_files):
 
2232
            yield self._final_paths.get_path(trans_id), entry
 
2233
 
 
2234
    def _iter_entries_for_dir(self, dir_path):
 
2235
        """Return path, entry for items in a directory without recursing down."""
 
2236
        ordered_ids = []
 
2237
        dir_trans_id = self._path2trans_id(dir_path)
 
2238
        dir_id = self._transform.final_file_id(dir_trans_id)
 
2239
        for child_trans_id in self._all_children(dir_trans_id):
 
2240
            ordered_ids.append((child_trans_id, dir_id))
 
2241
        path_entries = []
 
2242
        for entry, trans_id in self._make_inv_entries(ordered_ids):
 
2243
            path_entries.append((self._final_paths.get_path(trans_id), entry))
 
2244
        path_entries.sort()
 
2245
        return path_entries
 
2246
 
 
2247
    def list_files(self, include_root=False, from_dir=None, recursive=True,
 
2248
                   recurse_nested=False):
 
2249
        """See WorkingTree.list_files."""
 
2250
        if recurse_nested:
 
2251
            raise NotImplementedError(
 
2252
                'follow tree references not yet supported')
 
2253
 
 
2254
        # XXX This should behave like WorkingTree.list_files, but is really
 
2255
        # more like RevisionTree.list_files.
 
2256
        if from_dir == '.':
 
2257
            from_dir = None
 
2258
        if recursive:
 
2259
            prefix = None
 
2260
            if from_dir:
 
2261
                prefix = from_dir + '/'
 
2262
            entries = self.iter_entries_by_dir()
 
2263
            for path, entry in entries:
 
2264
                if entry.name == '' and not include_root:
 
2265
                    continue
 
2266
                if prefix:
 
2267
                    if not path.startswith(prefix):
 
2268
                        continue
 
2269
                    path = path[len(prefix):]
 
2270
                yield path, 'V', entry.kind, entry
 
2271
        else:
 
2272
            if from_dir is None and include_root is True:
 
2273
                root_entry = inventory.make_entry(
 
2274
                    'directory', '', ROOT_PARENT, self.path2id(''))
 
2275
                yield '', 'V', 'directory', root_entry
 
2276
            entries = self._iter_entries_for_dir(from_dir or '')
 
2277
            for path, entry in entries:
 
2278
                yield path, 'V', entry.kind, entry
 
2279
 
 
2280
    def kind(self, path):
 
2281
        trans_id = self._path2trans_id(path)
 
2282
        if trans_id is None:
 
2283
            raise errors.NoSuchFile(path)
 
2284
        return self._transform.final_kind(trans_id)
 
2285
 
 
2286
    def stored_kind(self, path):
 
2287
        trans_id = self._path2trans_id(path)
 
2288
        if trans_id is None:
 
2289
            raise errors.NoSuchFile(path)
 
2290
        try:
 
2291
            return self._transform._new_contents[trans_id]
 
2292
        except KeyError:
 
2293
            return self._transform._tree.stored_kind(path)
 
2294
 
 
2295
    def get_file_mtime(self, path):
 
2296
        """See Tree.get_file_mtime"""
 
2297
        file_id = self.path2id(path)
 
2298
        if file_id is None:
 
2299
            raise errors.NoSuchFile(path)
 
2300
        if not self._content_change(file_id):
 
2301
            return self._transform._tree.get_file_mtime(
 
2302
                self._transform._tree.id2path(file_id))
 
2303
        trans_id = self._path2trans_id(path)
 
2304
        return self._stat_limbo_file(trans_id).st_mtime
 
2305
 
 
2306
    def get_file_size(self, path):
 
2307
        """See Tree.get_file_size"""
 
2308
        trans_id = self._path2trans_id(path)
 
2309
        if trans_id is None:
 
2310
            raise errors.NoSuchFile(path)
 
2311
        kind = self._transform.final_kind(trans_id)
 
2312
        if kind != 'file':
 
2313
            return None
 
2314
        if trans_id in self._transform._new_contents:
 
2315
            return self._stat_limbo_file(trans_id).st_size
 
2316
        if self.kind(path) == 'file':
 
2317
            return self._transform._tree.get_file_size(path)
 
2318
        else:
 
2319
            return None
 
2320
 
 
2321
    def get_file_verifier(self, path, stat_value=None):
 
2322
        trans_id = self._path2trans_id(path)
 
2323
        if trans_id is None:
 
2324
            raise errors.NoSuchFile(path)
 
2325
        kind = self._transform._new_contents.get(trans_id)
 
2326
        if kind is None:
 
2327
            return self._transform._tree.get_file_verifier(path)
 
2328
        if kind == 'file':
 
2329
            with self.get_file(path) as fileobj:
 
2330
                return ("SHA1", sha_file(fileobj))
 
2331
 
 
2332
    def get_file_sha1(self, path, stat_value=None):
 
2333
        trans_id = self._path2trans_id(path)
 
2334
        if trans_id is None:
 
2335
            raise errors.NoSuchFile(path)
 
2336
        kind = self._transform._new_contents.get(trans_id)
 
2337
        if kind is None:
 
2338
            return self._transform._tree.get_file_sha1(path)
 
2339
        if kind == 'file':
 
2340
            with self.get_file(path) as fileobj:
 
2341
                return sha_file(fileobj)
 
2342
 
 
2343
    def get_reference_revision(self, path):
 
2344
        trans_id = self._path2trans_id(path)
 
2345
        if trans_id is None:
 
2346
            raise errors.NoSuchFile(path)
 
2347
        reference_revision = self._transform._new_reference_revision.get(trans_id)
 
2348
        if reference_revision is None:
 
2349
            return self._transform._tree.get_reference_revision(path)
 
2350
        return reference_revision
 
2351
 
 
2352
    def is_executable(self, path):
 
2353
        trans_id = self._path2trans_id(path)
 
2354
        if trans_id is None:
 
2355
            return False
 
2356
        try:
 
2357
            return self._transform._new_executability[trans_id]
 
2358
        except KeyError:
 
2359
            try:
 
2360
                return self._transform._tree.is_executable(path)
 
2361
            except OSError as e:
 
2362
                if e.errno == errno.ENOENT:
 
2363
                    return False
 
2364
                raise
 
2365
            except errors.NoSuchFile:
 
2366
                return False
 
2367
 
 
2368
    def has_filename(self, path):
 
2369
        trans_id = self._path2trans_id(path)
 
2370
        if trans_id in self._transform._new_contents:
 
2371
            return True
 
2372
        elif trans_id in self._transform._removed_contents:
 
2373
            return False
 
2374
        else:
 
2375
            return self._transform._tree.has_filename(path)
 
2376
 
 
2377
    def path_content_summary(self, path):
 
2378
        trans_id = self._path2trans_id(path)
 
2379
        tt = self._transform
 
2380
        tree_path = tt._tree_id_paths.get(trans_id)
 
2381
        kind = tt._new_contents.get(trans_id)
 
2382
        if kind is None:
 
2383
            if tree_path is None or trans_id in tt._removed_contents:
 
2384
                return 'missing', None, None, None
 
2385
            summary = tt._tree.path_content_summary(tree_path)
 
2386
            kind, size, executable, link_or_sha1 = summary
 
2387
        else:
 
2388
            link_or_sha1 = None
 
2389
            limbo_name = tt._limbo_name(trans_id)
 
2390
            if trans_id in tt._new_reference_revision:
 
2391
                kind = 'tree-reference'
 
2392
            if kind == 'file':
 
2393
                statval = os.lstat(limbo_name)
 
2394
                size = statval.st_size
 
2395
                if not tt._limbo_supports_executable():
 
2396
                    executable = False
 
2397
                else:
 
2398
                    executable = statval.st_mode & S_IEXEC
 
2399
            else:
 
2400
                size = None
 
2401
                executable = None
 
2402
            if kind == 'symlink':
 
2403
                link_or_sha1 = os.readlink(limbo_name)
 
2404
                if not isinstance(link_or_sha1, str):
 
2405
                    link_or_sha1 = link_or_sha1.decode(osutils._fs_enc)
 
2406
        executable = tt._new_executability.get(trans_id, executable)
 
2407
        return kind, size, executable, link_or_sha1
 
2408
 
 
2409
    def iter_changes(self, from_tree, include_unchanged=False,
 
2410
                     specific_files=None, pb=None, extra_trees=None,
 
2411
                     require_versioned=True, want_unversioned=False):
 
2412
        """See InterTree.iter_changes.
 
2413
 
 
2414
        This has a fast path that is only used when the from_tree matches
 
2415
        the transform tree, and no fancy options are supplied.
 
2416
        """
 
2417
        if (from_tree is not self._transform._tree or include_unchanged
 
2418
                or specific_files or want_unversioned):
 
2419
            return tree.InterTree(from_tree, self).iter_changes(
 
2420
                include_unchanged=include_unchanged,
 
2421
                specific_files=specific_files,
 
2422
                pb=pb,
 
2423
                extra_trees=extra_trees,
 
2424
                require_versioned=require_versioned,
 
2425
                want_unversioned=want_unversioned)
 
2426
        if want_unversioned:
 
2427
            raise ValueError('want_unversioned is not supported')
 
2428
        return self._transform.iter_changes()
 
2429
 
 
2430
    def get_file(self, path):
 
2431
        """See Tree.get_file"""
 
2432
        file_id = self.path2id(path)
 
2433
        if not self._content_change(file_id):
 
2434
            return self._transform._tree.get_file(path)
 
2435
        trans_id = self._path2trans_id(path)
 
2436
        name = self._transform._limbo_name(trans_id)
 
2437
        return open(name, 'rb')
 
2438
 
 
2439
    def get_file_with_stat(self, path):
 
2440
        return self.get_file(path), None
 
2441
 
 
2442
    def annotate_iter(self, path,
 
2443
                      default_revision=_mod_revision.CURRENT_REVISION):
 
2444
        file_id = self.path2id(path)
 
2445
        changes = self._iter_changes_cache.get(file_id)
 
2446
        if changes is None:
 
2447
            get_old = True
 
2448
        else:
 
2449
            changed_content, versioned, kind = (
 
2450
                changes.changed_content, changes.versioned, changes.kind)
 
2451
            if kind[1] is None:
 
2452
                return None
 
2453
            get_old = (kind[0] == 'file' and versioned[0])
 
2454
        if get_old:
 
2455
            old_annotation = self._transform._tree.annotate_iter(
 
2456
                path, default_revision=default_revision)
 
2457
        else:
 
2458
            old_annotation = []
 
2459
        if changes is None:
 
2460
            return old_annotation
 
2461
        if not changed_content:
 
2462
            return old_annotation
 
2463
        # TODO: This is doing something similar to what WT.annotate_iter is
 
2464
        #       doing, however it fails slightly because it doesn't know what
 
2465
        #       the *other* revision_id is, so it doesn't know how to give the
 
2466
        #       other as the origin for some lines, they all get
 
2467
        #       'default_revision'
 
2468
        #       It would be nice to be able to use the new Annotator based
 
2469
        #       approach, as well.
 
2470
        return annotate.reannotate([old_annotation],
 
2471
                                   self.get_file(path).readlines(),
 
2472
                                   default_revision)
 
2473
 
 
2474
    def get_symlink_target(self, path):
 
2475
        """See Tree.get_symlink_target"""
 
2476
        file_id = self.path2id(path)
 
2477
        if not self._content_change(file_id):
 
2478
            return self._transform._tree.get_symlink_target(path)
 
2479
        trans_id = self._path2trans_id(path)
 
2480
        name = self._transform._limbo_name(trans_id)
 
2481
        return osutils.readlink(name)
 
2482
 
 
2483
    def walkdirs(self, prefix=''):
 
2484
        pending = [self._transform.root]
 
2485
        while len(pending) > 0:
 
2486
            parent_id = pending.pop()
 
2487
            children = []
 
2488
            subdirs = []
 
2489
            prefix = prefix.rstrip('/')
 
2490
            parent_path = self._final_paths.get_path(parent_id)
 
2491
            parent_file_id = self._transform.final_file_id(parent_id)
 
2492
            for child_id in self._all_children(parent_id):
 
2493
                path_from_root = self._final_paths.get_path(child_id)
 
2494
                basename = self._transform.final_name(child_id)
 
2495
                file_id = self._transform.final_file_id(child_id)
 
2496
                kind = self._transform.final_kind(child_id)
 
2497
                if kind is not None:
 
2498
                    versioned_kind = kind
 
2499
                else:
 
2500
                    kind = 'unknown'
 
2501
                    versioned_kind = self._transform._tree.stored_kind(
 
2502
                        self._transform._tree.id2path(file_id))
 
2503
                if versioned_kind == 'directory':
 
2504
                    subdirs.append(child_id)
 
2505
                children.append((path_from_root, basename, kind, None,
 
2506
                                 file_id, versioned_kind))
 
2507
            children.sort()
 
2508
            if parent_path.startswith(prefix):
 
2509
                yield (parent_path, parent_file_id), children
 
2510
            pending.extend(sorted(subdirs, key=self._final_paths.get_path,
 
2511
                                  reverse=True))
 
2512
 
 
2513
    def get_parent_ids(self):
 
2514
        return self._parent_ids
 
2515
 
 
2516
    def set_parent_ids(self, parent_ids):
 
2517
        self._parent_ids = parent_ids
 
2518
 
 
2519
    def get_revision_tree(self, revision_id):
 
2520
        return self._transform._tree.get_revision_tree(revision_id)
 
2521
 
 
2522
 
599
2523
def joinpath(parent, child):
600
2524
    """Join tree-relative paths, handling the tree root specially"""
601
2525
    if parent is None or parent == "":
690
2614
        if wt.path2id('') != tree.path2id(''):
691
2615
            wt.set_root_id(tree.path2id(''))
692
2616
            wt.flush()
693
 
    tt = wt.transform()
 
2617
    tt = wt.get_transform()
694
2618
    divert = set()
695
2619
    try:
696
2620
        pp.next_phase()
697
 
        file_trans_id[find_previous_path(wt, tree, '')] = tt.trans_id_tree_path('')
 
2621
        file_trans_id[wt.path2id('')] = tt.trans_id_tree_path('')
698
2622
        with ui.ui_factory.nested_progress_bar() as pb:
699
2623
            deferred_contents = []
700
2624
            num = 0
731
2655
                        except errors.NotBranchError:
732
2656
                            pass
733
2657
                        else:
734
 
                            divert.add(tree_path)
735
 
                    if (tree_path not in divert
 
2658
                            divert.add(file_id)
 
2659
                    if (file_id not in divert
736
2660
                        and _content_match(
737
2661
                            tree, entry, tree_path, kind, target_path)):
738
2662
                        tt.delete_contents(tt.trans_id_tree_path(tree_path))
739
2663
                        if kind == 'directory':
740
2664
                            reparent = True
741
 
                parent_id = file_trans_id[osutils.dirname(tree_path)]
 
2665
                parent_id = file_trans_id[entry.parent_id]
742
2666
                if entry.kind == 'file':
743
2667
                    # We *almost* replicate new_by_entry, so that we can defer
744
2668
                    # getting the file text, and get them all at once.
745
2669
                    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)
 
2670
                    file_trans_id[file_id] = trans_id
 
2671
                    tt.version_file(file_id, trans_id)
748
2672
                    executable = tree.is_executable(tree_path)
749
2673
                    if executable:
750
2674
                        tt.set_executability(executable, trans_id)
751
 
                    trans_data = (trans_id, tree_path, entry.text_sha1)
 
2675
                    trans_data = (trans_id, file_id,
 
2676
                                  tree_path, entry.text_sha1)
752
2677
                    deferred_contents.append((tree_path, trans_data))
753
2678
                else:
754
 
                    file_trans_id[tree_path] = new_by_entry(
 
2679
                    file_trans_id[file_id] = new_by_entry(
755
2680
                        tree_path, tt, entry, parent_id, tree)
756
2681
                if reparent:
757
 
                    new_trans_id = file_trans_id[tree_path]
 
2682
                    new_trans_id = file_trans_id[file_id]
758
2683
                    old_parent = tt.trans_id_tree_path(tree_path)
759
2684
                    _reparent_children(tt, old_parent, new_trans_id)
760
2685
            offset = num + 1 - len(deferred_contents)
800
2725
        unchanged = dict(unchanged)
801
2726
        new_desired_files = []
802
2727
        count = 0
803
 
        for unused_tree_path, (trans_id, tree_path, text_sha1) in desired_files:
 
2728
        for unused_tree_path, (trans_id, file_id, tree_path, text_sha1) in desired_files:
804
2729
            accelerator_path = unchanged.get(tree_path)
805
2730
            if accelerator_path is None:
806
2731
                new_desired_files.append((tree_path,
807
 
                                          (trans_id, tree_path, text_sha1)))
 
2732
                                          (trans_id, file_id, tree_path, text_sha1)))
808
2733
                continue
809
2734
            pb.update(gettext('Adding file contents'), count + offset, total)
810
2735
            if hardlink:
820
2745
                    tt.create_file(chunks, trans_id, sha1=text_sha1)
821
2746
            count += 1
822
2747
        offset += count
823
 
    for count, ((trans_id, tree_path, text_sha1), contents) in enumerate(
 
2748
    for count, ((trans_id, file_id, tree_path, text_sha1), contents) in enumerate(
824
2749
            tree.iter_files_bytes(new_desired_files)):
825
2750
        if wt.supports_content_filtering():
826
2751
            filters = wt._content_filter_stack(tree_path)
955
2880
    """Revert a working tree's contents to those of a target tree."""
956
2881
    pb = ui.ui_factory.nested_progress_bar()
957
2882
    try:
958
 
        with target_tree.lock_read(), working_tree.transform(pb) as tt:
 
2883
        with target_tree.lock_read(), working_tree.get_transform(pb) as tt:
959
2884
            pp = ProgressPhase("Revert phase", 3, pb)
960
2885
            conflicts, merge_modified = _prepare_revert_transform(
961
2886
                working_tree, target_tree, tt, filenames, backups, pp)
962
2887
            if change_reporter:
963
 
                from . import delta
964
2888
                change_reporter = delta._ChangeReporter(
965
2889
                    unversioned_filter=working_tree.is_ignored)
966
2890
                delta.report_changes(tt.iter_changes(), change_reporter)
1049
2973
                        new_trans_id = tt.create_path(wt_name, parent_trans_id)
1050
2974
                        if wt_versioned and target_versioned:
1051
2975
                            tt.unversion_file(trans_id)
1052
 
                            tt.version_file(new_trans_id, file_id=file_id)
 
2976
                            tt.version_file(file_id, new_trans_id)
1053
2977
                        # New contents should have the same unix perms as old
1054
2978
                        # contents
1055
2979
                        mode_id = trans_id
1087
3011
                elif target_kind is not None:
1088
3012
                    raise AssertionError(target_kind)
1089
3013
            if not wt_versioned and target_versioned:
1090
 
                tt.version_file(trans_id, file_id=file_id)
 
3014
                tt.version_file(file_id, trans_id)
1091
3015
            if wt_versioned and not target_versioned:
1092
3016
                tt.unversion_file(trans_id)
1093
3017
            if (target_name is not None
1232
3156
            if path_tree and path_tree.path2id('') == file_id:
1233
3157
                # This is the root entry, skip it
1234
3158
                continue
1235
 
            tt.version_file(conflict[1], file_id=file_id)
 
3159
            tt.version_file(file_id, conflict[1])
1236
3160
            new_conflicts.add((c_type, 'Versioned directory', conflict[1]))
1237
3161
        elif c_type == 'non-directory parent':
1238
3162
            parent_id = conflict[1]
1293
3217
                raise errors.FileExists(to, str(e))
1294
3218
            # normal OSError doesn't include filenames so it's hard to see where
1295
3219
            # the problem is, see https://bugs.launchpad.net/bzr/+bug/491763
1296
 
            raise TransformRenameFailed(from_, to, str(e), e.errno)
 
3220
            raise errors.TransformRenameFailed(from_, to, str(e), e.errno)
1297
3221
        self.past_renames.append((from_, to))
1298
3222
 
1299
3223
    def pre_delete(self, from_, to):
1312
3236
            try:
1313
3237
                os.rename(to, from_)
1314
3238
            except OSError as e:
1315
 
                raise TransformRenameFailed(to, from_, str(e), e.errno)
 
3239
                raise errors.TransformRenameFailed(to, from_, str(e), e.errno)
1316
3240
        # after rollback, don't reuse _FileMover
1317
3241
        self.past_renames = None
1318
3242
        self.pending_deletions = None
1332
3256
    :param target_tree: Tree to change
1333
3257
    :param source_tree: Tree to hard-link from
1334
3258
    """
1335
 
    with target_tree.transform() as tt:
 
3259
    with target_tree.get_transform() as tt:
1336
3260
        for change in target_tree.iter_changes(source_tree, include_unchanged=True):
1337
3261
            if change.changed_content:
1338
3262
                continue
1344
3268
            tt.delete_contents(trans_id)
1345
3269
            tt.create_hardlink(source_tree.abspath(change.path[0]), trans_id)
1346
3270
        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