/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/transform.py

  • Committer: Jelmer Vernooij
  • Date: 2017-07-23 22:06:41 UTC
  • mfrom: (6738 trunk)
  • mto: This revision was merged to the branch mainline in revision 6739.
  • Revision ID: jelmer@jelmer.uk-20170723220641-69eczax9bmv8d6kk
Merge trunk, address review comments.

Show diffs side-by-side

added added

removed removed

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