← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transform.py

  • Committer: Danny van Heumen
  • Date: 2010-03-09 21:42:11 UTC
  • mto: (4634.139.5 2.0)
  • mto: This revision was merged to the branch mainline in revision 5160.
  • Revision ID: danny@dannyvanheumen.nl-20100309214211-iqh42x6qcikgd9p3
Reverted now-useless TODO list.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/transform.py
1
 
# Copyright (C) 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2006-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
import os
18
18
import errno
19
 
from stat import S_ISREG
 
19
from stat import S_ISREG, S_IEXEC
20
20
 
21
21
from bzrlib.lazy_import import lazy_import
22
22
lazy_import(globals(), """
23
23
from bzrlib import (
 
24
    annotate,
 
25
    bencode,
24
26
    bzrdir,
25
27
    delta,
26
28
    errors,
27
 
    inventory
 
29
    inventory,
 
30
    multiparent,
 
31
    osutils,
 
32
    revision as _mod_revision,
28
33
    )
29
34
""")
30
35
from bzrlib.errors import (DuplicateKey, MalformedTransform, NoSuchFile,
31
36
                           ReusingTransform, NotVersionedError, CantMoveRoot,
32
 
                           ExistingLimbo, ImmortalLimbo, NoFinalPath)
 
37
                           ExistingLimbo, ImmortalLimbo, NoFinalPath,
 
38
                           UnableCreateSymlink)
 
39
from bzrlib.filters import filtered_output_bytes, ContentFilterContext
33
40
from bzrlib.inventory import InventoryEntry
34
 
from bzrlib.osutils import (file_kind, supports_executable, pathjoin, lexists,
35
 
                            delete_any)
 
41
from bzrlib.osutils import (
 
42
    delete_any,
 
43
    file_kind,
 
44
    has_symlinks,
 
45
    lexists,
 
46
    pathjoin,
 
47
    sha_file,
 
48
    splitpath,
 
49
    supports_executable,
 
50
)
36
51
from bzrlib.progress import DummyProgress, ProgressPhase
37
 
from bzrlib.symbol_versioning import deprecated_function, zero_fifteen
 
52
from bzrlib.symbol_versioning import (
 
53
        deprecated_function,
 
54
        deprecated_in,
 
55
        )
38
56
from bzrlib.trace import mutter, warning
39
57
from bzrlib import tree
40
58
import bzrlib.ui
57
75
        self.rename_count = rename_count
58
76
 
59
77
 
60
 
class TreeTransform(object):
61
 
    """Represent a tree transformation.
62
 
    
63
 
    This object is designed to support incremental generation of the transform,
64
 
    in any order.
65
 
 
66
 
    However, it gives optimum performance when parent directories are created
67
 
    before their contents.  The transform is then able to put child files
68
 
    directly in their parent directory, avoiding later renames.
69
 
    
70
 
    It is easy to produce malformed transforms, but they are generally
71
 
    harmless.  Attempting to apply a malformed transform will cause an
72
 
    exception to be raised before any modifications are made to the tree.  
73
 
 
74
 
    Many kinds of malformed transforms can be corrected with the 
75
 
    resolve_conflicts function.  The remaining ones indicate programming error,
76
 
    such as trying to create a file with no path.
77
 
 
78
 
    Two sets of file creation methods are supplied.  Convenience methods are:
79
 
     * new_file
80
 
     * new_directory
81
 
     * new_symlink
82
 
 
83
 
    These are composed of the low-level methods:
84
 
     * create_path
85
 
     * create_file or create_directory or create_symlink
86
 
     * version_file
87
 
     * set_executability
88
 
    """
89
 
    def __init__(self, tree, pb=DummyProgress()):
90
 
        """Note: a tree_write lock is taken on the tree.
91
 
        
92
 
        Use TreeTransform.finalize() to release the lock (can be omitted if
93
 
        TreeTransform.apply() called).
 
78
class TreeTransformBase(object):
 
79
    """The base class for TreeTransform and its kin."""
 
80
 
 
81
    def __init__(self, tree, pb=DummyProgress(),
 
82
                 case_sensitive=True):
 
83
        """Constructor.
 
84
 
 
85
        :param tree: The tree that will be transformed, but not necessarily
 
86
            the output tree.
 
87
        :param pb: A ProgressTask indicating how much progress is being made
 
88
        :param case_sensitive: If True, the target of the transform is
 
89
            case sensitive, not just case preserving.
94
90
        """
95
91
        object.__init__(self)
96
92
        self._tree = tree
97
 
        self._tree.lock_tree_write()
98
 
        try:
99
 
            control_files = self._tree._control_files
100
 
            self._limbodir = urlutils.local_path_from_url(
101
 
                control_files.controlfilename('limbo'))
102
 
            try:
103
 
                os.mkdir(self._limbodir)
104
 
            except OSError, e:
105
 
                if e.errno == errno.EEXIST:
106
 
                    raise ExistingLimbo(self._limbodir)
107
 
        except: 
108
 
            self._tree.unlock()
109
 
            raise
110
 
 
111
93
        self._id_number = 0
 
94
        # mapping of trans_id -> new basename
112
95
        self._new_name = {}
 
96
        # mapping of trans_id -> new parent trans_id
113
97
        self._new_parent = {}
 
98
        # mapping of trans_id with new contents -> new file_kind
114
99
        self._new_contents = {}
115
 
        # A mapping of transform ids to their limbo filename
116
 
        self._limbo_files = {}
117
 
        # A mapping of transform ids to a set of the transform ids of children
118
 
        # that their limbo directory has
119
 
        self._limbo_children = {}
120
 
        # Map transform ids to maps of child filename to child transform id
121
 
        self._limbo_children_names = {}
122
 
        # List of transform ids that need to be renamed from limbo into place
123
 
        self._needs_rename = set()
 
100
        # Set of trans_ids whose contents will be removed
124
101
        self._removed_contents = set()
 
102
        # Mapping of trans_id -> new execute-bit value
125
103
        self._new_executability = {}
 
104
        # Mapping of trans_id -> new tree-reference value
126
105
        self._new_reference_revision = {}
 
106
        # Mapping of trans_id -> new file_id
127
107
        self._new_id = {}
 
108
        # Mapping of old file-id -> trans_id
128
109
        self._non_present_ids = {}
 
110
        # Mapping of new file_id -> trans_id
129
111
        self._r_new_id = {}
 
112
        # Set of trans_ids that will be removed
130
113
        self._removed_id = set()
 
114
        # Mapping of path in old tree -> trans_id
131
115
        self._tree_path_ids = {}
 
116
        # Mapping trans_id -> path in old tree
132
117
        self._tree_id_paths = {}
133
 
        # Cache of realpath results, to speed up canonical_path
134
 
        self._realpaths = {}
135
 
        # Cache of relpath results, to speed up canonical_path
136
 
        self._relpaths = {}
137
 
        self._new_root = self.trans_id_tree_file_id(tree.get_root_id())
138
 
        self.__done = False
 
118
        # The trans_id that will be used as the tree root
 
119
        root_id = tree.get_root_id()
 
120
        if root_id is not None:
 
121
            self._new_root = self.trans_id_tree_file_id(root_id)
 
122
        else:
 
123
            self._new_root = None
 
124
        # Indictor of whether the transform has been applied
 
125
        self._done = False
 
126
        # A progress bar
139
127
        self._pb = pb
 
128
        # Whether the target is case sensitive
 
129
        self._case_sensitive_target = case_sensitive
 
130
        # A counter of how many files have been renamed
140
131
        self.rename_count = 0
141
132
 
 
133
    def finalize(self):
 
134
        """Release the working tree lock, if held.
 
135
 
 
136
        This is required if apply has not been invoked, but can be invoked
 
137
        even after apply.
 
138
        """
 
139
        if self._tree is None:
 
140
            return
 
141
        self._tree.unlock()
 
142
        self._tree = None
 
143
 
142
144
    def __get_root(self):
143
145
        return self._new_root
144
146
 
145
147
    root = property(__get_root)
146
148
 
147
 
    def finalize(self):
148
 
        """Release the working tree lock, if held, clean up limbo dir.
149
 
 
150
 
        This is required if apply has not been invoked, but can be invoked
151
 
        even after apply.
152
 
        """
153
 
        if self._tree is None:
154
 
            return
155
 
        try:
156
 
            entries = [(self._limbo_name(t), t, k) for t, k in
157
 
                       self._new_contents.iteritems()]
158
 
            entries.sort(reverse=True)
159
 
            for path, trans_id, kind in entries:
160
 
                if kind == "directory":
161
 
                    os.rmdir(path)
162
 
                else:
163
 
                    os.unlink(path)
164
 
            try:
165
 
                os.rmdir(self._limbodir)
166
 
            except OSError:
167
 
                # We don't especially care *why* the dir is immortal.
168
 
                raise ImmortalLimbo(self._limbodir)
169
 
        finally:
170
 
            self._tree.unlock()
171
 
            self._tree = None
172
 
 
173
149
    def _assign_id(self):
174
150
        """Produce a new tranform id"""
175
151
        new_id = "new-%s" % self._id_number
185
161
 
186
162
    def adjust_path(self, name, parent, trans_id):
187
163
        """Change the path that is assigned to a transaction id."""
 
164
        if parent is None:
 
165
            raise ValueError("Parent trans-id may not be None")
188
166
        if trans_id == self._new_root:
189
167
            raise CantMoveRoot
190
 
        previous_parent = self._new_parent.get(trans_id)
191
 
        previous_name = self._new_name.get(trans_id)
192
168
        self._new_name[trans_id] = name
193
169
        self._new_parent[trans_id] = parent
194
 
        if (trans_id in self._limbo_files and
195
 
            trans_id not in self._needs_rename):
196
 
            self._rename_in_limbo([trans_id])
197
 
            self._limbo_children[previous_parent].remove(trans_id)
198
 
            del self._limbo_children_names[previous_parent][previous_name]
199
 
 
200
 
    def _rename_in_limbo(self, trans_ids):
201
 
        """Fix limbo names so that the right final path is produced.
202
 
 
203
 
        This means we outsmarted ourselves-- we tried to avoid renaming
204
 
        these files later by creating them with their final names in their
205
 
        final parents.  But now the previous name or parent is no longer
206
 
        suitable, so we have to rename them.
207
 
 
208
 
        Even for trans_ids that have no new contents, we must remove their
209
 
        entries from _limbo_files, because they are now stale.
210
 
        """
211
 
        for trans_id in trans_ids:
212
 
            old_path = self._limbo_files.pop(trans_id)
213
 
            if trans_id not in self._new_contents:
214
 
                continue
215
 
            new_path = self._limbo_name(trans_id)
216
 
            os.rename(old_path, new_path)
217
170
 
218
171
    def adjust_root_path(self, name, parent):
219
172
        """Emulate moving the root by moving all children, instead.
220
 
        
 
173
 
221
174
        We do this by undoing the association of root's transaction id with the
222
175
        current tree.  This allows us to create a new directory with that
223
 
        transaction id.  We unversion the root directory and version the 
 
176
        transaction id.  We unversion the root directory and version the
224
177
        physically new directory, and hope someone versions the tree root
225
178
        later.
226
179
        """
229
182
        # force moving all children of root
230
183
        for child_id in self.iter_tree_children(old_root):
231
184
            if child_id != parent:
232
 
                self.adjust_path(self.final_name(child_id), 
 
185
                self.adjust_path(self.final_name(child_id),
233
186
                                 self.final_parent(child_id), child_id)
234
187
            file_id = self.final_file_id(child_id)
235
188
            if file_id is not None:
236
189
                self.unversion_file(child_id)
237
190
            self.version_file(file_id, child_id)
238
 
        
 
191
 
239
192
        # the physical root needs a new transaction id
240
193
        self._tree_path_ids.pop("")
241
194
        self._tree_id_paths.pop(old_root)
247
200
        self.version_file(old_root_file_id, old_root)
248
201
        self.unversion_file(self._new_root)
249
202
 
 
203
    def fixup_new_roots(self):
 
204
        """Reinterpret requests to change the root directory
 
205
 
 
206
        Instead of creating a root directory, or moving an existing directory,
 
207
        all the attributes and children of the new root are applied to the
 
208
        existing root directory.
 
209
 
 
210
        This means that the old root trans-id becomes obsolete, so it is
 
211
        recommended only to invoke this after the root trans-id has become
 
212
        irrelevant.
 
213
        """
 
214
        new_roots = [k for k, v in self._new_parent.iteritems() if v is
 
215
                     ROOT_PARENT]
 
216
        if len(new_roots) < 1:
 
217
            return
 
218
        if len(new_roots) != 1:
 
219
            raise ValueError('A tree cannot have two roots!')
 
220
        if self._new_root is None:
 
221
            self._new_root = new_roots[0]
 
222
            return
 
223
        old_new_root = new_roots[0]
 
224
        # TODO: What to do if a old_new_root is present, but self._new_root is
 
225
        #       not listed as being removed? This code explicitly unversions
 
226
        #       the old root and versions it with the new file_id. Though that
 
227
        #       seems like an incomplete delta
 
228
 
 
229
        # unversion the new root's directory.
 
230
        file_id = self.final_file_id(old_new_root)
 
231
        if old_new_root in self._new_id:
 
232
            self.cancel_versioning(old_new_root)
 
233
        else:
 
234
            self.unversion_file(old_new_root)
 
235
        # if, at this stage, root still has an old file_id, zap it so we can
 
236
        # stick a new one in.
 
237
        if (self.tree_file_id(self._new_root) is not None and
 
238
            self._new_root not in self._removed_id):
 
239
            self.unversion_file(self._new_root)
 
240
        self.version_file(file_id, self._new_root)
 
241
 
 
242
        # Now move children of new root into old root directory.
 
243
        # Ensure all children are registered with the transaction, but don't
 
244
        # use directly-- some tree children have new parents
 
245
        list(self.iter_tree_children(old_new_root))
 
246
        # Move all children of new root into old root directory.
 
247
        for child in self.by_parent().get(old_new_root, []):
 
248
            self.adjust_path(self.final_name(child), self._new_root, child)
 
249
 
 
250
        # Ensure old_new_root has no directory.
 
251
        if old_new_root in self._new_contents:
 
252
            self.cancel_creation(old_new_root)
 
253
        else:
 
254
            self.delete_contents(old_new_root)
 
255
 
 
256
        # prevent deletion of root directory.
 
257
        if self._new_root in self._removed_contents:
 
258
            self.cancel_deletion(self._new_root)
 
259
 
 
260
        # destroy path info for old_new_root.
 
261
        del self._new_parent[old_new_root]
 
262
        del self._new_name[old_new_root]
 
263
 
250
264
    def trans_id_tree_file_id(self, inventory_id):
251
265
        """Determine the transaction id of a working tree file.
252
 
        
 
266
 
253
267
        This reflects only files that already exist, not ones that will be
254
268
        added by transactions.
255
269
        """
256
 
        path = self._tree.inventory.id2path(inventory_id)
 
270
        if inventory_id is None:
 
271
            raise ValueError('None is not a valid file id')
 
272
        path = self._tree.id2path(inventory_id)
257
273
        return self.trans_id_tree_path(path)
258
274
 
259
275
    def trans_id_file_id(self, file_id):
262
278
        a transaction has been unversioned, it is deliberately still returned.
263
279
        (this will likely lead to an unversioned parent conflict.)
264
280
        """
 
281
        if file_id is None:
 
282
            raise ValueError('None is not a valid file id')
265
283
        if file_id in self._r_new_id and self._r_new_id[file_id] is not None:
266
284
            return self._r_new_id[file_id]
267
 
        elif file_id in self._tree.inventory:
268
 
            return self.trans_id_tree_file_id(file_id)
269
 
        elif file_id in self._non_present_ids:
270
 
            return self._non_present_ids[file_id]
271
 
        else:
272
 
            trans_id = self._assign_id()
273
 
            self._non_present_ids[file_id] = trans_id
274
 
            return trans_id
275
 
 
276
 
    def canonical_path(self, path):
277
 
        """Get the canonical tree-relative path"""
278
 
        # don't follow final symlinks
279
 
        abs = self._tree.abspath(path)
280
 
        if abs in self._relpaths:
281
 
            return self._relpaths[abs]
282
 
        dirname, basename = os.path.split(abs)
283
 
        if dirname not in self._realpaths:
284
 
            self._realpaths[dirname] = os.path.realpath(dirname)
285
 
        dirname = self._realpaths[dirname]
286
 
        abs = pathjoin(dirname, basename)
287
 
        if dirname in self._relpaths:
288
 
            relpath = pathjoin(self._relpaths[dirname], basename)
289
 
            relpath = relpath.rstrip('/\\')
290
 
        else:
291
 
            relpath = self._tree.relpath(abs)
292
 
        self._relpaths[abs] = relpath
293
 
        return relpath
 
285
        else:
 
286
            try:
 
287
                self._tree.iter_entries_by_dir([file_id]).next()
 
288
            except StopIteration:
 
289
                if file_id in self._non_present_ids:
 
290
                    return self._non_present_ids[file_id]
 
291
                else:
 
292
                    trans_id = self._assign_id()
 
293
                    self._non_present_ids[file_id] = trans_id
 
294
                    return trans_id
 
295
            else:
 
296
                return self.trans_id_tree_file_id(file_id)
294
297
 
295
298
    def trans_id_tree_path(self, path):
296
299
        """Determine (and maybe set) the transaction ID for a tree path."""
307
310
            return ROOT_PARENT
308
311
        return self.trans_id_tree_path(os.path.dirname(path))
309
312
 
310
 
    def create_file(self, contents, trans_id, mode_id=None):
311
 
        """Schedule creation of a new file.
312
 
 
313
 
        See also new_file.
314
 
        
315
 
        Contents is an iterator of strings, all of which will be written
316
 
        to the target destination.
317
 
 
318
 
        New file takes the permissions of any existing file with that id,
319
 
        unless mode_id is specified.
320
 
        """
321
 
        name = self._limbo_name(trans_id)
322
 
        f = open(name, 'wb')
323
 
        try:
324
 
            try:
325
 
                unique_add(self._new_contents, trans_id, 'file')
326
 
            except:
327
 
                # Clean up the file, it never got registered so
328
 
                # TreeTransform.finalize() won't clean it up.
329
 
                f.close()
330
 
                os.unlink(name)
331
 
                raise
332
 
 
333
 
            f.writelines(contents)
334
 
        finally:
335
 
            f.close()
336
 
        self._set_mode(trans_id, mode_id, S_ISREG)
337
 
 
338
 
    def _set_mode(self, trans_id, mode_id, typefunc):
339
 
        """Set the mode of new file contents.
340
 
        The mode_id is the existing file to get the mode from (often the same
341
 
        as trans_id).  The operation is only performed if there's a mode match
342
 
        according to typefunc.
343
 
        """
344
 
        if mode_id is None:
345
 
            mode_id = trans_id
346
 
        try:
347
 
            old_path = self._tree_id_paths[mode_id]
348
 
        except KeyError:
349
 
            return
350
 
        try:
351
 
            mode = os.stat(self._tree.abspath(old_path)).st_mode
352
 
        except OSError, e:
353
 
            if e.errno == errno.ENOENT:
354
 
                return
355
 
            else:
356
 
                raise
357
 
        if typefunc(mode):
358
 
            os.chmod(self._limbo_name(trans_id), mode)
359
 
 
360
 
    def create_directory(self, trans_id):
361
 
        """Schedule creation of a new directory.
362
 
        
363
 
        See also new_directory.
364
 
        """
365
 
        os.mkdir(self._limbo_name(trans_id))
366
 
        unique_add(self._new_contents, trans_id, 'directory')
367
 
 
368
 
    def create_symlink(self, target, trans_id):
369
 
        """Schedule creation of a new symbolic link.
370
 
 
371
 
        target is a bytestring.
372
 
        See also new_symlink.
373
 
        """
374
 
        os.symlink(target, self._limbo_name(trans_id))
375
 
        unique_add(self._new_contents, trans_id, 'symlink')
376
 
 
377
 
    def cancel_creation(self, trans_id):
378
 
        """Cancel the creation of new file contents."""
379
 
        del self._new_contents[trans_id]
380
 
        children = self._limbo_children.get(trans_id)
381
 
        # if this is a limbo directory with children, move them before removing
382
 
        # the directory
383
 
        if children is not None:
384
 
            self._rename_in_limbo(children)
385
 
            del self._limbo_children[trans_id]
386
 
            del self._limbo_children_names[trans_id]
387
 
        delete_any(self._limbo_name(trans_id))
388
 
 
389
313
    def delete_contents(self, trans_id):
390
314
        """Schedule the contents of a path entry for deletion"""
 
315
        # Ensure that the object exists in the WorkingTree, this will raise an
 
316
        # exception if there is a problem
391
317
        self.tree_kind(trans_id)
392
318
        self._removed_contents.add(trans_id)
393
319
 
419
345
 
420
346
    def version_file(self, file_id, trans_id):
421
347
        """Schedule a file to become versioned."""
422
 
        assert file_id is not None
 
348
        if file_id is None:
 
349
            raise ValueError()
423
350
        unique_add(self._new_id, trans_id, file_id)
424
351
        unique_add(self._r_new_id, file_id, trans_id)
425
352
 
429
356
        del self._new_id[trans_id]
430
357
        del self._r_new_id[file_id]
431
358
 
432
 
    def new_paths(self):
433
 
        """Determine the paths of all new and changed files"""
434
 
        new_ids = set()
435
 
        fp = FinalPaths(self)
436
 
        for id_set in (self._new_name, self._new_parent, self._new_contents,
437
 
                       self._new_id, self._new_executability):
438
 
            new_ids.update(id_set)
439
 
        new_paths = [(fp.get_path(t), t) for t in new_ids]
440
 
        new_paths.sort()
441
 
        return new_paths
442
 
 
443
 
    def tree_kind(self, trans_id):
444
 
        """Determine the file kind in the working tree.
445
 
 
446
 
        Raises NoSuchFile if the file does not exist
 
359
    def new_paths(self, filesystem_only=False):
 
360
        """Determine the paths of all new and changed files.
 
361
 
 
362
        :param filesystem_only: if True, only calculate values for files
 
363
            that require renames or execute bit changes.
447
364
        """
448
 
        path = self._tree_id_paths.get(trans_id)
449
 
        if path is None:
450
 
            raise NoSuchFile(None)
451
 
        try:
452
 
            return file_kind(self._tree.abspath(path))
453
 
        except OSError, e:
454
 
            if e.errno != errno.ENOENT:
455
 
                raise
456
 
            else:
457
 
                raise NoSuchFile(path)
 
365
        new_ids = set()
 
366
        if filesystem_only:
 
367
            stale_ids = self._needs_rename.difference(self._new_name)
 
368
            stale_ids.difference_update(self._new_parent)
 
369
            stale_ids.difference_update(self._new_contents)
 
370
            stale_ids.difference_update(self._new_id)
 
371
            needs_rename = self._needs_rename.difference(stale_ids)
 
372
            id_sets = (needs_rename, self._new_executability)
 
373
        else:
 
374
            id_sets = (self._new_name, self._new_parent, self._new_contents,
 
375
                       self._new_id, self._new_executability)
 
376
        for id_set in id_sets:
 
377
            new_ids.update(id_set)
 
378
        return sorted(FinalPaths(self).get_paths(new_ids))
 
379
 
 
380
    def _inventory_altered(self):
 
381
        """Get the trans_ids and paths of files needing new inv entries."""
 
382
        new_ids = set()
 
383
        for id_set in [self._new_name, self._new_parent, self._new_id,
 
384
                       self._new_executability]:
 
385
            new_ids.update(id_set)
 
386
        changed_kind = set(self._removed_contents)
 
387
        changed_kind.intersection_update(self._new_contents)
 
388
        changed_kind.difference_update(new_ids)
 
389
        changed_kind = (t for t in changed_kind if self.tree_kind(t) !=
 
390
                        self.final_kind(t))
 
391
        new_ids.update(changed_kind)
 
392
        return sorted(FinalPaths(self).get_paths(new_ids))
458
393
 
459
394
    def final_kind(self, trans_id):
460
395
        """Determine the final file kind, after any changes applied.
461
 
        
 
396
 
462
397
        Raises NoSuchFile if the file does not exist/has no contents.
463
398
        (It is conceivable that a path would be created without the
464
399
        corresponding contents insertion command)
479
414
            return None
480
415
        # the file is old; the old id is still valid
481
416
        if self._new_root == trans_id:
482
 
            return self._tree.inventory.root.file_id
483
 
        return self._tree.inventory.path2id(path)
 
417
            return self._tree.get_root_id()
 
418
        return self._tree.path2id(path)
484
419
 
485
420
    def final_file_id(self, trans_id):
486
421
        """Determine the file id after any changes are applied, or None.
487
 
        
 
422
 
488
423
        None indicates that the file will not be versioned after changes are
489
424
        applied.
490
425
        """
491
426
        try:
492
 
            # there is a new id for this file
493
 
            assert self._new_id[trans_id] is not None
494
427
            return self._new_id[trans_id]
495
428
        except KeyError:
496
429
            if trans_id in self._removed_id:
531
464
 
532
465
    def by_parent(self):
533
466
        """Return a map of parent: children for known parents.
534
 
        
 
467
 
535
468
        Only new paths and parents of tree files with assigned ids are used.
536
469
        """
537
470
        by_parent = {}
538
471
        items = list(self._new_parent.iteritems())
539
 
        items.extend((t, self.final_parent(t)) for t in 
 
472
        items.extend((t, self.final_parent(t)) for t in
540
473
                      self._tree_id_paths.keys())
541
474
        for trans_id, parent_id in items:
542
475
            if parent_id not in by_parent:
553
486
 
554
487
    def find_conflicts(self):
555
488
        """Find any violations of inventory or filesystem invariants"""
556
 
        if self.__done is True:
 
489
        if self._done is True:
557
490
            raise ReusingTransform()
558
491
        conflicts = []
559
492
        # ensure all children of all existent parents are known
570
503
        conflicts.extend(self._overwrite_conflicts())
571
504
        return conflicts
572
505
 
 
506
    def _check_malformed(self):
 
507
        conflicts = self.find_conflicts()
 
508
        if len(conflicts) != 0:
 
509
            raise MalformedTransform(conflicts=conflicts)
 
510
 
573
511
    def _add_tree_children(self):
574
512
        """Add all the children of all active parents to the known paths.
575
513
 
577
515
        removed.  This is a necessary first step in detecting conflicts.
578
516
        """
579
517
        parents = self.by_parent().keys()
580
 
        parents.extend([t for t in self._removed_contents if 
 
518
        parents.extend([t for t in self._removed_contents if
581
519
                        self.tree_kind(t) == 'directory'])
582
520
        for trans_id in self._removed_id:
583
521
            file_id = self.tree_file_id(trans_id)
584
 
            if self._tree.inventory[file_id].kind == 'directory':
 
522
            if file_id is not None:
 
523
                if self._tree.inventory[file_id].kind == 'directory':
 
524
                    parents.append(trans_id)
 
525
            elif self.tree_kind(trans_id) == 'directory':
585
526
                parents.append(trans_id)
586
527
 
587
528
        for parent_id in parents:
588
529
            # ensure that all children are registered with the transaction
589
530
            list(self.iter_tree_children(parent_id))
590
531
 
591
 
    def iter_tree_children(self, parent_id):
592
 
        """Iterate through the entry's tree children, if any"""
593
 
        try:
594
 
            path = self._tree_id_paths[parent_id]
595
 
        except KeyError:
596
 
            return
597
 
        try:
598
 
            children = os.listdir(self._tree.abspath(path))
599
 
        except OSError, e:
600
 
            if e.errno != errno.ENOENT and e.errno != errno.ESRCH:
601
 
                raise
602
 
            return
603
 
            
604
 
        for child in children:
605
 
            childpath = joinpath(path, child)
606
 
            if self._tree.is_control_filename(childpath):
607
 
                continue
608
 
            yield self.trans_id_tree_path(childpath)
609
 
 
610
532
    def has_named_child(self, by_parent, parent_id, name):
611
533
        try:
612
534
            children = by_parent[parent_id]
666
588
 
667
589
    def _improper_versioning(self):
668
590
        """Cannot version a file with no contents, or a bad type.
669
 
        
 
591
 
670
592
        However, existing entries with no contents are okay.
671
593
        """
672
594
        conflicts = []
682
604
 
683
605
    def _executability_conflicts(self):
684
606
        """Check for bad executability changes.
685
 
        
 
607
 
686
608
        Only versioned files may have their executability set, because
687
609
        1. only versioned entries can have executability under windows
688
610
        2. only files can be executable.  (The execute bit on a directory
717
639
    def _duplicate_entries(self, by_parent):
718
640
        """No directory may have two entries with the same name."""
719
641
        conflicts = []
 
642
        if (self._new_name, self._new_parent) == ({}, {}):
 
643
            return conflicts
720
644
        for children in by_parent.itervalues():
721
645
            name_ids = [(self.final_name(t), t) for t in children]
 
646
            if not self._case_sensitive_target:
 
647
                name_ids = [(n.lower(), t) for n, t in name_ids]
722
648
            name_ids.sort()
723
649
            last_name = None
724
650
            last_trans_id = None
742
668
        conflicts = []
743
669
        removed_tree_ids = set((self.tree_file_id(trans_id) for trans_id in
744
670
                                self._removed_id))
745
 
        active_tree_ids = set((f for f in self._tree.inventory if
746
 
                               f not in removed_tree_ids))
 
671
        all_ids = self._tree.all_file_ids()
 
672
        active_tree_ids = all_ids.difference(removed_tree_ids)
747
673
        for trans_id, file_id in self._new_id.iteritems():
748
674
            if file_id in active_tree_ids:
749
675
                old_trans_id = self.trans_id_tree_file_id(file_id)
782
708
                continue
783
709
            return True
784
710
        return False
785
 
            
786
 
    def apply(self):
787
 
        """Apply all changes to the inventory and filesystem.
788
 
        
789
 
        If filesystem or inventory conflicts are present, MalformedTransform
790
 
        will be thrown.
791
 
 
792
 
        If apply succeeds, finalize is not necessary.
793
 
        """
794
 
        conflicts = self.find_conflicts()
795
 
        if len(conflicts) != 0:
796
 
            raise MalformedTransform(conflicts=conflicts)
797
 
        inv = self._tree.inventory
798
 
        inventory_delta = []
799
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
800
 
        try:
801
 
            child_pb.update('Apply phase', 0, 2)
802
 
            self._apply_removals(inv, inventory_delta)
803
 
            child_pb.update('Apply phase', 1, 2)
804
 
            modified_paths = self._apply_insertions(inv, inventory_delta)
805
 
        finally:
806
 
            child_pb.finished()
807
 
        self._tree.apply_inventory_delta(inventory_delta)
808
 
        self.__done = True
809
 
        self.finalize()
810
 
        return _TransformResults(modified_paths, self.rename_count)
811
 
 
812
 
    def _limbo_name(self, trans_id):
813
 
        """Generate the limbo name of a file"""
814
 
        limbo_name = self._limbo_files.get(trans_id)
815
 
        if limbo_name is not None:
816
 
            return limbo_name
817
 
        parent = self._new_parent.get(trans_id)
818
 
        # if the parent directory is already in limbo (e.g. when building a
819
 
        # tree), choose a limbo name inside the parent, to reduce further
820
 
        # renames.
821
 
        use_direct_path = False
822
 
        if self._new_contents.get(parent) == 'directory':
823
 
            filename = self._new_name.get(trans_id)
824
 
            if filename is not None:
825
 
                if parent not in self._limbo_children:
826
 
                    self._limbo_children[parent] = set()
827
 
                    self._limbo_children_names[parent] = {}
828
 
                    use_direct_path = True
829
 
                # the direct path can only be used if no other file has
830
 
                # already taken this pathname, i.e. if the name is unused, or
831
 
                # if it is already associated with this trans_id.
832
 
                elif (self._limbo_children_names[parent].get(filename)
833
 
                      in (trans_id, None)):
834
 
                    use_direct_path = True
835
 
        if use_direct_path:
836
 
            limbo_name = pathjoin(self._limbo_files[parent], filename)
837
 
            self._limbo_children[parent].add(trans_id)
838
 
            self._limbo_children_names[parent][filename] = trans_id
839
 
        else:
840
 
            limbo_name = pathjoin(self._limbodir, trans_id)
841
 
            self._needs_rename.add(trans_id)
842
 
        self._limbo_files[trans_id] = limbo_name
843
 
        return limbo_name
844
 
 
845
 
    def _apply_removals(self, inv, inventory_delta):
846
 
        """Perform tree operations that remove directory/inventory names.
847
 
        
848
 
        That is, delete files that are to be deleted, and put any files that
849
 
        need renaming into limbo.  This must be done in strict child-to-parent
850
 
        order.
851
 
        """
852
 
        tree_paths = list(self._tree_path_ids.iteritems())
853
 
        tree_paths.sort(reverse=True)
854
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
855
 
        try:
856
 
            for num, data in enumerate(tree_paths):
857
 
                path, trans_id = data
858
 
                child_pb.update('removing file', num, len(tree_paths))
859
 
                full_path = self._tree.abspath(path)
860
 
                if trans_id in self._removed_contents:
861
 
                    delete_any(full_path)
862
 
                elif trans_id in self._new_name or trans_id in \
863
 
                    self._new_parent:
864
 
                    try:
865
 
                        os.rename(full_path, self._limbo_name(trans_id))
866
 
                    except OSError, e:
867
 
                        if e.errno != errno.ENOENT:
868
 
                            raise
869
 
                    else:
870
 
                        self.rename_count += 1
871
 
                if trans_id in self._removed_id:
872
 
                    if trans_id == self._new_root:
873
 
                        file_id = self._tree.inventory.root.file_id
874
 
                    else:
875
 
                        file_id = self.tree_file_id(trans_id)
876
 
                    assert file_id is not None
877
 
                    inventory_delta.append((path, None, file_id, None))
878
 
        finally:
879
 
            child_pb.finished()
880
 
 
881
 
    def _apply_insertions(self, inv, inventory_delta):
882
 
        """Perform tree operations that insert directory/inventory names.
883
 
        
884
 
        That is, create any files that need to be created, and restore from
885
 
        limbo any files that needed renaming.  This must be done in strict
886
 
        parent-to-child order.
887
 
        """
888
 
        new_paths = self.new_paths()
889
 
        modified_paths = []
890
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
891
 
        try:
892
 
            for num, (path, trans_id) in enumerate(new_paths):
893
 
                new_entry = None
894
 
                child_pb.update('adding file', num, len(new_paths))
895
 
                try:
896
 
                    kind = self._new_contents[trans_id]
897
 
                except KeyError:
898
 
                    kind = contents = None
899
 
                if trans_id in self._new_contents or \
900
 
                    self.path_changed(trans_id):
901
 
                    full_path = self._tree.abspath(path)
902
 
                    if trans_id in self._needs_rename:
903
 
                        try:
904
 
                            os.rename(self._limbo_name(trans_id), full_path)
905
 
                        except OSError, e:
906
 
                            # We may be renaming a dangling inventory id
907
 
                            if e.errno != errno.ENOENT:
908
 
                                raise
909
 
                        else:
910
 
                            self.rename_count += 1
911
 
                    if trans_id in self._new_contents:
912
 
                        modified_paths.append(full_path)
913
 
                        del self._new_contents[trans_id]
914
 
 
915
 
                if trans_id in self._new_id:
916
 
                    if kind is None:
917
 
                        kind = file_kind(self._tree.abspath(path))
918
 
                    if trans_id in self._new_reference_revision:
919
 
                        new_entry = inventory.TreeReference(
920
 
                            self._new_id[trans_id],
921
 
                            self._new_name[trans_id], 
922
 
                            self.final_file_id(self._new_parent[trans_id]),
923
 
                            None, self._new_reference_revision[trans_id])
924
 
                    else:
925
 
                        new_entry = inventory.make_entry(kind,
926
 
                            self.final_name(trans_id),
927
 
                            self.final_file_id(self.final_parent(trans_id)),
928
 
                            self._new_id[trans_id])
929
 
                else:
930
 
                    if trans_id in self._new_name or trans_id in\
931
 
                        self._new_parent or\
932
 
                        trans_id in self._new_executability:
933
 
                        file_id = self.final_file_id(trans_id)
934
 
                        if file_id is not None:
935
 
                            entry = inv[file_id]
936
 
                            new_entry = entry.copy()
937
 
 
938
 
                    if trans_id in self._new_name or trans_id in\
939
 
                        self._new_parent:
940
 
                            if new_entry is not None:
941
 
                                new_entry.name = self.final_name(trans_id)
942
 
                                parent = self.final_parent(trans_id)
943
 
                                parent_id = self.final_file_id(parent)
944
 
                                new_entry.parent_id = parent_id
945
 
 
946
 
                if trans_id in self._new_executability:
947
 
                    self._set_executability(path, new_entry, trans_id)
948
 
                if new_entry is not None:
949
 
                    if new_entry.file_id in inv:
950
 
                        old_path = inv.id2path(new_entry.file_id)
951
 
                    else:
952
 
                        old_path = None
953
 
                    inventory_delta.append((old_path, path,
954
 
                                            new_entry.file_id,
955
 
                                            new_entry))
956
 
        finally:
957
 
            child_pb.finished()
958
 
        return modified_paths
959
 
 
960
 
    def _set_executability(self, path, entry, trans_id):
 
711
 
 
712
    def _set_executability(self, path, trans_id):
961
713
        """Set the executability of versioned files """
962
 
        new_executability = self._new_executability[trans_id]
963
 
        entry.executable = new_executability
964
714
        if supports_executable():
 
715
            new_executability = self._new_executability[trans_id]
965
716
            abspath = self._tree.abspath(path)
966
717
            current_mode = os.stat(abspath).st_mode
967
718
            if new_executability:
984
735
            self.version_file(file_id, trans_id)
985
736
        return trans_id
986
737
 
987
 
    def new_file(self, name, parent_id, contents, file_id=None, 
 
738
    def new_file(self, name, parent_id, contents, file_id=None,
988
739
                 executable=None):
989
740
        """Convenience method to create files.
990
 
        
 
741
 
991
742
        name is the name of the file to create.
992
743
        parent_id is the transaction id of the parent directory of the file.
993
744
        contents is an iterator of bytestrings, which will be used to produce
1013
764
        """
1014
765
        trans_id = self._new_entry(name, parent_id, file_id)
1015
766
        self.create_directory(trans_id)
1016
 
        return trans_id 
 
767
        return trans_id
1017
768
 
1018
769
    def new_symlink(self, name, parent_id, target, file_id=None):
1019
770
        """Convenience method to create symbolic link.
1020
 
        
 
771
 
1021
772
        name is the name of the symlink to create.
1022
773
        parent_id is the transaction id of the parent directory of the symlink.
1023
774
        target is a bytestring of the target of the symlink.
1062
813
        from_path = self._tree_id_paths.get(from_trans_id)
1063
814
        if from_versioned:
1064
815
            # get data from working tree if versioned
1065
 
            from_entry = self._tree.inventory[file_id]
 
816
            from_entry = self._tree.iter_entries_by_dir([file_id]).next()[1]
1066
817
            from_name = from_entry.name
1067
818
            from_parent = from_entry.parent_id
1068
819
        else:
1104
855
            to_executable = False
1105
856
        return to_name, to_parent, to_kind, to_executable
1106
857
 
1107
 
    def _iter_changes(self):
1108
 
        """Produce output in the same format as Tree._iter_changes.
 
858
    def iter_changes(self):
 
859
        """Produce output in the same format as Tree.iter_changes.
1109
860
 
1110
861
        Will produce nonsensical results if invoked while inventory/filesystem
1111
862
        conflicts (as reported by TreeTransform.find_conflicts()) are present.
1166
917
                   (from_executable, to_executable)))
1167
918
        return iter(sorted(results, key=lambda x:x[1]))
1168
919
 
 
920
    def get_preview_tree(self):
 
921
        """Return a tree representing the result of the transform.
 
922
 
 
923
        The tree is a snapshot, and altering the TreeTransform will invalidate
 
924
        it.
 
925
        """
 
926
        return _PreviewTree(self)
 
927
 
 
928
    def commit(self, branch, message, merge_parents=None, strict=False):
 
929
        """Commit the result of this TreeTransform to a branch.
 
930
 
 
931
        :param branch: The branch to commit to.
 
932
        :param message: The message to attach to the commit.
 
933
        :param merge_parents: Additional parents specified by pending merges.
 
934
        :return: The revision_id of the revision committed.
 
935
        """
 
936
        self._check_malformed()
 
937
        if strict:
 
938
            unversioned = set(self._new_contents).difference(set(self._new_id))
 
939
            for trans_id in unversioned:
 
940
                if self.final_file_id(trans_id) is None:
 
941
                    raise errors.StrictCommitFailed()
 
942
 
 
943
        revno, last_rev_id = branch.last_revision_info()
 
944
        if last_rev_id == _mod_revision.NULL_REVISION:
 
945
            if merge_parents is not None:
 
946
                raise ValueError('Cannot supply merge parents for first'
 
947
                                 ' commit.')
 
948
            parent_ids = []
 
949
        else:
 
950
            parent_ids = [last_rev_id]
 
951
            if merge_parents is not None:
 
952
                parent_ids.extend(merge_parents)
 
953
        if self._tree.get_revision_id() != last_rev_id:
 
954
            raise ValueError('TreeTransform not based on branch basis: %s' %
 
955
                             self._tree.get_revision_id())
 
956
        builder = branch.get_commit_builder(parent_ids)
 
957
        preview = self.get_preview_tree()
 
958
        list(builder.record_iter_changes(preview, last_rev_id,
 
959
                                         self.iter_changes()))
 
960
        builder.finish_inventory()
 
961
        revision_id = builder.commit(message)
 
962
        branch.set_last_revision_info(revno + 1, revision_id)
 
963
        return revision_id
 
964
 
 
965
    def _text_parent(self, trans_id):
 
966
        file_id = self.tree_file_id(trans_id)
 
967
        try:
 
968
            if file_id is None or self._tree.kind(file_id) != 'file':
 
969
                return None
 
970
        except errors.NoSuchFile:
 
971
            return None
 
972
        return file_id
 
973
 
 
974
    def _get_parents_texts(self, trans_id):
 
975
        """Get texts for compression parents of this file."""
 
976
        file_id = self._text_parent(trans_id)
 
977
        if file_id is None:
 
978
            return ()
 
979
        return (self._tree.get_file_text(file_id),)
 
980
 
 
981
    def _get_parents_lines(self, trans_id):
 
982
        """Get lines for compression parents of this file."""
 
983
        file_id = self._text_parent(trans_id)
 
984
        if file_id is None:
 
985
            return ()
 
986
        return (self._tree.get_file_lines(file_id),)
 
987
 
 
988
    def serialize(self, serializer):
 
989
        """Serialize this TreeTransform.
 
990
 
 
991
        :param serializer: A Serialiser like pack.ContainerSerializer.
 
992
        """
 
993
        new_name = dict((k, v.encode('utf-8')) for k, v in
 
994
                        self._new_name.items())
 
995
        new_executability = dict((k, int(v)) for k, v in
 
996
                                 self._new_executability.items())
 
997
        tree_path_ids = dict((k.encode('utf-8'), v)
 
998
                             for k, v in self._tree_path_ids.items())
 
999
        attribs = {
 
1000
            '_id_number': self._id_number,
 
1001
            '_new_name': new_name,
 
1002
            '_new_parent': self._new_parent,
 
1003
            '_new_executability': new_executability,
 
1004
            '_new_id': self._new_id,
 
1005
            '_tree_path_ids': tree_path_ids,
 
1006
            '_removed_id': list(self._removed_id),
 
1007
            '_removed_contents': list(self._removed_contents),
 
1008
            '_non_present_ids': self._non_present_ids,
 
1009
            }
 
1010
        yield serializer.bytes_record(bencode.bencode(attribs),
 
1011
                                      (('attribs',),))
 
1012
        for trans_id, kind in self._new_contents.items():
 
1013
            if kind == 'file':
 
1014
                lines = osutils.chunks_to_lines(
 
1015
                    self._read_file_chunks(trans_id))
 
1016
                parents = self._get_parents_lines(trans_id)
 
1017
                mpdiff = multiparent.MultiParent.from_lines(lines, parents)
 
1018
                content = ''.join(mpdiff.to_patch())
 
1019
            if kind == 'directory':
 
1020
                content = ''
 
1021
            if kind == 'symlink':
 
1022
                content = self._read_symlink_target(trans_id)
 
1023
            yield serializer.bytes_record(content, ((trans_id, kind),))
 
1024
 
 
1025
    def deserialize(self, records):
 
1026
        """Deserialize a stored TreeTransform.
 
1027
 
 
1028
        :param records: An iterable of (names, content) tuples, as per
 
1029
            pack.ContainerPushParser.
 
1030
        """
 
1031
        names, content = records.next()
 
1032
        attribs = bencode.bdecode(content)
 
1033
        self._id_number = attribs['_id_number']
 
1034
        self._new_name = dict((k, v.decode('utf-8'))
 
1035
                            for k, v in attribs['_new_name'].items())
 
1036
        self._new_parent = attribs['_new_parent']
 
1037
        self._new_executability = dict((k, bool(v)) for k, v in
 
1038
            attribs['_new_executability'].items())
 
1039
        self._new_id = attribs['_new_id']
 
1040
        self._r_new_id = dict((v, k) for k, v in self._new_id.items())
 
1041
        self._tree_path_ids = {}
 
1042
        self._tree_id_paths = {}
 
1043
        for bytepath, trans_id in attribs['_tree_path_ids'].items():
 
1044
            path = bytepath.decode('utf-8')
 
1045
            self._tree_path_ids[path] = trans_id
 
1046
            self._tree_id_paths[trans_id] = path
 
1047
        self._removed_id = set(attribs['_removed_id'])
 
1048
        self._removed_contents = set(attribs['_removed_contents'])
 
1049
        self._non_present_ids = attribs['_non_present_ids']
 
1050
        for ((trans_id, kind),), content in records:
 
1051
            if kind == 'file':
 
1052
                mpdiff = multiparent.MultiParent.from_patch(content)
 
1053
                lines = mpdiff.to_lines(self._get_parents_texts(trans_id))
 
1054
                self.create_file(lines, trans_id)
 
1055
            if kind == 'directory':
 
1056
                self.create_directory(trans_id)
 
1057
            if kind == 'symlink':
 
1058
                self.create_symlink(content.decode('utf-8'), trans_id)
 
1059
 
 
1060
 
 
1061
class DiskTreeTransform(TreeTransformBase):
 
1062
    """Tree transform storing its contents on disk."""
 
1063
 
 
1064
    def __init__(self, tree, limbodir, pb=DummyProgress(),
 
1065
                 case_sensitive=True):
 
1066
        """Constructor.
 
1067
        :param tree: The tree that will be transformed, but not necessarily
 
1068
            the output tree.
 
1069
        :param limbodir: A directory where new files can be stored until
 
1070
            they are installed in their proper places
 
1071
        :param pb: A ProgressBar indicating how much progress is being made
 
1072
        :param case_sensitive: If True, the target of the transform is
 
1073
            case sensitive, not just case preserving.
 
1074
        """
 
1075
        TreeTransformBase.__init__(self, tree, pb, case_sensitive)
 
1076
        self._limbodir = limbodir
 
1077
        self._deletiondir = None
 
1078
        # A mapping of transform ids to their limbo filename
 
1079
        self._limbo_files = {}
 
1080
        # A mapping of transform ids to a set of the transform ids of children
 
1081
        # that their limbo directory has
 
1082
        self._limbo_children = {}
 
1083
        # Map transform ids to maps of child filename to child transform id
 
1084
        self._limbo_children_names = {}
 
1085
        # List of transform ids that need to be renamed from limbo into place
 
1086
        self._needs_rename = set()
 
1087
 
 
1088
    def finalize(self):
 
1089
        """Release the working tree lock, if held, clean up limbo dir.
 
1090
 
 
1091
        This is required if apply has not been invoked, but can be invoked
 
1092
        even after apply.
 
1093
        """
 
1094
        if self._tree is None:
 
1095
            return
 
1096
        try:
 
1097
            entries = [(self._limbo_name(t), t, k) for t, k in
 
1098
                       self._new_contents.iteritems()]
 
1099
            entries.sort(reverse=True)
 
1100
            for path, trans_id, kind in entries:
 
1101
                delete_any(path)
 
1102
            try:
 
1103
                delete_any(self._limbodir)
 
1104
            except OSError:
 
1105
                # We don't especially care *why* the dir is immortal.
 
1106
                raise ImmortalLimbo(self._limbodir)
 
1107
            try:
 
1108
                if self._deletiondir is not None:
 
1109
                    delete_any(self._deletiondir)
 
1110
            except OSError:
 
1111
                raise errors.ImmortalPendingDeletion(self._deletiondir)
 
1112
        finally:
 
1113
            TreeTransformBase.finalize(self)
 
1114
 
 
1115
    def _limbo_name(self, trans_id):
 
1116
        """Generate the limbo name of a file"""
 
1117
        limbo_name = self._limbo_files.get(trans_id)
 
1118
        if limbo_name is None:
 
1119
            limbo_name = self._generate_limbo_path(trans_id)
 
1120
            self._limbo_files[trans_id] = limbo_name
 
1121
        return limbo_name
 
1122
 
 
1123
    def _generate_limbo_path(self, trans_id):
 
1124
        """Generate a limbo path using the trans_id as the relative path.
 
1125
 
 
1126
        This is suitable as a fallback, and when the transform should not be
 
1127
        sensitive to the path encoding of the limbo directory.
 
1128
        """
 
1129
        self._needs_rename.add(trans_id)
 
1130
        return pathjoin(self._limbodir, trans_id)
 
1131
 
 
1132
    def adjust_path(self, name, parent, trans_id):
 
1133
        previous_parent = self._new_parent.get(trans_id)
 
1134
        previous_name = self._new_name.get(trans_id)
 
1135
        TreeTransformBase.adjust_path(self, name, parent, trans_id)
 
1136
        if (trans_id in self._limbo_files and
 
1137
            trans_id not in self._needs_rename):
 
1138
            self._rename_in_limbo([trans_id])
 
1139
            if previous_parent != parent:
 
1140
                self._limbo_children[previous_parent].remove(trans_id)
 
1141
            if previous_parent != parent or previous_name != name:
 
1142
                del self._limbo_children_names[previous_parent][previous_name]
 
1143
 
 
1144
    def _rename_in_limbo(self, trans_ids):
 
1145
        """Fix limbo names so that the right final path is produced.
 
1146
 
 
1147
        This means we outsmarted ourselves-- we tried to avoid renaming
 
1148
        these files later by creating them with their final names in their
 
1149
        final parents.  But now the previous name or parent is no longer
 
1150
        suitable, so we have to rename them.
 
1151
 
 
1152
        Even for trans_ids that have no new contents, we must remove their
 
1153
        entries from _limbo_files, because they are now stale.
 
1154
        """
 
1155
        for trans_id in trans_ids:
 
1156
            old_path = self._limbo_files.pop(trans_id)
 
1157
            if trans_id not in self._new_contents:
 
1158
                continue
 
1159
            new_path = self._limbo_name(trans_id)
 
1160
            os.rename(old_path, new_path)
 
1161
 
 
1162
    def create_file(self, contents, trans_id, mode_id=None):
 
1163
        """Schedule creation of a new file.
 
1164
 
 
1165
        See also new_file.
 
1166
 
 
1167
        Contents is an iterator of strings, all of which will be written
 
1168
        to the target destination.
 
1169
 
 
1170
        New file takes the permissions of any existing file with that id,
 
1171
        unless mode_id is specified.
 
1172
        """
 
1173
        name = self._limbo_name(trans_id)
 
1174
        f = open(name, 'wb')
 
1175
        try:
 
1176
            try:
 
1177
                unique_add(self._new_contents, trans_id, 'file')
 
1178
            except:
 
1179
                # Clean up the file, it never got registered so
 
1180
                # TreeTransform.finalize() won't clean it up.
 
1181
                f.close()
 
1182
                os.unlink(name)
 
1183
                raise
 
1184
 
 
1185
            f.writelines(contents)
 
1186
        finally:
 
1187
            f.close()
 
1188
        self._set_mode(trans_id, mode_id, S_ISREG)
 
1189
 
 
1190
    def _read_file_chunks(self, trans_id):
 
1191
        cur_file = open(self._limbo_name(trans_id), 'rb')
 
1192
        try:
 
1193
            return cur_file.readlines()
 
1194
        finally:
 
1195
            cur_file.close()
 
1196
 
 
1197
    def _read_symlink_target(self, trans_id):
 
1198
        return os.readlink(self._limbo_name(trans_id))
 
1199
 
 
1200
    def create_hardlink(self, path, trans_id):
 
1201
        """Schedule creation of a hard link"""
 
1202
        name = self._limbo_name(trans_id)
 
1203
        try:
 
1204
            os.link(path, name)
 
1205
        except OSError, e:
 
1206
            if e.errno != errno.EPERM:
 
1207
                raise
 
1208
            raise errors.HardLinkNotSupported(path)
 
1209
        try:
 
1210
            unique_add(self._new_contents, trans_id, 'file')
 
1211
        except:
 
1212
            # Clean up the file, it never got registered so
 
1213
            # TreeTransform.finalize() won't clean it up.
 
1214
            os.unlink(name)
 
1215
            raise
 
1216
 
 
1217
    def create_directory(self, trans_id):
 
1218
        """Schedule creation of a new directory.
 
1219
 
 
1220
        See also new_directory.
 
1221
        """
 
1222
        os.mkdir(self._limbo_name(trans_id))
 
1223
        unique_add(self._new_contents, trans_id, 'directory')
 
1224
 
 
1225
    def create_symlink(self, target, trans_id):
 
1226
        """Schedule creation of a new symbolic link.
 
1227
 
 
1228
        target is a bytestring.
 
1229
        See also new_symlink.
 
1230
        """
 
1231
        if has_symlinks():
 
1232
            os.symlink(target, self._limbo_name(trans_id))
 
1233
            unique_add(self._new_contents, trans_id, 'symlink')
 
1234
        else:
 
1235
            try:
 
1236
                path = FinalPaths(self).get_path(trans_id)
 
1237
            except KeyError:
 
1238
                path = None
 
1239
            raise UnableCreateSymlink(path=path)
 
1240
 
 
1241
    def cancel_creation(self, trans_id):
 
1242
        """Cancel the creation of new file contents."""
 
1243
        del self._new_contents[trans_id]
 
1244
        children = self._limbo_children.get(trans_id)
 
1245
        # if this is a limbo directory with children, move them before removing
 
1246
        # the directory
 
1247
        if children is not None:
 
1248
            self._rename_in_limbo(children)
 
1249
            del self._limbo_children[trans_id]
 
1250
            del self._limbo_children_names[trans_id]
 
1251
        delete_any(self._limbo_name(trans_id))
 
1252
 
 
1253
 
 
1254
class TreeTransform(DiskTreeTransform):
 
1255
    """Represent a tree transformation.
 
1256
 
 
1257
    This object is designed to support incremental generation of the transform,
 
1258
    in any order.
 
1259
 
 
1260
    However, it gives optimum performance when parent directories are created
 
1261
    before their contents.  The transform is then able to put child files
 
1262
    directly in their parent directory, avoiding later renames.
 
1263
 
 
1264
    It is easy to produce malformed transforms, but they are generally
 
1265
    harmless.  Attempting to apply a malformed transform will cause an
 
1266
    exception to be raised before any modifications are made to the tree.
 
1267
 
 
1268
    Many kinds of malformed transforms can be corrected with the
 
1269
    resolve_conflicts function.  The remaining ones indicate programming error,
 
1270
    such as trying to create a file with no path.
 
1271
 
 
1272
    Two sets of file creation methods are supplied.  Convenience methods are:
 
1273
     * new_file
 
1274
     * new_directory
 
1275
     * new_symlink
 
1276
 
 
1277
    These are composed of the low-level methods:
 
1278
     * create_path
 
1279
     * create_file or create_directory or create_symlink
 
1280
     * version_file
 
1281
     * set_executability
 
1282
 
 
1283
    Transform/Transaction ids
 
1284
    -------------------------
 
1285
    trans_ids are temporary ids assigned to all files involved in a transform.
 
1286
    It's possible, even common, that not all files in the Tree have trans_ids.
 
1287
 
 
1288
    trans_ids are used because filenames and file_ids are not good enough
 
1289
    identifiers; filenames change, and not all files have file_ids.  File-ids
 
1290
    are also associated with trans-ids, so that moving a file moves its
 
1291
    file-id.
 
1292
 
 
1293
    trans_ids are only valid for the TreeTransform that generated them.
 
1294
 
 
1295
    Limbo
 
1296
    -----
 
1297
    Limbo is a temporary directory use to hold new versions of files.
 
1298
    Files are added to limbo by create_file, create_directory, create_symlink,
 
1299
    and their convenience variants (new_*).  Files may be removed from limbo
 
1300
    using cancel_creation.  Files are renamed from limbo into their final
 
1301
    location as part of TreeTransform.apply
 
1302
 
 
1303
    Limbo must be cleaned up, by either calling TreeTransform.apply or
 
1304
    calling TreeTransform.finalize.
 
1305
 
 
1306
    Files are placed into limbo inside their parent directories, where
 
1307
    possible.  This reduces subsequent renames, and makes operations involving
 
1308
    lots of files faster.  This optimization is only possible if the parent
 
1309
    directory is created *before* creating any of its children, so avoid
 
1310
    creating children before parents, where possible.
 
1311
 
 
1312
    Pending-deletion
 
1313
    ----------------
 
1314
    This temporary directory is used by _FileMover for storing files that are
 
1315
    about to be deleted.  In case of rollback, the files will be restored.
 
1316
    FileMover does not delete files until it is sure that a rollback will not
 
1317
    happen.
 
1318
    """
 
1319
    def __init__(self, tree, pb=DummyProgress()):
 
1320
        """Note: a tree_write lock is taken on the tree.
 
1321
 
 
1322
        Use TreeTransform.finalize() to release the lock (can be omitted if
 
1323
        TreeTransform.apply() called).
 
1324
        """
 
1325
        tree.lock_tree_write()
 
1326
 
 
1327
        try:
 
1328
            limbodir = urlutils.local_path_from_url(
 
1329
                tree._transport.abspath('limbo'))
 
1330
            try:
 
1331
                os.mkdir(limbodir)
 
1332
            except OSError, e:
 
1333
                if e.errno == errno.EEXIST:
 
1334
                    raise ExistingLimbo(limbodir)
 
1335
            deletiondir = urlutils.local_path_from_url(
 
1336
                tree._transport.abspath('pending-deletion'))
 
1337
            try:
 
1338
                os.mkdir(deletiondir)
 
1339
            except OSError, e:
 
1340
                if e.errno == errno.EEXIST:
 
1341
                    raise errors.ExistingPendingDeletion(deletiondir)
 
1342
        except:
 
1343
            tree.unlock()
 
1344
            raise
 
1345
 
 
1346
        # Cache of realpath results, to speed up canonical_path
 
1347
        self._realpaths = {}
 
1348
        # Cache of relpath results, to speed up canonical_path
 
1349
        self._relpaths = {}
 
1350
        DiskTreeTransform.__init__(self, tree, limbodir, pb,
 
1351
                                   tree.case_sensitive)
 
1352
        self._deletiondir = deletiondir
 
1353
 
 
1354
    def canonical_path(self, path):
 
1355
        """Get the canonical tree-relative path"""
 
1356
        # don't follow final symlinks
 
1357
        abs = self._tree.abspath(path)
 
1358
        if abs in self._relpaths:
 
1359
            return self._relpaths[abs]
 
1360
        dirname, basename = os.path.split(abs)
 
1361
        if dirname not in self._realpaths:
 
1362
            self._realpaths[dirname] = os.path.realpath(dirname)
 
1363
        dirname = self._realpaths[dirname]
 
1364
        abs = pathjoin(dirname, basename)
 
1365
        if dirname in self._relpaths:
 
1366
            relpath = pathjoin(self._relpaths[dirname], basename)
 
1367
            relpath = relpath.rstrip('/\\')
 
1368
        else:
 
1369
            relpath = self._tree.relpath(abs)
 
1370
        self._relpaths[abs] = relpath
 
1371
        return relpath
 
1372
 
 
1373
    def tree_kind(self, trans_id):
 
1374
        """Determine the file kind in the working tree.
 
1375
 
 
1376
        Raises NoSuchFile if the file does not exist
 
1377
        """
 
1378
        path = self._tree_id_paths.get(trans_id)
 
1379
        if path is None:
 
1380
            raise NoSuchFile(None)
 
1381
        try:
 
1382
            return file_kind(self._tree.abspath(path))
 
1383
        except OSError, e:
 
1384
            if e.errno != errno.ENOENT:
 
1385
                raise
 
1386
            else:
 
1387
                raise NoSuchFile(path)
 
1388
 
 
1389
    def _set_mode(self, trans_id, mode_id, typefunc):
 
1390
        """Set the mode of new file contents.
 
1391
        The mode_id is the existing file to get the mode from (often the same
 
1392
        as trans_id).  The operation is only performed if there's a mode match
 
1393
        according to typefunc.
 
1394
        """
 
1395
        if mode_id is None:
 
1396
            mode_id = trans_id
 
1397
        try:
 
1398
            old_path = self._tree_id_paths[mode_id]
 
1399
        except KeyError:
 
1400
            return
 
1401
        try:
 
1402
            mode = os.stat(self._tree.abspath(old_path)).st_mode
 
1403
        except OSError, e:
 
1404
            if e.errno in (errno.ENOENT, errno.ENOTDIR):
 
1405
                # Either old_path doesn't exist, or the parent of the
 
1406
                # target is not a directory (but will be one eventually)
 
1407
                # Either way, we know it doesn't exist *right now*
 
1408
                # See also bug #248448
 
1409
                return
 
1410
            else:
 
1411
                raise
 
1412
        if typefunc(mode):
 
1413
            os.chmod(self._limbo_name(trans_id), mode)
 
1414
 
 
1415
    def iter_tree_children(self, parent_id):
 
1416
        """Iterate through the entry's tree children, if any"""
 
1417
        try:
 
1418
            path = self._tree_id_paths[parent_id]
 
1419
        except KeyError:
 
1420
            return
 
1421
        try:
 
1422
            children = os.listdir(self._tree.abspath(path))
 
1423
        except OSError, e:
 
1424
            if not (osutils._is_error_enotdir(e)
 
1425
                    or e.errno in (errno.ENOENT, errno.ESRCH)):
 
1426
                raise
 
1427
            return
 
1428
 
 
1429
        for child in children:
 
1430
            childpath = joinpath(path, child)
 
1431
            if self._tree.is_control_filename(childpath):
 
1432
                continue
 
1433
            yield self.trans_id_tree_path(childpath)
 
1434
 
 
1435
    def _generate_limbo_path(self, trans_id):
 
1436
        """Generate a limbo path using the final path if possible.
 
1437
 
 
1438
        This optimizes the performance of applying the tree transform by
 
1439
        avoiding renames.  These renames can be avoided only when the parent
 
1440
        directory is already scheduled for creation.
 
1441
 
 
1442
        If the final path cannot be used, falls back to using the trans_id as
 
1443
        the relpath.
 
1444
        """
 
1445
        parent = self._new_parent.get(trans_id)
 
1446
        # if the parent directory is already in limbo (e.g. when building a
 
1447
        # tree), choose a limbo name inside the parent, to reduce further
 
1448
        # renames.
 
1449
        use_direct_path = False
 
1450
        if self._new_contents.get(parent) == 'directory':
 
1451
            filename = self._new_name.get(trans_id)
 
1452
            if filename is not None:
 
1453
                if parent not in self._limbo_children:
 
1454
                    self._limbo_children[parent] = set()
 
1455
                    self._limbo_children_names[parent] = {}
 
1456
                    use_direct_path = True
 
1457
                # the direct path can only be used if no other file has
 
1458
                # already taken this pathname, i.e. if the name is unused, or
 
1459
                # if it is already associated with this trans_id.
 
1460
                elif self._case_sensitive_target:
 
1461
                    if (self._limbo_children_names[parent].get(filename)
 
1462
                        in (trans_id, None)):
 
1463
                        use_direct_path = True
 
1464
                else:
 
1465
                    for l_filename, l_trans_id in\
 
1466
                        self._limbo_children_names[parent].iteritems():
 
1467
                        if l_trans_id == trans_id:
 
1468
                            continue
 
1469
                        if l_filename.lower() == filename.lower():
 
1470
                            break
 
1471
                    else:
 
1472
                        use_direct_path = True
 
1473
 
 
1474
        if not use_direct_path:
 
1475
            return DiskTreeTransform._generate_limbo_path(self, trans_id)
 
1476
 
 
1477
        limbo_name = pathjoin(self._limbo_files[parent], filename)
 
1478
        self._limbo_children[parent].add(trans_id)
 
1479
        self._limbo_children_names[parent][filename] = trans_id
 
1480
        return limbo_name
 
1481
 
 
1482
 
 
1483
    def apply(self, no_conflicts=False, precomputed_delta=None, _mover=None):
 
1484
        """Apply all changes to the inventory and filesystem.
 
1485
 
 
1486
        If filesystem or inventory conflicts are present, MalformedTransform
 
1487
        will be thrown.
 
1488
 
 
1489
        If apply succeeds, finalize is not necessary.
 
1490
 
 
1491
        :param no_conflicts: if True, the caller guarantees there are no
 
1492
            conflicts, so no check is made.
 
1493
        :param precomputed_delta: An inventory delta to use instead of
 
1494
            calculating one.
 
1495
        :param _mover: Supply an alternate FileMover, for testing
 
1496
        """
 
1497
        if not no_conflicts:
 
1498
            self._check_malformed()
 
1499
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1500
        try:
 
1501
            if precomputed_delta is None:
 
1502
                child_pb.update('Apply phase', 0, 2)
 
1503
                inventory_delta = self._generate_inventory_delta()
 
1504
                offset = 1
 
1505
            else:
 
1506
                inventory_delta = precomputed_delta
 
1507
                offset = 0
 
1508
            if _mover is None:
 
1509
                mover = _FileMover()
 
1510
            else:
 
1511
                mover = _mover
 
1512
            try:
 
1513
                child_pb.update('Apply phase', 0 + offset, 2 + offset)
 
1514
                self._apply_removals(mover)
 
1515
                child_pb.update('Apply phase', 1 + offset, 2 + offset)
 
1516
                modified_paths = self._apply_insertions(mover)
 
1517
            except:
 
1518
                mover.rollback()
 
1519
                raise
 
1520
            else:
 
1521
                mover.apply_deletions()
 
1522
        finally:
 
1523
            child_pb.finished()
 
1524
        self._tree.apply_inventory_delta(inventory_delta)
 
1525
        self._done = True
 
1526
        self.finalize()
 
1527
        return _TransformResults(modified_paths, self.rename_count)
 
1528
 
 
1529
    def _generate_inventory_delta(self):
 
1530
        """Generate an inventory delta for the current transform."""
 
1531
        inventory_delta = []
 
1532
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1533
        new_paths = self._inventory_altered()
 
1534
        total_entries = len(new_paths) + len(self._removed_id)
 
1535
        try:
 
1536
            for num, trans_id in enumerate(self._removed_id):
 
1537
                if (num % 10) == 0:
 
1538
                    child_pb.update('removing file', num, total_entries)
 
1539
                if trans_id == self._new_root:
 
1540
                    file_id = self._tree.get_root_id()
 
1541
                else:
 
1542
                    file_id = self.tree_file_id(trans_id)
 
1543
                # File-id isn't really being deleted, just moved
 
1544
                if file_id in self._r_new_id:
 
1545
                    continue
 
1546
                path = self._tree_id_paths[trans_id]
 
1547
                inventory_delta.append((path, None, file_id, None))
 
1548
            new_path_file_ids = dict((t, self.final_file_id(t)) for p, t in
 
1549
                                     new_paths)
 
1550
            entries = self._tree.iter_entries_by_dir(
 
1551
                new_path_file_ids.values())
 
1552
            old_paths = dict((e.file_id, p) for p, e in entries)
 
1553
            final_kinds = {}
 
1554
            for num, (path, trans_id) in enumerate(new_paths):
 
1555
                if (num % 10) == 0:
 
1556
                    child_pb.update('adding file',
 
1557
                                    num + len(self._removed_id), total_entries)
 
1558
                file_id = new_path_file_ids[trans_id]
 
1559
                if file_id is None:
 
1560
                    continue
 
1561
                needs_entry = False
 
1562
                try:
 
1563
                    kind = self.final_kind(trans_id)
 
1564
                except NoSuchFile:
 
1565
                    kind = self._tree.stored_kind(file_id)
 
1566
                parent_trans_id = self.final_parent(trans_id)
 
1567
                parent_file_id = new_path_file_ids.get(parent_trans_id)
 
1568
                if parent_file_id is None:
 
1569
                    parent_file_id = self.final_file_id(parent_trans_id)
 
1570
                if trans_id in self._new_reference_revision:
 
1571
                    new_entry = inventory.TreeReference(
 
1572
                        file_id,
 
1573
                        self._new_name[trans_id],
 
1574
                        self.final_file_id(self._new_parent[trans_id]),
 
1575
                        None, self._new_reference_revision[trans_id])
 
1576
                else:
 
1577
                    new_entry = inventory.make_entry(kind,
 
1578
                        self.final_name(trans_id),
 
1579
                        parent_file_id, file_id)
 
1580
                old_path = old_paths.get(new_entry.file_id)
 
1581
                new_executability = self._new_executability.get(trans_id)
 
1582
                if new_executability is not None:
 
1583
                    new_entry.executable = new_executability
 
1584
                inventory_delta.append(
 
1585
                    (old_path, path, new_entry.file_id, new_entry))
 
1586
        finally:
 
1587
            child_pb.finished()
 
1588
        return inventory_delta
 
1589
 
 
1590
    def _apply_removals(self, mover):
 
1591
        """Perform tree operations that remove directory/inventory names.
 
1592
 
 
1593
        That is, delete files that are to be deleted, and put any files that
 
1594
        need renaming into limbo.  This must be done in strict child-to-parent
 
1595
        order.
 
1596
 
 
1597
        If inventory_delta is None, no inventory delta generation is performed.
 
1598
        """
 
1599
        tree_paths = list(self._tree_path_ids.iteritems())
 
1600
        tree_paths.sort(reverse=True)
 
1601
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1602
        try:
 
1603
            for num, data in enumerate(tree_paths):
 
1604
                path, trans_id = data
 
1605
                child_pb.update('removing file', num, len(tree_paths))
 
1606
                full_path = self._tree.abspath(path)
 
1607
                if trans_id in self._removed_contents:
 
1608
                    delete_path = os.path.join(self._deletiondir, trans_id)
 
1609
                    mover.pre_delete(full_path, delete_path)
 
1610
                elif (trans_id in self._new_name
 
1611
                      or trans_id in self._new_parent):
 
1612
                    try:
 
1613
                        mover.rename(full_path, self._limbo_name(trans_id))
 
1614
                    except OSError, e:
 
1615
                        if e.errno != errno.ENOENT:
 
1616
                            raise
 
1617
                    else:
 
1618
                        self.rename_count += 1
 
1619
        finally:
 
1620
            child_pb.finished()
 
1621
 
 
1622
    def _apply_insertions(self, mover):
 
1623
        """Perform tree operations that insert directory/inventory names.
 
1624
 
 
1625
        That is, create any files that need to be created, and restore from
 
1626
        limbo any files that needed renaming.  This must be done in strict
 
1627
        parent-to-child order.
 
1628
 
 
1629
        If inventory_delta is None, no inventory delta is calculated, and
 
1630
        no list of modified paths is returned.
 
1631
        """
 
1632
        new_paths = self.new_paths(filesystem_only=True)
 
1633
        modified_paths = []
 
1634
        new_path_file_ids = dict((t, self.final_file_id(t)) for p, t in
 
1635
                                 new_paths)
 
1636
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1637
        try:
 
1638
            for num, (path, trans_id) in enumerate(new_paths):
 
1639
                if (num % 10) == 0:
 
1640
                    child_pb.update('adding file', num, len(new_paths))
 
1641
                full_path = self._tree.abspath(path)
 
1642
                if trans_id in self._needs_rename:
 
1643
                    try:
 
1644
                        mover.rename(self._limbo_name(trans_id), full_path)
 
1645
                    except OSError, e:
 
1646
                        # We may be renaming a dangling inventory id
 
1647
                        if e.errno != errno.ENOENT:
 
1648
                            raise
 
1649
                    else:
 
1650
                        self.rename_count += 1
 
1651
                if (trans_id in self._new_contents or
 
1652
                    self.path_changed(trans_id)):
 
1653
                    if trans_id in self._new_contents:
 
1654
                        modified_paths.append(full_path)
 
1655
                if trans_id in self._new_executability:
 
1656
                    self._set_executability(path, trans_id)
 
1657
        finally:
 
1658
            child_pb.finished()
 
1659
        self._new_contents.clear()
 
1660
        return modified_paths
 
1661
 
 
1662
 
 
1663
class TransformPreview(DiskTreeTransform):
 
1664
    """A TreeTransform for generating preview trees.
 
1665
 
 
1666
    Unlike TreeTransform, this version works when the input tree is a
 
1667
    RevisionTree, rather than a WorkingTree.  As a result, it tends to ignore
 
1668
    unversioned files in the input tree.
 
1669
    """
 
1670
 
 
1671
    def __init__(self, tree, pb=DummyProgress(), case_sensitive=True):
 
1672
        tree.lock_read()
 
1673
        limbodir = osutils.mkdtemp(prefix='bzr-limbo-')
 
1674
        DiskTreeTransform.__init__(self, tree, limbodir, pb, case_sensitive)
 
1675
 
 
1676
    def canonical_path(self, path):
 
1677
        return path
 
1678
 
 
1679
    def tree_kind(self, trans_id):
 
1680
        path = self._tree_id_paths.get(trans_id)
 
1681
        if path is None:
 
1682
            raise NoSuchFile(None)
 
1683
        file_id = self._tree.path2id(path)
 
1684
        return self._tree.kind(file_id)
 
1685
 
 
1686
    def _set_mode(self, trans_id, mode_id, typefunc):
 
1687
        """Set the mode of new file contents.
 
1688
        The mode_id is the existing file to get the mode from (often the same
 
1689
        as trans_id).  The operation is only performed if there's a mode match
 
1690
        according to typefunc.
 
1691
        """
 
1692
        # is it ok to ignore this?  probably
 
1693
        pass
 
1694
 
 
1695
    def iter_tree_children(self, parent_id):
 
1696
        """Iterate through the entry's tree children, if any"""
 
1697
        try:
 
1698
            path = self._tree_id_paths[parent_id]
 
1699
        except KeyError:
 
1700
            return
 
1701
        file_id = self.tree_file_id(parent_id)
 
1702
        if file_id is None:
 
1703
            return
 
1704
        entry = self._tree.iter_entries_by_dir([file_id]).next()[1]
 
1705
        children = getattr(entry, 'children', {})
 
1706
        for child in children:
 
1707
            childpath = joinpath(path, child)
 
1708
            yield self.trans_id_tree_path(childpath)
 
1709
 
 
1710
 
 
1711
class _PreviewTree(tree.Tree):
 
1712
    """Partial implementation of Tree to support show_diff_trees"""
 
1713
 
 
1714
    def __init__(self, transform):
 
1715
        self._transform = transform
 
1716
        self._final_paths = FinalPaths(transform)
 
1717
        self.__by_parent = None
 
1718
        self._parent_ids = []
 
1719
        self._all_children_cache = {}
 
1720
        self._path2trans_id_cache = {}
 
1721
        self._final_name_cache = {}
 
1722
        self._iter_changes_cache = dict((c[0], c) for c in
 
1723
                                        self._transform.iter_changes())
 
1724
 
 
1725
    def _content_change(self, file_id):
 
1726
        """Return True if the content of this file changed"""
 
1727
        changes = self._iter_changes_cache.get(file_id)
 
1728
        # changes[2] is true if the file content changed.  See
 
1729
        # InterTree.iter_changes.
 
1730
        return (changes is not None and changes[2])
 
1731
 
 
1732
    def _get_repository(self):
 
1733
        repo = getattr(self._transform._tree, '_repository', None)
 
1734
        if repo is None:
 
1735
            repo = self._transform._tree.branch.repository
 
1736
        return repo
 
1737
 
 
1738
    def _iter_parent_trees(self):
 
1739
        for revision_id in self.get_parent_ids():
 
1740
            try:
 
1741
                yield self.revision_tree(revision_id)
 
1742
            except errors.NoSuchRevisionInTree:
 
1743
                yield self._get_repository().revision_tree(revision_id)
 
1744
 
 
1745
    def _get_file_revision(self, file_id, vf, tree_revision):
 
1746
        parent_keys = [(file_id, self._file_revision(t, file_id)) for t in
 
1747
                       self._iter_parent_trees()]
 
1748
        vf.add_lines((file_id, tree_revision), parent_keys,
 
1749
                     self.get_file(file_id).readlines())
 
1750
        repo = self._get_repository()
 
1751
        base_vf = repo.texts
 
1752
        if base_vf not in vf.fallback_versionedfiles:
 
1753
            vf.fallback_versionedfiles.append(base_vf)
 
1754
        return tree_revision
 
1755
 
 
1756
    def _stat_limbo_file(self, file_id):
 
1757
        trans_id = self._transform.trans_id_file_id(file_id)
 
1758
        name = self._transform._limbo_name(trans_id)
 
1759
        return os.lstat(name)
 
1760
 
 
1761
    @property
 
1762
    def _by_parent(self):
 
1763
        if self.__by_parent is None:
 
1764
            self.__by_parent = self._transform.by_parent()
 
1765
        return self.__by_parent
 
1766
 
 
1767
    def _comparison_data(self, entry, path):
 
1768
        kind, size, executable, link_or_sha1 = self.path_content_summary(path)
 
1769
        if kind == 'missing':
 
1770
            kind = None
 
1771
            executable = False
 
1772
        else:
 
1773
            file_id = self._transform.final_file_id(self._path2trans_id(path))
 
1774
            executable = self.is_executable(file_id, path)
 
1775
        return kind, executable, None
 
1776
 
 
1777
    def lock_read(self):
 
1778
        # Perhaps in theory, this should lock the TreeTransform?
 
1779
        pass
 
1780
 
 
1781
    def unlock(self):
 
1782
        pass
 
1783
 
 
1784
    @property
 
1785
    def inventory(self):
 
1786
        """This Tree does not use inventory as its backing data."""
 
1787
        raise NotImplementedError(_PreviewTree.inventory)
 
1788
 
 
1789
    def get_root_id(self):
 
1790
        return self._transform.final_file_id(self._transform.root)
 
1791
 
 
1792
    def all_file_ids(self):
 
1793
        tree_ids = set(self._transform._tree.all_file_ids())
 
1794
        tree_ids.difference_update(self._transform.tree_file_id(t)
 
1795
                                   for t in self._transform._removed_id)
 
1796
        tree_ids.update(self._transform._new_id.values())
 
1797
        return tree_ids
 
1798
 
 
1799
    def __iter__(self):
 
1800
        return iter(self.all_file_ids())
 
1801
 
 
1802
    def _has_id(self, file_id, fallback_check):
 
1803
        if file_id in self._transform._r_new_id:
 
1804
            return True
 
1805
        elif file_id in set([self._transform.tree_file_id(trans_id) for
 
1806
            trans_id in self._transform._removed_id]):
 
1807
            return False
 
1808
        else:
 
1809
            return fallback_check(file_id)
 
1810
 
 
1811
    def has_id(self, file_id):
 
1812
        return self._has_id(file_id, self._transform._tree.has_id)
 
1813
 
 
1814
    def has_or_had_id(self, file_id):
 
1815
        return self._has_id(file_id, self._transform._tree.has_or_had_id)
 
1816
 
 
1817
    def _path2trans_id(self, path):
 
1818
        # We must not use None here, because that is a valid value to store.
 
1819
        trans_id = self._path2trans_id_cache.get(path, object)
 
1820
        if trans_id is not object:
 
1821
            return trans_id
 
1822
        segments = splitpath(path)
 
1823
        cur_parent = self._transform.root
 
1824
        for cur_segment in segments:
 
1825
            for child in self._all_children(cur_parent):
 
1826
                final_name = self._final_name_cache.get(child)
 
1827
                if final_name is None:
 
1828
                    final_name = self._transform.final_name(child)
 
1829
                    self._final_name_cache[child] = final_name
 
1830
                if final_name == cur_segment:
 
1831
                    cur_parent = child
 
1832
                    break
 
1833
            else:
 
1834
                self._path2trans_id_cache[path] = None
 
1835
                return None
 
1836
        self._path2trans_id_cache[path] = cur_parent
 
1837
        return cur_parent
 
1838
 
 
1839
    def path2id(self, path):
 
1840
        return self._transform.final_file_id(self._path2trans_id(path))
 
1841
 
 
1842
    def id2path(self, file_id):
 
1843
        trans_id = self._transform.trans_id_file_id(file_id)
 
1844
        try:
 
1845
            return self._final_paths._determine_path(trans_id)
 
1846
        except NoFinalPath:
 
1847
            raise errors.NoSuchId(self, file_id)
 
1848
 
 
1849
    def _all_children(self, trans_id):
 
1850
        children = self._all_children_cache.get(trans_id)
 
1851
        if children is not None:
 
1852
            return children
 
1853
        children = set(self._transform.iter_tree_children(trans_id))
 
1854
        # children in the _new_parent set are provided by _by_parent.
 
1855
        children.difference_update(self._transform._new_parent.keys())
 
1856
        children.update(self._by_parent.get(trans_id, []))
 
1857
        self._all_children_cache[trans_id] = children
 
1858
        return children
 
1859
 
 
1860
    def iter_children(self, file_id):
 
1861
        trans_id = self._transform.trans_id_file_id(file_id)
 
1862
        for child_trans_id in self._all_children(trans_id):
 
1863
            yield self._transform.final_file_id(child_trans_id)
 
1864
 
 
1865
    def extras(self):
 
1866
        possible_extras = set(self._transform.trans_id_tree_path(p) for p
 
1867
                              in self._transform._tree.extras())
 
1868
        possible_extras.update(self._transform._new_contents)
 
1869
        possible_extras.update(self._transform._removed_id)
 
1870
        for trans_id in possible_extras:
 
1871
            if self._transform.final_file_id(trans_id) is None:
 
1872
                yield self._final_paths._determine_path(trans_id)
 
1873
 
 
1874
    def _make_inv_entries(self, ordered_entries, specific_file_ids=None,
 
1875
        yield_parents=False):
 
1876
        for trans_id, parent_file_id in ordered_entries:
 
1877
            file_id = self._transform.final_file_id(trans_id)
 
1878
            if file_id is None:
 
1879
                continue
 
1880
            if (specific_file_ids is not None
 
1881
                and file_id not in specific_file_ids):
 
1882
                continue
 
1883
            try:
 
1884
                kind = self._transform.final_kind(trans_id)
 
1885
            except NoSuchFile:
 
1886
                kind = self._transform._tree.stored_kind(file_id)
 
1887
            new_entry = inventory.make_entry(
 
1888
                kind,
 
1889
                self._transform.final_name(trans_id),
 
1890
                parent_file_id, file_id)
 
1891
            yield new_entry, trans_id
 
1892
 
 
1893
    def _list_files_by_dir(self):
 
1894
        todo = [ROOT_PARENT]
 
1895
        ordered_ids = []
 
1896
        while len(todo) > 0:
 
1897
            parent = todo.pop()
 
1898
            parent_file_id = self._transform.final_file_id(parent)
 
1899
            children = list(self._all_children(parent))
 
1900
            paths = dict(zip(children, self._final_paths.get_paths(children)))
 
1901
            children.sort(key=paths.get)
 
1902
            todo.extend(reversed(children))
 
1903
            for trans_id in children:
 
1904
                ordered_ids.append((trans_id, parent_file_id))
 
1905
        return ordered_ids
 
1906
 
 
1907
    def iter_entries_by_dir(self, specific_file_ids=None, yield_parents=False):
 
1908
        # This may not be a maximally efficient implementation, but it is
 
1909
        # reasonably straightforward.  An implementation that grafts the
 
1910
        # TreeTransform changes onto the tree's iter_entries_by_dir results
 
1911
        # might be more efficient, but requires tricky inferences about stack
 
1912
        # position.
 
1913
        ordered_ids = self._list_files_by_dir()
 
1914
        for entry, trans_id in self._make_inv_entries(ordered_ids,
 
1915
            specific_file_ids, yield_parents=yield_parents):
 
1916
            yield unicode(self._final_paths.get_path(trans_id)), entry
 
1917
 
 
1918
    def _iter_entries_for_dir(self, dir_path):
 
1919
        """Return path, entry for items in a directory without recursing down."""
 
1920
        dir_file_id = self.path2id(dir_path)
 
1921
        ordered_ids = []
 
1922
        for file_id in self.iter_children(dir_file_id):
 
1923
            trans_id = self._transform.trans_id_file_id(file_id)
 
1924
            ordered_ids.append((trans_id, file_id))
 
1925
        for entry, trans_id in self._make_inv_entries(ordered_ids):
 
1926
            yield unicode(self._final_paths.get_path(trans_id)), entry
 
1927
 
 
1928
    def list_files(self, include_root=False, from_dir=None, recursive=True):
 
1929
        """See WorkingTree.list_files."""
 
1930
        # XXX This should behave like WorkingTree.list_files, but is really
 
1931
        # more like RevisionTree.list_files.
 
1932
        if recursive:
 
1933
            prefix = None
 
1934
            if from_dir:
 
1935
                prefix = from_dir + '/'
 
1936
            entries = self.iter_entries_by_dir()
 
1937
            for path, entry in entries:
 
1938
                if entry.name == '' and not include_root:
 
1939
                    continue
 
1940
                if prefix:
 
1941
                    if not path.startswith(prefix):
 
1942
                        continue
 
1943
                    path = path[len(prefix):]
 
1944
                yield path, 'V', entry.kind, entry.file_id, entry
 
1945
        else:
 
1946
            if from_dir is None and include_root is True:
 
1947
                root_entry = inventory.make_entry('directory', '',
 
1948
                    ROOT_PARENT, self.get_root_id())
 
1949
                yield '', 'V', 'directory', root_entry.file_id, root_entry
 
1950
            entries = self._iter_entries_for_dir(from_dir or '')
 
1951
            for path, entry in entries:
 
1952
                yield path, 'V', entry.kind, entry.file_id, entry
 
1953
 
 
1954
    def kind(self, file_id):
 
1955
        trans_id = self._transform.trans_id_file_id(file_id)
 
1956
        return self._transform.final_kind(trans_id)
 
1957
 
 
1958
    def stored_kind(self, file_id):
 
1959
        trans_id = self._transform.trans_id_file_id(file_id)
 
1960
        try:
 
1961
            return self._transform._new_contents[trans_id]
 
1962
        except KeyError:
 
1963
            return self._transform._tree.stored_kind(file_id)
 
1964
 
 
1965
    def get_file_mtime(self, file_id, path=None):
 
1966
        """See Tree.get_file_mtime"""
 
1967
        if not self._content_change(file_id):
 
1968
            return self._transform._tree.get_file_mtime(file_id, path)
 
1969
        return self._stat_limbo_file(file_id).st_mtime
 
1970
 
 
1971
    def _file_size(self, entry, stat_value):
 
1972
        return self.get_file_size(entry.file_id)
 
1973
 
 
1974
    def get_file_size(self, file_id):
 
1975
        """See Tree.get_file_size"""
 
1976
        if self.kind(file_id) == 'file':
 
1977
            return self._transform._tree.get_file_size(file_id)
 
1978
        else:
 
1979
            return None
 
1980
 
 
1981
    def get_file_sha1(self, file_id, path=None, stat_value=None):
 
1982
        trans_id = self._transform.trans_id_file_id(file_id)
 
1983
        kind = self._transform._new_contents.get(trans_id)
 
1984
        if kind is None:
 
1985
            return self._transform._tree.get_file_sha1(file_id)
 
1986
        if kind == 'file':
 
1987
            fileobj = self.get_file(file_id)
 
1988
            try:
 
1989
                return sha_file(fileobj)
 
1990
            finally:
 
1991
                fileobj.close()
 
1992
 
 
1993
    def is_executable(self, file_id, path=None):
 
1994
        if file_id is None:
 
1995
            return False
 
1996
        trans_id = self._transform.trans_id_file_id(file_id)
 
1997
        try:
 
1998
            return self._transform._new_executability[trans_id]
 
1999
        except KeyError:
 
2000
            try:
 
2001
                return self._transform._tree.is_executable(file_id, path)
 
2002
            except OSError, e:
 
2003
                if e.errno == errno.ENOENT:
 
2004
                    return False
 
2005
                raise
 
2006
            except errors.NoSuchId:
 
2007
                return False
 
2008
 
 
2009
    def path_content_summary(self, path):
 
2010
        trans_id = self._path2trans_id(path)
 
2011
        tt = self._transform
 
2012
        tree_path = tt._tree_id_paths.get(trans_id)
 
2013
        kind = tt._new_contents.get(trans_id)
 
2014
        if kind is None:
 
2015
            if tree_path is None or trans_id in tt._removed_contents:
 
2016
                return 'missing', None, None, None
 
2017
            summary = tt._tree.path_content_summary(tree_path)
 
2018
            kind, size, executable, link_or_sha1 = summary
 
2019
        else:
 
2020
            link_or_sha1 = None
 
2021
            limbo_name = tt._limbo_name(trans_id)
 
2022
            if trans_id in tt._new_reference_revision:
 
2023
                kind = 'tree-reference'
 
2024
            if kind == 'file':
 
2025
                statval = os.lstat(limbo_name)
 
2026
                size = statval.st_size
 
2027
                if not supports_executable():
 
2028
                    executable = None
 
2029
                else:
 
2030
                    executable = statval.st_mode & S_IEXEC
 
2031
            else:
 
2032
                size = None
 
2033
                executable = None
 
2034
            if kind == 'symlink':
 
2035
                link_or_sha1 = os.readlink(limbo_name).decode(osutils._fs_enc)
 
2036
        if supports_executable():
 
2037
            executable = tt._new_executability.get(trans_id, executable)
 
2038
        return kind, size, executable, link_or_sha1
 
2039
 
 
2040
    def iter_changes(self, from_tree, include_unchanged=False,
 
2041
                      specific_files=None, pb=None, extra_trees=None,
 
2042
                      require_versioned=True, want_unversioned=False):
 
2043
        """See InterTree.iter_changes.
 
2044
 
 
2045
        This has a fast path that is only used when the from_tree matches
 
2046
        the transform tree, and no fancy options are supplied.
 
2047
        """
 
2048
        if (from_tree is not self._transform._tree or include_unchanged or
 
2049
            specific_files or want_unversioned):
 
2050
            return tree.InterTree(from_tree, self).iter_changes(
 
2051
                include_unchanged=include_unchanged,
 
2052
                specific_files=specific_files,
 
2053
                pb=pb,
 
2054
                extra_trees=extra_trees,
 
2055
                require_versioned=require_versioned,
 
2056
                want_unversioned=want_unversioned)
 
2057
        if want_unversioned:
 
2058
            raise ValueError('want_unversioned is not supported')
 
2059
        return self._transform.iter_changes()
 
2060
 
 
2061
    def get_file(self, file_id, path=None):
 
2062
        """See Tree.get_file"""
 
2063
        if not self._content_change(file_id):
 
2064
            return self._transform._tree.get_file(file_id, path)
 
2065
        trans_id = self._transform.trans_id_file_id(file_id)
 
2066
        name = self._transform._limbo_name(trans_id)
 
2067
        return open(name, 'rb')
 
2068
 
 
2069
    def get_file_with_stat(self, file_id, path=None):
 
2070
        return self.get_file(file_id, path), None
 
2071
 
 
2072
    def annotate_iter(self, file_id,
 
2073
                      default_revision=_mod_revision.CURRENT_REVISION):
 
2074
        changes = self._iter_changes_cache.get(file_id)
 
2075
        if changes is None:
 
2076
            get_old = True
 
2077
        else:
 
2078
            changed_content, versioned, kind = (changes[2], changes[3],
 
2079
                                                changes[6])
 
2080
            if kind[1] is None:
 
2081
                return None
 
2082
            get_old = (kind[0] == 'file' and versioned[0])
 
2083
        if get_old:
 
2084
            old_annotation = self._transform._tree.annotate_iter(file_id,
 
2085
                default_revision=default_revision)
 
2086
        else:
 
2087
            old_annotation = []
 
2088
        if changes is None:
 
2089
            return old_annotation
 
2090
        if not changed_content:
 
2091
            return old_annotation
 
2092
        # TODO: This is doing something similar to what WT.annotate_iter is
 
2093
        #       doing, however it fails slightly because it doesn't know what
 
2094
        #       the *other* revision_id is, so it doesn't know how to give the
 
2095
        #       other as the origin for some lines, they all get
 
2096
        #       'default_revision'
 
2097
        #       It would be nice to be able to use the new Annotator based
 
2098
        #       approach, as well.
 
2099
        return annotate.reannotate([old_annotation],
 
2100
                                   self.get_file(file_id).readlines(),
 
2101
                                   default_revision)
 
2102
 
 
2103
    def get_symlink_target(self, file_id):
 
2104
        """See Tree.get_symlink_target"""
 
2105
        if not self._content_change(file_id):
 
2106
            return self._transform._tree.get_symlink_target(file_id)
 
2107
        trans_id = self._transform.trans_id_file_id(file_id)
 
2108
        name = self._transform._limbo_name(trans_id)
 
2109
        return osutils.readlink(name)
 
2110
 
 
2111
    def walkdirs(self, prefix=''):
 
2112
        pending = [self._transform.root]
 
2113
        while len(pending) > 0:
 
2114
            parent_id = pending.pop()
 
2115
            children = []
 
2116
            subdirs = []
 
2117
            prefix = prefix.rstrip('/')
 
2118
            parent_path = self._final_paths.get_path(parent_id)
 
2119
            parent_file_id = self._transform.final_file_id(parent_id)
 
2120
            for child_id in self._all_children(parent_id):
 
2121
                path_from_root = self._final_paths.get_path(child_id)
 
2122
                basename = self._transform.final_name(child_id)
 
2123
                file_id = self._transform.final_file_id(child_id)
 
2124
                try:
 
2125
                    kind = self._transform.final_kind(child_id)
 
2126
                    versioned_kind = kind
 
2127
                except NoSuchFile:
 
2128
                    kind = 'unknown'
 
2129
                    versioned_kind = self._transform._tree.stored_kind(file_id)
 
2130
                if versioned_kind == 'directory':
 
2131
                    subdirs.append(child_id)
 
2132
                children.append((path_from_root, basename, kind, None,
 
2133
                                 file_id, versioned_kind))
 
2134
            children.sort()
 
2135
            if parent_path.startswith(prefix):
 
2136
                yield (parent_path, parent_file_id), children
 
2137
            pending.extend(sorted(subdirs, key=self._final_paths.get_path,
 
2138
                                  reverse=True))
 
2139
 
 
2140
    def get_parent_ids(self):
 
2141
        return self._parent_ids
 
2142
 
 
2143
    def set_parent_ids(self, parent_ids):
 
2144
        self._parent_ids = parent_ids
 
2145
 
 
2146
    def get_revision_tree(self, revision_id):
 
2147
        return self._transform._tree.get_revision_tree(revision_id)
 
2148
 
1169
2149
 
1170
2150
def joinpath(parent, child):
1171
2151
    """Join tree-relative paths, handling the tree root specially"""
1187
2167
        self.transform = transform
1188
2168
 
1189
2169
    def _determine_path(self, trans_id):
1190
 
        if trans_id == self.transform.root:
 
2170
        if (trans_id == self.transform.root or trans_id == ROOT_PARENT):
1191
2171
            return ""
1192
2172
        name = self.transform.final_name(trans_id)
1193
2173
        parent_id = self.transform.final_parent(trans_id)
1202
2182
            self._known_paths[trans_id] = self._determine_path(trans_id)
1203
2183
        return self._known_paths[trans_id]
1204
2184
 
 
2185
    def get_paths(self, trans_ids):
 
2186
        return [(self.get_path(t), t) for t in trans_ids]
 
2187
 
 
2188
 
 
2189
 
1205
2190
def topology_sorted_ids(tree):
1206
2191
    """Determine the topological order of the ids in a tree"""
1207
2192
    file_ids = list(tree)
1209
2194
    return file_ids
1210
2195
 
1211
2196
 
1212
 
def build_tree(tree, wt):
 
2197
def build_tree(tree, wt, accelerator_tree=None, hardlink=False,
 
2198
               delta_from_tree=False):
1213
2199
    """Create working tree for a branch, using a TreeTransform.
1214
 
    
 
2200
 
1215
2201
    This function should be used on empty trees, having a tree root at most.
1216
2202
    (see merge and revert functionality for working with existing trees)
1217
2203
 
1218
2204
    Existing files are handled like so:
1219
 
    
 
2205
 
1220
2206
    - Existing bzrdirs take precedence over creating new items.  They are
1221
2207
      created as '%s.diverted' % name.
1222
2208
    - Otherwise, if the content on disk matches the content we are building,
1223
2209
      it is silently replaced.
1224
2210
    - Otherwise, conflict resolution will move the old file to 'oldname.moved'.
 
2211
 
 
2212
    :param tree: The tree to convert wt into a copy of
 
2213
    :param wt: The working tree that files will be placed into
 
2214
    :param accelerator_tree: A tree which can be used for retrieving file
 
2215
        contents more quickly than tree itself, i.e. a workingtree.  tree
 
2216
        will be used for cases where accelerator_tree's content is different.
 
2217
    :param hardlink: If true, hard-link files to accelerator_tree, where
 
2218
        possible.  accelerator_tree must implement abspath, i.e. be a
 
2219
        working tree.
 
2220
    :param delta_from_tree: If true, build_tree may use the input Tree to
 
2221
        generate the inventory delta.
1225
2222
    """
1226
2223
    wt.lock_tree_write()
1227
2224
    try:
1228
2225
        tree.lock_read()
1229
2226
        try:
1230
 
            return _build_tree(tree, wt)
 
2227
            if accelerator_tree is not None:
 
2228
                accelerator_tree.lock_read()
 
2229
            try:
 
2230
                return _build_tree(tree, wt, accelerator_tree, hardlink,
 
2231
                                   delta_from_tree)
 
2232
            finally:
 
2233
                if accelerator_tree is not None:
 
2234
                    accelerator_tree.unlock()
1231
2235
        finally:
1232
2236
            tree.unlock()
1233
2237
    finally:
1234
2238
        wt.unlock()
1235
2239
 
1236
 
def _build_tree(tree, wt):
 
2240
 
 
2241
def _build_tree(tree, wt, accelerator_tree, hardlink, delta_from_tree):
1237
2242
    """See build_tree."""
1238
 
    if len(wt.inventory) > 1:  # more than just a root
1239
 
        raise errors.WorkingTreeAlreadyPopulated(base=wt.basedir)
 
2243
    for num, _unused in enumerate(wt.all_file_ids()):
 
2244
        if num > 0:  # more than just a root
 
2245
            raise errors.WorkingTreeAlreadyPopulated(base=wt.basedir)
 
2246
    existing_files = set()
 
2247
    for dir, files in wt.walkdirs():
 
2248
        existing_files.update(f[0] for f in files)
1240
2249
    file_trans_id = {}
1241
2250
    top_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1242
2251
    pp = ProgressPhase("Build phase", 2, top_pb)
1248
2257
        # is set within the tree, nor setting the root and thus
1249
2258
        # marking the tree as dirty, because we use two different
1250
2259
        # idioms here: tree interfaces and inventory interfaces.
1251
 
        if wt.path2id('') != tree.inventory.root.file_id:
1252
 
            wt.set_root_id(tree.inventory.root.file_id)
 
2260
        if wt.get_root_id() != tree.get_root_id():
 
2261
            wt.set_root_id(tree.get_root_id())
1253
2262
            wt.flush()
1254
2263
    tt = TreeTransform(wt)
1255
2264
    divert = set()
1259
2268
            tt.trans_id_tree_file_id(wt.get_root_id())
1260
2269
        pb = bzrlib.ui.ui_factory.nested_progress_bar()
1261
2270
        try:
 
2271
            deferred_contents = []
 
2272
            num = 0
 
2273
            total = len(tree.inventory)
 
2274
            if delta_from_tree:
 
2275
                precomputed_delta = []
 
2276
            else:
 
2277
                precomputed_delta = None
1262
2278
            for num, (tree_path, entry) in \
1263
2279
                enumerate(tree.inventory.iter_entries_by_dir()):
1264
 
                pb.update("Building tree", num, len(tree.inventory))
 
2280
                pb.update("Building tree", num - len(deferred_contents), total)
1265
2281
                if entry.parent_id is None:
1266
2282
                    continue
1267
2283
                reparent = False
1268
2284
                file_id = entry.file_id
1269
 
                target_path = wt.abspath(tree_path)
1270
 
                try:
 
2285
                if delta_from_tree:
 
2286
                    precomputed_delta.append((None, tree_path, file_id, entry))
 
2287
                if tree_path in existing_files:
 
2288
                    target_path = wt.abspath(tree_path)
1271
2289
                    kind = file_kind(target_path)
1272
 
                except NoSuchFile:
1273
 
                    pass
1274
 
                else:
1275
2290
                    if kind == "directory":
1276
2291
                        try:
1277
2292
                            bzrdir.BzrDir.open(target_path)
1285
2300
                        tt.delete_contents(tt.trans_id_tree_path(tree_path))
1286
2301
                        if kind == 'directory':
1287
2302
                            reparent = True
1288
 
                if entry.parent_id not in file_trans_id:
1289
 
                    raise AssertionError(
1290
 
                        'entry %s parent id %r is not in file_trans_id %r'
1291
 
                        % (entry, entry.parent_id, file_trans_id))
1292
2303
                parent_id = file_trans_id[entry.parent_id]
1293
 
                file_trans_id[file_id] = new_by_entry(tt, entry, parent_id,
1294
 
                                                      tree)
 
2304
                if entry.kind == 'file':
 
2305
                    # We *almost* replicate new_by_entry, so that we can defer
 
2306
                    # getting the file text, and get them all at once.
 
2307
                    trans_id = tt.create_path(entry.name, parent_id)
 
2308
                    file_trans_id[file_id] = trans_id
 
2309
                    tt.version_file(file_id, trans_id)
 
2310
                    executable = tree.is_executable(file_id, tree_path)
 
2311
                    if executable:
 
2312
                        tt.set_executability(executable, trans_id)
 
2313
                    trans_data = (trans_id, tree_path)
 
2314
                    deferred_contents.append((file_id, trans_data))
 
2315
                else:
 
2316
                    file_trans_id[file_id] = new_by_entry(tt, entry, parent_id,
 
2317
                                                          tree)
1295
2318
                if reparent:
1296
2319
                    new_trans_id = file_trans_id[file_id]
1297
2320
                    old_parent = tt.trans_id_tree_path(tree_path)
1298
2321
                    _reparent_children(tt, old_parent, new_trans_id)
 
2322
            offset = num + 1 - len(deferred_contents)
 
2323
            _create_files(tt, tree, deferred_contents, pb, offset,
 
2324
                          accelerator_tree, hardlink)
1299
2325
        finally:
1300
2326
            pb.finished()
1301
2327
        pp.next_phase()
1302
2328
        divert_trans = set(file_trans_id[f] for f in divert)
1303
2329
        resolver = lambda t, c: resolve_checkout(t, c, divert_trans)
1304
2330
        raw_conflicts = resolve_conflicts(tt, pass_func=resolver)
 
2331
        if len(raw_conflicts) > 0:
 
2332
            precomputed_delta = None
1305
2333
        conflicts = cook_conflicts(raw_conflicts, tt)
1306
2334
        for conflict in conflicts:
1307
2335
            warning(conflict)
1309
2337
            wt.add_conflicts(conflicts)
1310
2338
        except errors.UnsupportedOperation:
1311
2339
            pass
1312
 
        result = tt.apply()
 
2340
        result = tt.apply(no_conflicts=True,
 
2341
                          precomputed_delta=precomputed_delta)
1313
2342
    finally:
1314
2343
        tt.finalize()
1315
2344
        top_pb.finished()
1316
2345
    return result
1317
2346
 
1318
2347
 
 
2348
def _create_files(tt, tree, desired_files, pb, offset, accelerator_tree,
 
2349
                  hardlink):
 
2350
    total = len(desired_files) + offset
 
2351
    wt = tt._tree
 
2352
    if accelerator_tree is None:
 
2353
        new_desired_files = desired_files
 
2354
    else:
 
2355
        iter = accelerator_tree.iter_changes(tree, include_unchanged=True)
 
2356
        unchanged = dict((f, p[1]) for (f, p, c, v, d, n, k, e)
 
2357
                         in iter if not (c or e[0] != e[1]))
 
2358
        new_desired_files = []
 
2359
        count = 0
 
2360
        for file_id, (trans_id, tree_path) in desired_files:
 
2361
            accelerator_path = unchanged.get(file_id)
 
2362
            if accelerator_path is None:
 
2363
                new_desired_files.append((file_id, (trans_id, tree_path)))
 
2364
                continue
 
2365
            pb.update('Adding file contents', count + offset, total)
 
2366
            if hardlink:
 
2367
                tt.create_hardlink(accelerator_tree.abspath(accelerator_path),
 
2368
                                   trans_id)
 
2369
            else:
 
2370
                contents = accelerator_tree.get_file(file_id, accelerator_path)
 
2371
                if wt.supports_content_filtering():
 
2372
                    filters = wt._content_filter_stack(tree_path)
 
2373
                    contents = filtered_output_bytes(contents, filters,
 
2374
                        ContentFilterContext(tree_path, tree))
 
2375
                try:
 
2376
                    tt.create_file(contents, trans_id)
 
2377
                finally:
 
2378
                    try:
 
2379
                        contents.close()
 
2380
                    except AttributeError:
 
2381
                        # after filtering, contents may no longer be file-like
 
2382
                        pass
 
2383
            count += 1
 
2384
        offset += count
 
2385
    for count, ((trans_id, tree_path), contents) in enumerate(
 
2386
            tree.iter_files_bytes(new_desired_files)):
 
2387
        if wt.supports_content_filtering():
 
2388
            filters = wt._content_filter_stack(tree_path)
 
2389
            contents = filtered_output_bytes(contents, filters,
 
2390
                ContentFilterContext(tree_path, tree))
 
2391
        tt.create_file(contents, trans_id)
 
2392
        pb.update('Adding file contents', count + offset, total)
 
2393
 
 
2394
 
1319
2395
def _reparent_children(tt, old_parent, new_parent):
1320
2396
    for child in tt.iter_tree_children(old_parent):
1321
2397
        tt.adjust_path(tt.final_name(child), new_parent, child)
1322
2398
 
 
2399
def _reparent_transform_children(tt, old_parent, new_parent):
 
2400
    by_parent = tt.by_parent()
 
2401
    for child in by_parent[old_parent]:
 
2402
        tt.adjust_path(tt.final_name(child), new_parent, child)
 
2403
    return by_parent[old_parent]
1323
2404
 
1324
2405
def _content_match(tree, entry, file_id, kind, target_path):
1325
2406
    if entry.kind != kind:
1339
2420
    new_conflicts = set()
1340
2421
    for c_type, conflict in ((c[0], c) for c in conflicts):
1341
2422
        # Anything but a 'duplicate' would indicate programmer error
1342
 
        assert c_type == 'duplicate', c_type
 
2423
        if c_type != 'duplicate':
 
2424
            raise AssertionError(c_type)
1343
2425
        # Now figure out which is new and which is old
1344
2426
        if tt.new_contents(conflict[1]):
1345
2427
            new_file = conflict[1]
1371
2453
    if kind == 'file':
1372
2454
        contents = tree.get_file(entry.file_id).readlines()
1373
2455
        executable = tree.is_executable(entry.file_id)
1374
 
        return tt.new_file(name, parent_id, contents, entry.file_id, 
 
2456
        return tt.new_file(name, parent_id, contents, entry.file_id,
1375
2457
                           executable)
1376
2458
    elif kind in ('directory', 'tree-reference'):
1377
2459
        trans_id = tt.new_directory(name, parent_id, entry.file_id)
1378
2460
        if kind == 'tree-reference':
1379
2461
            tt.set_tree_reference(entry.reference_revision, trans_id)
1380
 
        return trans_id 
 
2462
        return trans_id
1381
2463
    elif kind == 'symlink':
1382
2464
        target = tree.get_symlink_target(entry.file_id)
1383
2465
        return tt.new_symlink(name, parent_id, target, entry.file_id)
1384
2466
    else:
1385
2467
        raise errors.BadFileKindError(name, kind)
1386
2468
 
 
2469
 
 
2470
@deprecated_function(deprecated_in((1, 9, 0)))
1387
2471
def create_by_entry(tt, entry, tree, trans_id, lines=None, mode_id=None):
1388
 
    """Create new file contents according to an inventory entry."""
 
2472
    """Create new file contents according to an inventory entry.
 
2473
 
 
2474
    DEPRECATED.  Use create_from_tree instead.
 
2475
    """
1389
2476
    if entry.kind == "file":
1390
2477
        if lines is None:
1391
2478
            lines = tree.get_file(entry.file_id).readlines()
1395
2482
    elif entry.kind == "directory":
1396
2483
        tt.create_directory(trans_id)
1397
2484
 
 
2485
 
 
2486
def create_from_tree(tt, trans_id, tree, file_id, bytes=None,
 
2487
    filter_tree_path=None):
 
2488
    """Create new file contents according to tree contents.
 
2489
    
 
2490
    :param filter_tree_path: the tree path to use to lookup
 
2491
      content filters to apply to the bytes output in the working tree.
 
2492
      This only applies if the working tree supports content filtering.
 
2493
    """
 
2494
    kind = tree.kind(file_id)
 
2495
    if kind == 'directory':
 
2496
        tt.create_directory(trans_id)
 
2497
    elif kind == "file":
 
2498
        if bytes is None:
 
2499
            tree_file = tree.get_file(file_id)
 
2500
            try:
 
2501
                bytes = tree_file.readlines()
 
2502
            finally:
 
2503
                tree_file.close()
 
2504
        wt = tt._tree
 
2505
        if wt.supports_content_filtering() and filter_tree_path is not None:
 
2506
            filters = wt._content_filter_stack(filter_tree_path)
 
2507
            bytes = filtered_output_bytes(bytes, filters,
 
2508
                ContentFilterContext(filter_tree_path, tree))
 
2509
        tt.create_file(bytes, trans_id)
 
2510
    elif kind == "symlink":
 
2511
        tt.create_symlink(tree.get_symlink_target(file_id), trans_id)
 
2512
    else:
 
2513
        raise AssertionError('Unknown kind %r' % kind)
 
2514
 
 
2515
 
1398
2516
def create_entry_executability(tt, entry, trans_id):
1399
2517
    """Set the executability of a trans_id according to an inventory entry"""
1400
2518
    if entry.kind == "file":
1401
2519
        tt.set_executability(entry.executable, trans_id)
1402
2520
 
1403
2521
 
1404
 
@deprecated_function(zero_fifteen)
1405
 
def find_interesting(working_tree, target_tree, filenames):
1406
 
    """Find the ids corresponding to specified filenames.
1407
 
    
1408
 
    Deprecated: Please use tree1.paths2ids(filenames, [tree2]).
1409
 
    """
1410
 
    working_tree.lock_read()
1411
 
    try:
1412
 
        target_tree.lock_read()
1413
 
        try:
1414
 
            return working_tree.paths2ids(filenames, [target_tree])
1415
 
        finally:
1416
 
            target_tree.unlock()
1417
 
    finally:
1418
 
        working_tree.unlock()
1419
 
 
1420
 
 
1421
 
def change_entry(tt, file_id, working_tree, target_tree, 
1422
 
                 trans_id_file_id, backups, trans_id, by_parent):
1423
 
    """Replace a file_id's contents with those from a target tree."""
1424
 
    e_trans_id = trans_id_file_id(file_id)
1425
 
    entry = target_tree.inventory[file_id]
1426
 
    has_contents, contents_mod, meta_mod, = _entry_changes(file_id, entry, 
1427
 
                                                           working_tree)
1428
 
    if contents_mod:
1429
 
        mode_id = e_trans_id
1430
 
        if has_contents:
1431
 
            if not backups:
1432
 
                tt.delete_contents(e_trans_id)
1433
 
            else:
1434
 
                parent_trans_id = trans_id_file_id(entry.parent_id)
1435
 
                backup_name = get_backup_name(entry, by_parent,
1436
 
                                              parent_trans_id, tt)
1437
 
                tt.adjust_path(backup_name, parent_trans_id, e_trans_id)
1438
 
                tt.unversion_file(e_trans_id)
1439
 
                e_trans_id = tt.create_path(entry.name, parent_trans_id)
1440
 
                tt.version_file(file_id, e_trans_id)
1441
 
                trans_id[file_id] = e_trans_id
1442
 
        create_by_entry(tt, entry, target_tree, e_trans_id, mode_id=mode_id)
1443
 
        create_entry_executability(tt, entry, e_trans_id)
1444
 
 
1445
 
    elif meta_mod:
1446
 
        tt.set_executability(entry.executable, e_trans_id)
1447
 
    if tt.final_name(e_trans_id) != entry.name:
1448
 
        adjust_path  = True
1449
 
    else:
1450
 
        parent_id = tt.final_parent(e_trans_id)
1451
 
        parent_file_id = tt.final_file_id(parent_id)
1452
 
        if parent_file_id != entry.parent_id:
1453
 
            adjust_path = True
1454
 
        else:
1455
 
            adjust_path = False
1456
 
    if adjust_path:
1457
 
        parent_trans_id = trans_id_file_id(entry.parent_id)
1458
 
        tt.adjust_path(entry.name, parent_trans_id, e_trans_id)
1459
 
 
1460
 
 
1461
2522
def get_backup_name(entry, by_parent, parent_trans_id, tt):
1462
2523
    return _get_backup_name(entry.name, by_parent, parent_trans_id, tt)
1463
2524
 
1494
2555
        if entry.kind != working_kind:
1495
2556
            contents_mod, meta_mod = True, False
1496
2557
        else:
1497
 
            cur_entry._read_tree_state(working_tree.id2path(file_id), 
 
2558
            cur_entry._read_tree_state(working_tree.id2path(file_id),
1498
2559
                                       working_tree)
1499
2560
            contents_mod, meta_mod = entry.detect_changes(cur_entry)
1500
2561
            cur_entry._forget_tree_state()
1508
2569
    tt = TreeTransform(working_tree, pb)
1509
2570
    try:
1510
2571
        pp = ProgressPhase("Revert phase", 3, pb)
1511
 
        pp.next_phase()
1512
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1513
 
        try:
1514
 
            merge_modified = _alter_files(working_tree, target_tree, tt,
1515
 
                                          child_pb, filenames, backups)
1516
 
        finally:
1517
 
            child_pb.finished()
1518
 
        pp.next_phase()
1519
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1520
 
        try:
1521
 
            raw_conflicts = resolve_conflicts(tt, child_pb)
1522
 
        finally:
1523
 
            child_pb.finished()
1524
 
        conflicts = cook_conflicts(raw_conflicts, tt)
 
2572
        conflicts, merge_modified = _prepare_revert_transform(
 
2573
            working_tree, target_tree, tt, filenames, backups, pp)
1525
2574
        if change_reporter:
1526
2575
            change_reporter = delta._ChangeReporter(
1527
2576
                unversioned_filter=working_tree.is_ignored)
1528
 
            delta.report_changes(tt._iter_changes(), change_reporter)
 
2577
            delta.report_changes(tt.iter_changes(), change_reporter)
1529
2578
        for conflict in conflicts:
1530
2579
            warning(conflict)
1531
2580
        pp.next_phase()
1538
2587
    return conflicts
1539
2588
 
1540
2589
 
 
2590
def _prepare_revert_transform(working_tree, target_tree, tt, filenames,
 
2591
                              backups, pp, basis_tree=None,
 
2592
                              merge_modified=None):
 
2593
    pp.next_phase()
 
2594
    child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
2595
    try:
 
2596
        if merge_modified is None:
 
2597
            merge_modified = working_tree.merge_modified()
 
2598
        merge_modified = _alter_files(working_tree, target_tree, tt,
 
2599
                                      child_pb, filenames, backups,
 
2600
                                      merge_modified, basis_tree)
 
2601
    finally:
 
2602
        child_pb.finished()
 
2603
    pp.next_phase()
 
2604
    child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
2605
    try:
 
2606
        raw_conflicts = resolve_conflicts(tt, child_pb,
 
2607
            lambda t, c: conflict_pass(t, c, target_tree))
 
2608
    finally:
 
2609
        child_pb.finished()
 
2610
    conflicts = cook_conflicts(raw_conflicts, tt)
 
2611
    return conflicts, merge_modified
 
2612
 
 
2613
 
1541
2614
def _alter_files(working_tree, target_tree, tt, pb, specific_files,
1542
 
                 backups):
1543
 
    merge_modified = working_tree.merge_modified()
1544
 
    change_list = target_tree._iter_changes(working_tree,
 
2615
                 backups, merge_modified, basis_tree=None):
 
2616
    if basis_tree is not None:
 
2617
        basis_tree.lock_read()
 
2618
    change_list = target_tree.iter_changes(working_tree,
1545
2619
        specific_files=specific_files, pb=pb)
1546
 
    if target_tree.inventory.root is None:
 
2620
    if target_tree.get_root_id() is None:
1547
2621
        skip_root = True
1548
2622
    else:
1549
2623
        skip_root = False
1550
 
    basis_tree = None
1551
2624
    try:
 
2625
        deferred_files = []
1552
2626
        for id_num, (file_id, path, changed_content, versioned, parent, name,
1553
2627
                kind, executable) in enumerate(change_list):
1554
2628
            if skip_root and file_id[0] is not None and parent[0] is None:
1588
2662
                        # contents
1589
2663
                        mode_id = trans_id
1590
2664
                        trans_id = new_trans_id
1591
 
                if kind[1] == 'directory':
 
2665
                if kind[1] in ('directory', 'tree-reference'):
1592
2666
                    tt.create_directory(trans_id)
 
2667
                    if kind[1] == 'tree-reference':
 
2668
                        revision = target_tree.get_reference_revision(file_id,
 
2669
                                                                      path[1])
 
2670
                        tt.set_tree_reference(revision, trans_id)
1593
2671
                elif kind[1] == 'symlink':
1594
2672
                    tt.create_symlink(target_tree.get_symlink_target(file_id),
1595
2673
                                      trans_id)
1596
2674
                elif kind[1] == 'file':
1597
 
                    tt.create_file(target_tree.get_file_lines(file_id),
1598
 
                                   trans_id, mode_id)
 
2675
                    deferred_files.append((file_id, (trans_id, mode_id)))
1599
2676
                    if basis_tree is None:
1600
2677
                        basis_tree = working_tree.basis_tree()
1601
2678
                        basis_tree.lock_read()
1610
2687
                    # preserve the execute bit when backing up
1611
2688
                    if keep_content and executable[0] == executable[1]:
1612
2689
                        tt.set_executability(executable[1], trans_id)
1613
 
                else:
1614
 
                    assert kind[1] is None
 
2690
                elif kind[1] is not None:
 
2691
                    raise AssertionError(kind[1])
1615
2692
            if versioned == (False, True):
1616
2693
                tt.version_file(file_id, trans_id)
1617
2694
            if versioned == (True, False):
1618
2695
                tt.unversion_file(trans_id)
1619
 
            if (name[1] is not None and 
 
2696
            if (name[1] is not None and
1620
2697
                (name[0] != name[1] or parent[0] != parent[1])):
1621
 
                tt.adjust_path(
1622
 
                    name[1], tt.trans_id_file_id(parent[1]), trans_id)
 
2698
                if name[1] == '' and parent[1] is None:
 
2699
                    parent_trans = ROOT_PARENT
 
2700
                else:
 
2701
                    parent_trans = tt.trans_id_file_id(parent[1])
 
2702
                if parent[0] is None and versioned[0]:
 
2703
                    tt.adjust_root_path(name[1], parent_trans)
 
2704
                else:
 
2705
                    tt.adjust_path(name[1], parent_trans, trans_id)
1623
2706
            if executable[0] != executable[1] and kind[1] == "file":
1624
2707
                tt.set_executability(executable[1], trans_id)
 
2708
        if working_tree.supports_content_filtering():
 
2709
            for index, ((trans_id, mode_id), bytes) in enumerate(
 
2710
                target_tree.iter_files_bytes(deferred_files)):
 
2711
                file_id = deferred_files[index][0]
 
2712
                # We're reverting a tree to the target tree so using the
 
2713
                # target tree to find the file path seems the best choice
 
2714
                # here IMO - Ian C 27/Oct/2009
 
2715
                filter_tree_path = target_tree.id2path(file_id)
 
2716
                filters = working_tree._content_filter_stack(filter_tree_path)
 
2717
                bytes = filtered_output_bytes(bytes, filters,
 
2718
                    ContentFilterContext(filter_tree_path, working_tree))
 
2719
                tt.create_file(bytes, trans_id, mode_id)
 
2720
        else:
 
2721
            for (trans_id, mode_id), bytes in target_tree.iter_files_bytes(
 
2722
                deferred_files):
 
2723
                tt.create_file(bytes, trans_id, mode_id)
 
2724
        tt.fixup_new_roots()
1625
2725
    finally:
1626
2726
        if basis_tree is not None:
1627
2727
            basis_tree.unlock()
1645
2745
        pb.clear()
1646
2746
 
1647
2747
 
1648
 
def conflict_pass(tt, conflicts):
1649
 
    """Resolve some classes of conflicts."""
 
2748
def conflict_pass(tt, conflicts, path_tree=None):
 
2749
    """Resolve some classes of conflicts.
 
2750
 
 
2751
    :param tt: The transform to resolve conflicts in
 
2752
    :param conflicts: The conflicts to resolve
 
2753
    :param path_tree: A Tree to get supplemental paths from
 
2754
    """
1650
2755
    new_conflicts = set()
1651
2756
    for c_type, conflict in ((c[0], c) for c in conflicts):
1652
2757
        if c_type == 'duplicate id':
1655
2760
                               conflict[1], conflict[2], ))
1656
2761
        elif c_type == 'duplicate':
1657
2762
            # files that were renamed take precedence
1658
 
            new_name = tt.final_name(conflict[1])+'.moved'
1659
2763
            final_parent = tt.final_parent(conflict[1])
1660
2764
            if tt.path_changed(conflict[1]):
1661
 
                tt.adjust_path(new_name, final_parent, conflict[2])
1662
 
                new_conflicts.add((c_type, 'Moved existing file to', 
1663
 
                                   conflict[2], conflict[1]))
 
2765
                existing_file, new_file = conflict[2], conflict[1]
1664
2766
            else:
1665
 
                tt.adjust_path(new_name, final_parent, conflict[1])
1666
 
                new_conflicts.add((c_type, 'Moved existing file to', 
1667
 
                                  conflict[1], conflict[2]))
 
2767
                existing_file, new_file = conflict[1], conflict[2]
 
2768
            new_name = tt.final_name(existing_file)+'.moved'
 
2769
            tt.adjust_path(new_name, final_parent, existing_file)
 
2770
            new_conflicts.add((c_type, 'Moved existing file to',
 
2771
                               existing_file, new_file))
1668
2772
        elif c_type == 'parent loop':
1669
2773
            # break the loop by undoing one of the ops that caused the loop
1670
2774
            cur = conflict[1]
1673
2777
            new_conflicts.add((c_type, 'Cancelled move', cur,
1674
2778
                               tt.final_parent(cur),))
1675
2779
            tt.adjust_path(tt.final_name(cur), tt.get_tree_parent(cur), cur)
1676
 
            
 
2780
 
1677
2781
        elif c_type == 'missing parent':
1678
2782
            trans_id = conflict[1]
1679
2783
            try:
1680
2784
                tt.cancel_deletion(trans_id)
1681
 
                new_conflicts.add(('deleting parent', 'Not deleting', 
 
2785
                new_conflicts.add(('deleting parent', 'Not deleting',
1682
2786
                                   trans_id))
1683
2787
            except KeyError:
1684
 
                tt.create_directory(trans_id)
1685
 
                new_conflicts.add((c_type, 'Created directory', trans_id))
 
2788
                create = True
 
2789
                try:
 
2790
                    tt.final_name(trans_id)
 
2791
                except NoFinalPath:
 
2792
                    if path_tree is not None:
 
2793
                        file_id = tt.final_file_id(trans_id)
 
2794
                        if file_id is None:
 
2795
                            file_id = tt.inactive_file_id(trans_id)
 
2796
                        entry = path_tree.inventory[file_id]
 
2797
                        # special-case the other tree root (move its
 
2798
                        # children to current root)
 
2799
                        if entry.parent_id is None:
 
2800
                            create=False
 
2801
                            moved = _reparent_transform_children(
 
2802
                                tt, trans_id, tt.root)
 
2803
                            for child in moved:
 
2804
                                new_conflicts.add((c_type, 'Moved to root',
 
2805
                                                   child))
 
2806
                        else:
 
2807
                            parent_trans_id = tt.trans_id_file_id(
 
2808
                                entry.parent_id)
 
2809
                            tt.adjust_path(entry.name, parent_trans_id,
 
2810
                                           trans_id)
 
2811
                if create:
 
2812
                    tt.create_directory(trans_id)
 
2813
                    new_conflicts.add((c_type, 'Created directory', trans_id))
1686
2814
        elif c_type == 'unversioned parent':
1687
 
            tt.version_file(tt.inactive_file_id(conflict[1]), conflict[1])
 
2815
            file_id = tt.inactive_file_id(conflict[1])
 
2816
            # special-case the other tree root (move its children instead)
 
2817
            if path_tree and file_id in path_tree:
 
2818
                if path_tree.inventory[file_id].parent_id is None:
 
2819
                    continue
 
2820
            tt.version_file(file_id, conflict[1])
1688
2821
            new_conflicts.add((c_type, 'Versioned directory', conflict[1]))
 
2822
        elif c_type == 'non-directory parent':
 
2823
            parent_id = conflict[1]
 
2824
            parent_parent = tt.final_parent(parent_id)
 
2825
            parent_name = tt.final_name(parent_id)
 
2826
            parent_file_id = tt.final_file_id(parent_id)
 
2827
            new_parent_id = tt.new_directory(parent_name + '.new',
 
2828
                parent_parent, parent_file_id)
 
2829
            _reparent_transform_children(tt, parent_id, new_parent_id)
 
2830
            if parent_file_id is not None:
 
2831
                tt.unversion_file(parent_id)
 
2832
            new_conflicts.add((c_type, 'Created directory', new_parent_id))
 
2833
        elif c_type == 'versioning no contents':
 
2834
            tt.cancel_versioning(conflict[1])
1689
2835
    return new_conflicts
1690
2836
 
1691
2837
 
1707
2853
        if len(conflict) == 3:
1708
2854
            yield Conflict.factory(c_type, action=action, path=modified_path,
1709
2855
                                     file_id=modified_id)
1710
 
             
 
2856
 
1711
2857
        else:
1712
2858
            conflicting_path = fp.get_path(conflict[3])
1713
2859
            conflicting_id = tt.final_file_id(conflict[3])
1714
2860
            yield Conflict.factory(c_type, action=action, path=modified_path,
1715
 
                                   file_id=modified_id, 
 
2861
                                   file_id=modified_id,
1716
2862
                                   conflict_path=conflicting_path,
1717
2863
                                   conflict_file_id=conflicting_id)
 
2864
 
 
2865
 
 
2866
class _FileMover(object):
 
2867
    """Moves and deletes files for TreeTransform, tracking operations"""
 
2868
 
 
2869
    def __init__(self):
 
2870
        self.past_renames = []
 
2871
        self.pending_deletions = []
 
2872
 
 
2873
    def rename(self, from_, to):
 
2874
        """Rename a file from one path to another.  Functions like os.rename"""
 
2875
        try:
 
2876
            os.rename(from_, to)
 
2877
        except OSError, e:
 
2878
            if e.errno in (errno.EEXIST, errno.ENOTEMPTY):
 
2879
                raise errors.FileExists(to, str(e))
 
2880
            raise
 
2881
        self.past_renames.append((from_, to))
 
2882
 
 
2883
    def pre_delete(self, from_, to):
 
2884
        """Rename a file out of the way and mark it for deletion.
 
2885
 
 
2886
        Unlike os.unlink, this works equally well for files and directories.
 
2887
        :param from_: The current file path
 
2888
        :param to: A temporary path for the file
 
2889
        """
 
2890
        self.rename(from_, to)
 
2891
        self.pending_deletions.append(to)
 
2892
 
 
2893
    def rollback(self):
 
2894
        """Reverse all renames that have been performed"""
 
2895
        for from_, to in reversed(self.past_renames):
 
2896
            os.rename(to, from_)
 
2897
        # after rollback, don't reuse _FileMover
 
2898
        past_renames = None
 
2899
        pending_deletions = None
 
2900
 
 
2901
    def apply_deletions(self):
 
2902
        """Apply all marked deletions"""
 
2903
        for path in self.pending_deletions:
 
2904
            delete_any(path)
 
2905
        # after apply_deletions, don't reuse _FileMover
 
2906
        past_renames = None
 
2907
        pending_deletions = None