← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transform.py

  • Committer: Robert Collins
  • Date: 2009-07-07 04:32:13 UTC
  • mto: This revision was merged to the branch mainline in revision 4524.
  • Revision ID: robertc@robertcollins.net-20090707043213-4hjjhgr40iq7gk2d
More informative assertions in xml serialisation.

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, 2007, 2008 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 ProgressBar 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
187
163
        """Change the path that is assigned to a transaction id."""
188
164
        if trans_id == self._new_root:
189
165
            raise CantMoveRoot
190
 
        previous_parent = self._new_parent.get(trans_id)
191
 
        previous_name = self._new_name.get(trans_id)
192
166
        self._new_name[trans_id] = name
193
167
        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)
 
168
        if parent == ROOT_PARENT:
 
169
            if self._new_root is not None:
 
170
                raise ValueError("Cannot have multiple roots.")
 
171
            self._new_root = trans_id
217
172
 
218
173
    def adjust_root_path(self, name, parent):
219
174
        """Emulate moving the root by moving all children, instead.
220
 
        
 
175
 
221
176
        We do this by undoing the association of root's transaction id with the
222
177
        current tree.  This allows us to create a new directory with that
223
 
        transaction id.  We unversion the root directory and version the 
 
178
        transaction id.  We unversion the root directory and version the
224
179
        physically new directory, and hope someone versions the tree root
225
180
        later.
226
181
        """
229
184
        # force moving all children of root
230
185
        for child_id in self.iter_tree_children(old_root):
231
186
            if child_id != parent:
232
 
                self.adjust_path(self.final_name(child_id), 
 
187
                self.adjust_path(self.final_name(child_id),
233
188
                                 self.final_parent(child_id), child_id)
234
189
            file_id = self.final_file_id(child_id)
235
190
            if file_id is not None:
236
191
                self.unversion_file(child_id)
237
192
            self.version_file(file_id, child_id)
238
 
        
 
193
 
239
194
        # the physical root needs a new transaction id
240
195
        self._tree_path_ids.pop("")
241
196
        self._tree_id_paths.pop(old_root)
249
204
 
250
205
    def trans_id_tree_file_id(self, inventory_id):
251
206
        """Determine the transaction id of a working tree file.
252
 
        
 
207
 
253
208
        This reflects only files that already exist, not ones that will be
254
209
        added by transactions.
255
210
        """
256
 
        path = self._tree.inventory.id2path(inventory_id)
 
211
        if inventory_id is None:
 
212
            raise ValueError('None is not a valid file id')
 
213
        path = self._tree.id2path(inventory_id)
257
214
        return self.trans_id_tree_path(path)
258
215
 
259
216
    def trans_id_file_id(self, file_id):
262
219
        a transaction has been unversioned, it is deliberately still returned.
263
220
        (this will likely lead to an unversioned parent conflict.)
264
221
        """
 
222
        if file_id is None:
 
223
            raise ValueError('None is not a valid file id')
265
224
        if file_id in self._r_new_id and self._r_new_id[file_id] is not None:
266
225
            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
 
226
        else:
 
227
            try:
 
228
                self._tree.iter_entries_by_dir([file_id]).next()
 
229
            except StopIteration:
 
230
                if file_id in self._non_present_ids:
 
231
                    return self._non_present_ids[file_id]
 
232
                else:
 
233
                    trans_id = self._assign_id()
 
234
                    self._non_present_ids[file_id] = trans_id
 
235
                    return trans_id
 
236
            else:
 
237
                return self.trans_id_tree_file_id(file_id)
294
238
 
295
239
    def trans_id_tree_path(self, path):
296
240
        """Determine (and maybe set) the transaction ID for a tree path."""
307
251
            return ROOT_PARENT
308
252
        return self.trans_id_tree_path(os.path.dirname(path))
309
253
 
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
254
    def delete_contents(self, trans_id):
390
255
        """Schedule the contents of a path entry for deletion"""
391
256
        self.tree_kind(trans_id)
419
284
 
420
285
    def version_file(self, file_id, trans_id):
421
286
        """Schedule a file to become versioned."""
422
 
        assert file_id is not None
 
287
        if file_id is None:
 
288
            raise ValueError()
423
289
        unique_add(self._new_id, trans_id, file_id)
424
290
        unique_add(self._r_new_id, file_id, trans_id)
425
291
 
429
295
        del self._new_id[trans_id]
430
296
        del self._r_new_id[file_id]
431
297
 
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
 
298
    def new_paths(self, filesystem_only=False):
 
299
        """Determine the paths of all new and changed files.
 
300
 
 
301
        :param filesystem_only: if True, only calculate values for files
 
302
            that require renames or execute bit changes.
447
303
        """
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)
 
304
        new_ids = set()
 
305
        if filesystem_only:
 
306
            stale_ids = self._needs_rename.difference(self._new_name)
 
307
            stale_ids.difference_update(self._new_parent)
 
308
            stale_ids.difference_update(self._new_contents)
 
309
            stale_ids.difference_update(self._new_id)
 
310
            needs_rename = self._needs_rename.difference(stale_ids)
 
311
            id_sets = (needs_rename, self._new_executability)
 
312
        else:
 
313
            id_sets = (self._new_name, self._new_parent, self._new_contents,
 
314
                       self._new_id, self._new_executability)
 
315
        for id_set in id_sets:
 
316
            new_ids.update(id_set)
 
317
        return sorted(FinalPaths(self).get_paths(new_ids))
 
318
 
 
319
    def _inventory_altered(self):
 
320
        """Get the trans_ids and paths of files needing new inv entries."""
 
321
        new_ids = set()
 
322
        for id_set in [self._new_name, self._new_parent, self._new_id,
 
323
                       self._new_executability]:
 
324
            new_ids.update(id_set)
 
325
        changed_kind = set(self._removed_contents)
 
326
        changed_kind.intersection_update(self._new_contents)
 
327
        changed_kind.difference_update(new_ids)
 
328
        changed_kind = (t for t in changed_kind if self.tree_kind(t) !=
 
329
                        self.final_kind(t))
 
330
        new_ids.update(changed_kind)
 
331
        return sorted(FinalPaths(self).get_paths(new_ids))
458
332
 
459
333
    def final_kind(self, trans_id):
460
334
        """Determine the final file kind, after any changes applied.
461
 
        
 
335
 
462
336
        Raises NoSuchFile if the file does not exist/has no contents.
463
337
        (It is conceivable that a path would be created without the
464
338
        corresponding contents insertion command)
479
353
            return None
480
354
        # the file is old; the old id is still valid
481
355
        if self._new_root == trans_id:
482
 
            return self._tree.inventory.root.file_id
483
 
        return self._tree.inventory.path2id(path)
 
356
            return self._tree.get_root_id()
 
357
        return self._tree.path2id(path)
484
358
 
485
359
    def final_file_id(self, trans_id):
486
360
        """Determine the file id after any changes are applied, or None.
487
 
        
 
361
 
488
362
        None indicates that the file will not be versioned after changes are
489
363
        applied.
490
364
        """
491
365
        try:
492
 
            # there is a new id for this file
493
 
            assert self._new_id[trans_id] is not None
494
366
            return self._new_id[trans_id]
495
367
        except KeyError:
496
368
            if trans_id in self._removed_id:
531
403
 
532
404
    def by_parent(self):
533
405
        """Return a map of parent: children for known parents.
534
 
        
 
406
 
535
407
        Only new paths and parents of tree files with assigned ids are used.
536
408
        """
537
409
        by_parent = {}
538
410
        items = list(self._new_parent.iteritems())
539
 
        items.extend((t, self.final_parent(t)) for t in 
 
411
        items.extend((t, self.final_parent(t)) for t in
540
412
                      self._tree_id_paths.keys())
541
413
        for trans_id, parent_id in items:
542
414
            if parent_id not in by_parent:
553
425
 
554
426
    def find_conflicts(self):
555
427
        """Find any violations of inventory or filesystem invariants"""
556
 
        if self.__done is True:
 
428
        if self._done is True:
557
429
            raise ReusingTransform()
558
430
        conflicts = []
559
431
        # ensure all children of all existent parents are known
577
449
        removed.  This is a necessary first step in detecting conflicts.
578
450
        """
579
451
        parents = self.by_parent().keys()
580
 
        parents.extend([t for t in self._removed_contents if 
 
452
        parents.extend([t for t in self._removed_contents if
581
453
                        self.tree_kind(t) == 'directory'])
582
454
        for trans_id in self._removed_id:
583
455
            file_id = self.tree_file_id(trans_id)
584
 
            if self._tree.inventory[file_id].kind == 'directory':
 
456
            if file_id is not None:
 
457
                if self._tree.inventory[file_id].kind == 'directory':
 
458
                    parents.append(trans_id)
 
459
            elif self.tree_kind(trans_id) == 'directory':
585
460
                parents.append(trans_id)
586
461
 
587
462
        for parent_id in parents:
588
463
            # ensure that all children are registered with the transaction
589
464
            list(self.iter_tree_children(parent_id))
590
465
 
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
466
    def has_named_child(self, by_parent, parent_id, name):
611
467
        try:
612
468
            children = by_parent[parent_id]
666
522
 
667
523
    def _improper_versioning(self):
668
524
        """Cannot version a file with no contents, or a bad type.
669
 
        
 
525
 
670
526
        However, existing entries with no contents are okay.
671
527
        """
672
528
        conflicts = []
682
538
 
683
539
    def _executability_conflicts(self):
684
540
        """Check for bad executability changes.
685
 
        
 
541
 
686
542
        Only versioned files may have their executability set, because
687
543
        1. only versioned entries can have executability under windows
688
544
        2. only files can be executable.  (The execute bit on a directory
721
577
            return conflicts
722
578
        for children in by_parent.itervalues():
723
579
            name_ids = [(self.final_name(t), t) for t in children]
 
580
            if not self._case_sensitive_target:
 
581
                name_ids = [(n.lower(), t) for n, t in name_ids]
724
582
            name_ids.sort()
725
583
            last_name = None
726
584
            last_trans_id = None
744
602
        conflicts = []
745
603
        removed_tree_ids = set((self.tree_file_id(trans_id) for trans_id in
746
604
                                self._removed_id))
747
 
        active_tree_ids = set((f for f in self._tree.inventory if
748
 
                               f not in removed_tree_ids))
 
605
        all_ids = self._tree.all_file_ids()
 
606
        active_tree_ids = all_ids.difference(removed_tree_ids)
749
607
        for trans_id, file_id in self._new_id.iteritems():
750
608
            if file_id in active_tree_ids:
751
609
                old_trans_id = self.trans_id_tree_file_id(file_id)
784
642
                continue
785
643
            return True
786
644
        return False
787
 
            
788
 
    def apply(self, no_conflicts=False):
789
 
        """Apply all changes to the inventory and filesystem.
790
 
        
791
 
        If filesystem or inventory conflicts are present, MalformedTransform
792
 
        will be thrown.
793
 
 
794
 
        If apply succeeds, finalize is not necessary.
795
 
 
796
 
        :param no_conflicts: if True, the caller guarantees there are no
797
 
            conflicts, so no check is made.
798
 
        """
799
 
        if not no_conflicts:
800
 
            conflicts = self.find_conflicts()
801
 
            if len(conflicts) != 0:
802
 
                raise MalformedTransform(conflicts=conflicts)
803
 
        inv = self._tree.inventory
804
 
        inventory_delta = []
805
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
806
 
        try:
807
 
            child_pb.update('Apply phase', 0, 2)
808
 
            self._apply_removals(inv, inventory_delta)
809
 
            child_pb.update('Apply phase', 1, 2)
810
 
            modified_paths = self._apply_insertions(inv, inventory_delta)
811
 
        finally:
812
 
            child_pb.finished()
813
 
        self._tree.apply_inventory_delta(inventory_delta)
814
 
        self.__done = True
815
 
        self.finalize()
816
 
        return _TransformResults(modified_paths, self.rename_count)
817
 
 
818
 
    def _limbo_name(self, trans_id):
819
 
        """Generate the limbo name of a file"""
820
 
        limbo_name = self._limbo_files.get(trans_id)
821
 
        if limbo_name is not None:
822
 
            return limbo_name
823
 
        parent = self._new_parent.get(trans_id)
824
 
        # if the parent directory is already in limbo (e.g. when building a
825
 
        # tree), choose a limbo name inside the parent, to reduce further
826
 
        # renames.
827
 
        use_direct_path = False
828
 
        if self._new_contents.get(parent) == 'directory':
829
 
            filename = self._new_name.get(trans_id)
830
 
            if filename is not None:
831
 
                if parent not in self._limbo_children:
832
 
                    self._limbo_children[parent] = set()
833
 
                    self._limbo_children_names[parent] = {}
834
 
                    use_direct_path = True
835
 
                # the direct path can only be used if no other file has
836
 
                # already taken this pathname, i.e. if the name is unused, or
837
 
                # if it is already associated with this trans_id.
838
 
                elif (self._limbo_children_names[parent].get(filename)
839
 
                      in (trans_id, None)):
840
 
                    use_direct_path = True
841
 
        if use_direct_path:
842
 
            limbo_name = pathjoin(self._limbo_files[parent], filename)
843
 
            self._limbo_children[parent].add(trans_id)
844
 
            self._limbo_children_names[parent][filename] = trans_id
845
 
        else:
846
 
            limbo_name = pathjoin(self._limbodir, trans_id)
847
 
            self._needs_rename.add(trans_id)
848
 
        self._limbo_files[trans_id] = limbo_name
849
 
        return limbo_name
850
 
 
851
 
    def _apply_removals(self, inv, inventory_delta):
852
 
        """Perform tree operations that remove directory/inventory names.
853
 
        
854
 
        That is, delete files that are to be deleted, and put any files that
855
 
        need renaming into limbo.  This must be done in strict child-to-parent
856
 
        order.
857
 
        """
858
 
        tree_paths = list(self._tree_path_ids.iteritems())
859
 
        tree_paths.sort(reverse=True)
860
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
861
 
        try:
862
 
            for num, data in enumerate(tree_paths):
863
 
                path, trans_id = data
864
 
                child_pb.update('removing file', num, len(tree_paths))
865
 
                full_path = self._tree.abspath(path)
866
 
                if trans_id in self._removed_contents:
867
 
                    delete_any(full_path)
868
 
                elif trans_id in self._new_name or trans_id in \
869
 
                    self._new_parent:
870
 
                    try:
871
 
                        os.rename(full_path, self._limbo_name(trans_id))
872
 
                    except OSError, e:
873
 
                        if e.errno != errno.ENOENT:
874
 
                            raise
875
 
                    else:
876
 
                        self.rename_count += 1
877
 
                if trans_id in self._removed_id:
878
 
                    if trans_id == self._new_root:
879
 
                        file_id = self._tree.inventory.root.file_id
880
 
                    else:
881
 
                        file_id = self.tree_file_id(trans_id)
882
 
                    assert file_id is not None
883
 
                    inventory_delta.append((path, None, file_id, None))
884
 
        finally:
885
 
            child_pb.finished()
886
 
 
887
 
    def _apply_insertions(self, inv, inventory_delta):
888
 
        """Perform tree operations that insert directory/inventory names.
889
 
        
890
 
        That is, create any files that need to be created, and restore from
891
 
        limbo any files that needed renaming.  This must be done in strict
892
 
        parent-to-child order.
893
 
        """
894
 
        new_paths = self.new_paths()
895
 
        modified_paths = []
896
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
897
 
        try:
898
 
            for num, (path, trans_id) in enumerate(new_paths):
899
 
                new_entry = None
900
 
                child_pb.update('adding file', num, len(new_paths))
901
 
                try:
902
 
                    kind = self._new_contents[trans_id]
903
 
                except KeyError:
904
 
                    kind = contents = None
905
 
                if trans_id in self._new_contents or \
906
 
                    self.path_changed(trans_id):
907
 
                    full_path = self._tree.abspath(path)
908
 
                    if trans_id in self._needs_rename:
909
 
                        try:
910
 
                            os.rename(self._limbo_name(trans_id), full_path)
911
 
                        except OSError, e:
912
 
                            # We may be renaming a dangling inventory id
913
 
                            if e.errno != errno.ENOENT:
914
 
                                raise
915
 
                        else:
916
 
                            self.rename_count += 1
917
 
                    if trans_id in self._new_contents:
918
 
                        modified_paths.append(full_path)
919
 
                        del self._new_contents[trans_id]
920
 
 
921
 
                if trans_id in self._new_id:
922
 
                    if kind is None:
923
 
                        kind = file_kind(self._tree.abspath(path))
924
 
                    if trans_id in self._new_reference_revision:
925
 
                        new_entry = inventory.TreeReference(
926
 
                            self._new_id[trans_id],
927
 
                            self._new_name[trans_id], 
928
 
                            self.final_file_id(self._new_parent[trans_id]),
929
 
                            None, self._new_reference_revision[trans_id])
930
 
                    else:
931
 
                        new_entry = inventory.make_entry(kind,
932
 
                            self.final_name(trans_id),
933
 
                            self.final_file_id(self.final_parent(trans_id)),
934
 
                            self._new_id[trans_id])
935
 
                else:
936
 
                    if trans_id in self._new_name or trans_id in\
937
 
                        self._new_parent or\
938
 
                        trans_id in self._new_executability:
939
 
                        file_id = self.final_file_id(trans_id)
940
 
                        if file_id is not None:
941
 
                            entry = inv[file_id]
942
 
                            new_entry = entry.copy()
943
 
 
944
 
                    if trans_id in self._new_name or trans_id in\
945
 
                        self._new_parent:
946
 
                            if new_entry is not None:
947
 
                                new_entry.name = self.final_name(trans_id)
948
 
                                parent = self.final_parent(trans_id)
949
 
                                parent_id = self.final_file_id(parent)
950
 
                                new_entry.parent_id = parent_id
951
 
 
952
 
                if trans_id in self._new_executability:
953
 
                    self._set_executability(path, new_entry, trans_id)
954
 
                if new_entry is not None:
955
 
                    if new_entry.file_id in inv:
956
 
                        old_path = inv.id2path(new_entry.file_id)
957
 
                    else:
958
 
                        old_path = None
959
 
                    inventory_delta.append((old_path, path,
960
 
                                            new_entry.file_id,
961
 
                                            new_entry))
962
 
        finally:
963
 
            child_pb.finished()
964
 
        return modified_paths
965
 
 
966
 
    def _set_executability(self, path, entry, trans_id):
 
645
 
 
646
    def _set_executability(self, path, trans_id):
967
647
        """Set the executability of versioned files """
968
 
        new_executability = self._new_executability[trans_id]
969
 
        entry.executable = new_executability
970
648
        if supports_executable():
 
649
            new_executability = self._new_executability[trans_id]
971
650
            abspath = self._tree.abspath(path)
972
651
            current_mode = os.stat(abspath).st_mode
973
652
            if new_executability:
990
669
            self.version_file(file_id, trans_id)
991
670
        return trans_id
992
671
 
993
 
    def new_file(self, name, parent_id, contents, file_id=None, 
 
672
    def new_file(self, name, parent_id, contents, file_id=None,
994
673
                 executable=None):
995
674
        """Convenience method to create files.
996
 
        
 
675
 
997
676
        name is the name of the file to create.
998
677
        parent_id is the transaction id of the parent directory of the file.
999
678
        contents is an iterator of bytestrings, which will be used to produce
1019
698
        """
1020
699
        trans_id = self._new_entry(name, parent_id, file_id)
1021
700
        self.create_directory(trans_id)
1022
 
        return trans_id 
 
701
        return trans_id
1023
702
 
1024
703
    def new_symlink(self, name, parent_id, target, file_id=None):
1025
704
        """Convenience method to create symbolic link.
1026
 
        
 
705
 
1027
706
        name is the name of the symlink to create.
1028
707
        parent_id is the transaction id of the parent directory of the symlink.
1029
708
        target is a bytestring of the target of the symlink.
1068
747
        from_path = self._tree_id_paths.get(from_trans_id)
1069
748
        if from_versioned:
1070
749
            # get data from working tree if versioned
1071
 
            from_entry = self._tree.inventory[file_id]
 
750
            from_entry = self._tree.iter_entries_by_dir([file_id]).next()[1]
1072
751
            from_name = from_entry.name
1073
752
            from_parent = from_entry.parent_id
1074
753
        else:
1110
789
            to_executable = False
1111
790
        return to_name, to_parent, to_kind, to_executable
1112
791
 
1113
 
    def _iter_changes(self):
1114
 
        """Produce output in the same format as Tree._iter_changes.
 
792
    def iter_changes(self):
 
793
        """Produce output in the same format as Tree.iter_changes.
1115
794
 
1116
795
        Will produce nonsensical results if invoked while inventory/filesystem
1117
796
        conflicts (as reported by TreeTransform.find_conflicts()) are present.
1172
851
                   (from_executable, to_executable)))
1173
852
        return iter(sorted(results, key=lambda x:x[1]))
1174
853
 
 
854
    def get_preview_tree(self):
 
855
        """Return a tree representing the result of the transform.
 
856
 
 
857
        This tree only supports the subset of Tree functionality required
 
858
        by show_diff_trees.  It must only be compared to tt._tree.
 
859
        """
 
860
        return _PreviewTree(self)
 
861
 
 
862
    def _text_parent(self, trans_id):
 
863
        file_id = self.tree_file_id(trans_id)
 
864
        try:
 
865
            if file_id is None or self._tree.kind(file_id) != 'file':
 
866
                return None
 
867
        except errors.NoSuchFile:
 
868
            return None
 
869
        return file_id
 
870
 
 
871
    def _get_parents_texts(self, trans_id):
 
872
        """Get texts for compression parents of this file."""
 
873
        file_id = self._text_parent(trans_id)
 
874
        if file_id is None:
 
875
            return ()
 
876
        return (self._tree.get_file_text(file_id),)
 
877
 
 
878
    def _get_parents_lines(self, trans_id):
 
879
        """Get lines for compression parents of this file."""
 
880
        file_id = self._text_parent(trans_id)
 
881
        if file_id is None:
 
882
            return ()
 
883
        return (self._tree.get_file_lines(file_id),)
 
884
 
 
885
    def serialize(self, serializer):
 
886
        """Serialize this TreeTransform.
 
887
 
 
888
        :param serializer: A Serialiser like pack.ContainerSerializer.
 
889
        """
 
890
        new_name = dict((k, v.encode('utf-8')) for k, v in
 
891
                        self._new_name.items())
 
892
        new_executability = dict((k, int(v)) for k, v in
 
893
                                 self._new_executability.items())
 
894
        tree_path_ids = dict((k.encode('utf-8'), v)
 
895
                             for k, v in self._tree_path_ids.items())
 
896
        attribs = {
 
897
            '_id_number': self._id_number,
 
898
            '_new_name': new_name,
 
899
            '_new_parent': self._new_parent,
 
900
            '_new_executability': new_executability,
 
901
            '_new_id': self._new_id,
 
902
            '_tree_path_ids': tree_path_ids,
 
903
            '_removed_id': list(self._removed_id),
 
904
            '_removed_contents': list(self._removed_contents),
 
905
            '_non_present_ids': self._non_present_ids,
 
906
            }
 
907
        yield serializer.bytes_record(bencode.bencode(attribs),
 
908
                                      (('attribs',),))
 
909
        for trans_id, kind in self._new_contents.items():
 
910
            if kind == 'file':
 
911
                lines = osutils.chunks_to_lines(
 
912
                    self._read_file_chunks(trans_id))
 
913
                parents = self._get_parents_lines(trans_id)
 
914
                mpdiff = multiparent.MultiParent.from_lines(lines, parents)
 
915
                content = ''.join(mpdiff.to_patch())
 
916
            if kind == 'directory':
 
917
                content = ''
 
918
            if kind == 'symlink':
 
919
                content = self._read_symlink_target(trans_id)
 
920
            yield serializer.bytes_record(content, ((trans_id, kind),))
 
921
 
 
922
    def deserialize(self, records):
 
923
        """Deserialize a stored TreeTransform.
 
924
 
 
925
        :param records: An iterable of (names, content) tuples, as per
 
926
            pack.ContainerPushParser.
 
927
        """
 
928
        names, content = records.next()
 
929
        attribs = bencode.bdecode(content)
 
930
        self._id_number = attribs['_id_number']
 
931
        self._new_name = dict((k, v.decode('utf-8'))
 
932
                            for k, v in attribs['_new_name'].items())
 
933
        self._new_parent = attribs['_new_parent']
 
934
        self._new_executability = dict((k, bool(v)) for k, v in
 
935
            attribs['_new_executability'].items())
 
936
        self._new_id = attribs['_new_id']
 
937
        self._r_new_id = dict((v, k) for k, v in self._new_id.items())
 
938
        self._tree_path_ids = {}
 
939
        self._tree_id_paths = {}
 
940
        for bytepath, trans_id in attribs['_tree_path_ids'].items():
 
941
            path = bytepath.decode('utf-8')
 
942
            self._tree_path_ids[path] = trans_id
 
943
            self._tree_id_paths[trans_id] = path
 
944
        self._removed_id = set(attribs['_removed_id'])
 
945
        self._removed_contents = set(attribs['_removed_contents'])
 
946
        self._non_present_ids = attribs['_non_present_ids']
 
947
        for ((trans_id, kind),), content in records:
 
948
            if kind == 'file':
 
949
                mpdiff = multiparent.MultiParent.from_patch(content)
 
950
                lines = mpdiff.to_lines(self._get_parents_texts(trans_id))
 
951
                self.create_file(lines, trans_id)
 
952
            if kind == 'directory':
 
953
                self.create_directory(trans_id)
 
954
            if kind == 'symlink':
 
955
                self.create_symlink(content.decode('utf-8'), trans_id)
 
956
 
 
957
 
 
958
class DiskTreeTransform(TreeTransformBase):
 
959
    """Tree transform storing its contents on disk."""
 
960
 
 
961
    def __init__(self, tree, limbodir, pb=DummyProgress(),
 
962
                 case_sensitive=True):
 
963
        """Constructor.
 
964
        :param tree: The tree that will be transformed, but not necessarily
 
965
            the output tree.
 
966
        :param limbodir: A directory where new files can be stored until
 
967
            they are installed in their proper places
 
968
        :param pb: A ProgressBar indicating how much progress is being made
 
969
        :param case_sensitive: If True, the target of the transform is
 
970
            case sensitive, not just case preserving.
 
971
        """
 
972
        TreeTransformBase.__init__(self, tree, pb, case_sensitive)
 
973
        self._limbodir = limbodir
 
974
        self._deletiondir = None
 
975
        # A mapping of transform ids to their limbo filename
 
976
        self._limbo_files = {}
 
977
        # A mapping of transform ids to a set of the transform ids of children
 
978
        # that their limbo directory has
 
979
        self._limbo_children = {}
 
980
        # Map transform ids to maps of child filename to child transform id
 
981
        self._limbo_children_names = {}
 
982
        # List of transform ids that need to be renamed from limbo into place
 
983
        self._needs_rename = set()
 
984
 
 
985
    def finalize(self):
 
986
        """Release the working tree lock, if held, clean up limbo dir.
 
987
 
 
988
        This is required if apply has not been invoked, but can be invoked
 
989
        even after apply.
 
990
        """
 
991
        if self._tree is None:
 
992
            return
 
993
        try:
 
994
            entries = [(self._limbo_name(t), t, k) for t, k in
 
995
                       self._new_contents.iteritems()]
 
996
            entries.sort(reverse=True)
 
997
            for path, trans_id, kind in entries:
 
998
                delete_any(path)
 
999
            try:
 
1000
                delete_any(self._limbodir)
 
1001
            except OSError:
 
1002
                # We don't especially care *why* the dir is immortal.
 
1003
                raise ImmortalLimbo(self._limbodir)
 
1004
            try:
 
1005
                if self._deletiondir is not None:
 
1006
                    delete_any(self._deletiondir)
 
1007
            except OSError:
 
1008
                raise errors.ImmortalPendingDeletion(self._deletiondir)
 
1009
        finally:
 
1010
            TreeTransformBase.finalize(self)
 
1011
 
 
1012
    def _limbo_name(self, trans_id):
 
1013
        """Generate the limbo name of a file"""
 
1014
        limbo_name = self._limbo_files.get(trans_id)
 
1015
        if limbo_name is not None:
 
1016
            return limbo_name
 
1017
        parent = self._new_parent.get(trans_id)
 
1018
        # if the parent directory is already in limbo (e.g. when building a
 
1019
        # tree), choose a limbo name inside the parent, to reduce further
 
1020
        # renames.
 
1021
        use_direct_path = False
 
1022
        if self._new_contents.get(parent) == 'directory':
 
1023
            filename = self._new_name.get(trans_id)
 
1024
            if filename is not None:
 
1025
                if parent not in self._limbo_children:
 
1026
                    self._limbo_children[parent] = set()
 
1027
                    self._limbo_children_names[parent] = {}
 
1028
                    use_direct_path = True
 
1029
                # the direct path can only be used if no other file has
 
1030
                # already taken this pathname, i.e. if the name is unused, or
 
1031
                # if it is already associated with this trans_id.
 
1032
                elif self._case_sensitive_target:
 
1033
                    if (self._limbo_children_names[parent].get(filename)
 
1034
                        in (trans_id, None)):
 
1035
                        use_direct_path = True
 
1036
                else:
 
1037
                    for l_filename, l_trans_id in\
 
1038
                        self._limbo_children_names[parent].iteritems():
 
1039
                        if l_trans_id == trans_id:
 
1040
                            continue
 
1041
                        if l_filename.lower() == filename.lower():
 
1042
                            break
 
1043
                    else:
 
1044
                        use_direct_path = True
 
1045
 
 
1046
        if use_direct_path:
 
1047
            limbo_name = pathjoin(self._limbo_files[parent], filename)
 
1048
            self._limbo_children[parent].add(trans_id)
 
1049
            self._limbo_children_names[parent][filename] = trans_id
 
1050
        else:
 
1051
            limbo_name = pathjoin(self._limbodir, trans_id)
 
1052
            self._needs_rename.add(trans_id)
 
1053
        self._limbo_files[trans_id] = limbo_name
 
1054
        return limbo_name
 
1055
 
 
1056
    def adjust_path(self, name, parent, trans_id):
 
1057
        previous_parent = self._new_parent.get(trans_id)
 
1058
        previous_name = self._new_name.get(trans_id)
 
1059
        TreeTransformBase.adjust_path(self, name, parent, trans_id)
 
1060
        if (trans_id in self._limbo_files and
 
1061
            trans_id not in self._needs_rename):
 
1062
            self._rename_in_limbo([trans_id])
 
1063
            self._limbo_children[previous_parent].remove(trans_id)
 
1064
            del self._limbo_children_names[previous_parent][previous_name]
 
1065
 
 
1066
    def _rename_in_limbo(self, trans_ids):
 
1067
        """Fix limbo names so that the right final path is produced.
 
1068
 
 
1069
        This means we outsmarted ourselves-- we tried to avoid renaming
 
1070
        these files later by creating them with their final names in their
 
1071
        final parents.  But now the previous name or parent is no longer
 
1072
        suitable, so we have to rename them.
 
1073
 
 
1074
        Even for trans_ids that have no new contents, we must remove their
 
1075
        entries from _limbo_files, because they are now stale.
 
1076
        """
 
1077
        for trans_id in trans_ids:
 
1078
            old_path = self._limbo_files.pop(trans_id)
 
1079
            if trans_id not in self._new_contents:
 
1080
                continue
 
1081
            new_path = self._limbo_name(trans_id)
 
1082
            os.rename(old_path, new_path)
 
1083
 
 
1084
    def create_file(self, contents, trans_id, mode_id=None):
 
1085
        """Schedule creation of a new file.
 
1086
 
 
1087
        See also new_file.
 
1088
 
 
1089
        Contents is an iterator of strings, all of which will be written
 
1090
        to the target destination.
 
1091
 
 
1092
        New file takes the permissions of any existing file with that id,
 
1093
        unless mode_id is specified.
 
1094
        """
 
1095
        name = self._limbo_name(trans_id)
 
1096
        f = open(name, 'wb')
 
1097
        try:
 
1098
            try:
 
1099
                unique_add(self._new_contents, trans_id, 'file')
 
1100
            except:
 
1101
                # Clean up the file, it never got registered so
 
1102
                # TreeTransform.finalize() won't clean it up.
 
1103
                f.close()
 
1104
                os.unlink(name)
 
1105
                raise
 
1106
 
 
1107
            f.writelines(contents)
 
1108
        finally:
 
1109
            f.close()
 
1110
        self._set_mode(trans_id, mode_id, S_ISREG)
 
1111
 
 
1112
    def _read_file_chunks(self, trans_id):
 
1113
        cur_file = open(self._limbo_name(trans_id), 'rb')
 
1114
        try:
 
1115
            return cur_file.readlines()
 
1116
        finally:
 
1117
            cur_file.close()
 
1118
 
 
1119
    def _read_symlink_target(self, trans_id):
 
1120
        return os.readlink(self._limbo_name(trans_id))
 
1121
 
 
1122
    def create_hardlink(self, path, trans_id):
 
1123
        """Schedule creation of a hard link"""
 
1124
        name = self._limbo_name(trans_id)
 
1125
        try:
 
1126
            os.link(path, name)
 
1127
        except OSError, e:
 
1128
            if e.errno != errno.EPERM:
 
1129
                raise
 
1130
            raise errors.HardLinkNotSupported(path)
 
1131
        try:
 
1132
            unique_add(self._new_contents, trans_id, 'file')
 
1133
        except:
 
1134
            # Clean up the file, it never got registered so
 
1135
            # TreeTransform.finalize() won't clean it up.
 
1136
            os.unlink(name)
 
1137
            raise
 
1138
 
 
1139
    def create_directory(self, trans_id):
 
1140
        """Schedule creation of a new directory.
 
1141
 
 
1142
        See also new_directory.
 
1143
        """
 
1144
        os.mkdir(self._limbo_name(trans_id))
 
1145
        unique_add(self._new_contents, trans_id, 'directory')
 
1146
 
 
1147
    def create_symlink(self, target, trans_id):
 
1148
        """Schedule creation of a new symbolic link.
 
1149
 
 
1150
        target is a bytestring.
 
1151
        See also new_symlink.
 
1152
        """
 
1153
        if has_symlinks():
 
1154
            os.symlink(target, self._limbo_name(trans_id))
 
1155
            unique_add(self._new_contents, trans_id, 'symlink')
 
1156
        else:
 
1157
            try:
 
1158
                path = FinalPaths(self).get_path(trans_id)
 
1159
            except KeyError:
 
1160
                path = None
 
1161
            raise UnableCreateSymlink(path=path)
 
1162
 
 
1163
    def cancel_creation(self, trans_id):
 
1164
        """Cancel the creation of new file contents."""
 
1165
        del self._new_contents[trans_id]
 
1166
        children = self._limbo_children.get(trans_id)
 
1167
        # if this is a limbo directory with children, move them before removing
 
1168
        # the directory
 
1169
        if children is not None:
 
1170
            self._rename_in_limbo(children)
 
1171
            del self._limbo_children[trans_id]
 
1172
            del self._limbo_children_names[trans_id]
 
1173
        delete_any(self._limbo_name(trans_id))
 
1174
 
 
1175
 
 
1176
class TreeTransform(DiskTreeTransform):
 
1177
    """Represent a tree transformation.
 
1178
 
 
1179
    This object is designed to support incremental generation of the transform,
 
1180
    in any order.
 
1181
 
 
1182
    However, it gives optimum performance when parent directories are created
 
1183
    before their contents.  The transform is then able to put child files
 
1184
    directly in their parent directory, avoiding later renames.
 
1185
 
 
1186
    It is easy to produce malformed transforms, but they are generally
 
1187
    harmless.  Attempting to apply a malformed transform will cause an
 
1188
    exception to be raised before any modifications are made to the tree.
 
1189
 
 
1190
    Many kinds of malformed transforms can be corrected with the
 
1191
    resolve_conflicts function.  The remaining ones indicate programming error,
 
1192
    such as trying to create a file with no path.
 
1193
 
 
1194
    Two sets of file creation methods are supplied.  Convenience methods are:
 
1195
     * new_file
 
1196
     * new_directory
 
1197
     * new_symlink
 
1198
 
 
1199
    These are composed of the low-level methods:
 
1200
     * create_path
 
1201
     * create_file or create_directory or create_symlink
 
1202
     * version_file
 
1203
     * set_executability
 
1204
 
 
1205
    Transform/Transaction ids
 
1206
    -------------------------
 
1207
    trans_ids are temporary ids assigned to all files involved in a transform.
 
1208
    It's possible, even common, that not all files in the Tree have trans_ids.
 
1209
 
 
1210
    trans_ids are used because filenames and file_ids are not good enough
 
1211
    identifiers; filenames change, and not all files have file_ids.  File-ids
 
1212
    are also associated with trans-ids, so that moving a file moves its
 
1213
    file-id.
 
1214
 
 
1215
    trans_ids are only valid for the TreeTransform that generated them.
 
1216
 
 
1217
    Limbo
 
1218
    -----
 
1219
    Limbo is a temporary directory use to hold new versions of files.
 
1220
    Files are added to limbo by create_file, create_directory, create_symlink,
 
1221
    and their convenience variants (new_*).  Files may be removed from limbo
 
1222
    using cancel_creation.  Files are renamed from limbo into their final
 
1223
    location as part of TreeTransform.apply
 
1224
 
 
1225
    Limbo must be cleaned up, by either calling TreeTransform.apply or
 
1226
    calling TreeTransform.finalize.
 
1227
 
 
1228
    Files are placed into limbo inside their parent directories, where
 
1229
    possible.  This reduces subsequent renames, and makes operations involving
 
1230
    lots of files faster.  This optimization is only possible if the parent
 
1231
    directory is created *before* creating any of its children, so avoid
 
1232
    creating children before parents, where possible.
 
1233
 
 
1234
    Pending-deletion
 
1235
    ----------------
 
1236
    This temporary directory is used by _FileMover for storing files that are
 
1237
    about to be deleted.  In case of rollback, the files will be restored.
 
1238
    FileMover does not delete files until it is sure that a rollback will not
 
1239
    happen.
 
1240
    """
 
1241
    def __init__(self, tree, pb=DummyProgress()):
 
1242
        """Note: a tree_write lock is taken on the tree.
 
1243
 
 
1244
        Use TreeTransform.finalize() to release the lock (can be omitted if
 
1245
        TreeTransform.apply() called).
 
1246
        """
 
1247
        tree.lock_tree_write()
 
1248
 
 
1249
        try:
 
1250
            limbodir = urlutils.local_path_from_url(
 
1251
                tree._transport.abspath('limbo'))
 
1252
            try:
 
1253
                os.mkdir(limbodir)
 
1254
            except OSError, e:
 
1255
                if e.errno == errno.EEXIST:
 
1256
                    raise ExistingLimbo(limbodir)
 
1257
            deletiondir = urlutils.local_path_from_url(
 
1258
                tree._transport.abspath('pending-deletion'))
 
1259
            try:
 
1260
                os.mkdir(deletiondir)
 
1261
            except OSError, e:
 
1262
                if e.errno == errno.EEXIST:
 
1263
                    raise errors.ExistingPendingDeletion(deletiondir)
 
1264
        except:
 
1265
            tree.unlock()
 
1266
            raise
 
1267
 
 
1268
        # Cache of realpath results, to speed up canonical_path
 
1269
        self._realpaths = {}
 
1270
        # Cache of relpath results, to speed up canonical_path
 
1271
        self._relpaths = {}
 
1272
        DiskTreeTransform.__init__(self, tree, limbodir, pb,
 
1273
                                   tree.case_sensitive)
 
1274
        self._deletiondir = deletiondir
 
1275
 
 
1276
    def canonical_path(self, path):
 
1277
        """Get the canonical tree-relative path"""
 
1278
        # don't follow final symlinks
 
1279
        abs = self._tree.abspath(path)
 
1280
        if abs in self._relpaths:
 
1281
            return self._relpaths[abs]
 
1282
        dirname, basename = os.path.split(abs)
 
1283
        if dirname not in self._realpaths:
 
1284
            self._realpaths[dirname] = os.path.realpath(dirname)
 
1285
        dirname = self._realpaths[dirname]
 
1286
        abs = pathjoin(dirname, basename)
 
1287
        if dirname in self._relpaths:
 
1288
            relpath = pathjoin(self._relpaths[dirname], basename)
 
1289
            relpath = relpath.rstrip('/\\')
 
1290
        else:
 
1291
            relpath = self._tree.relpath(abs)
 
1292
        self._relpaths[abs] = relpath
 
1293
        return relpath
 
1294
 
 
1295
    def tree_kind(self, trans_id):
 
1296
        """Determine the file kind in the working tree.
 
1297
 
 
1298
        Raises NoSuchFile if the file does not exist
 
1299
        """
 
1300
        path = self._tree_id_paths.get(trans_id)
 
1301
        if path is None:
 
1302
            raise NoSuchFile(None)
 
1303
        try:
 
1304
            return file_kind(self._tree.abspath(path))
 
1305
        except OSError, e:
 
1306
            if e.errno != errno.ENOENT:
 
1307
                raise
 
1308
            else:
 
1309
                raise NoSuchFile(path)
 
1310
 
 
1311
    def _set_mode(self, trans_id, mode_id, typefunc):
 
1312
        """Set the mode of new file contents.
 
1313
        The mode_id is the existing file to get the mode from (often the same
 
1314
        as trans_id).  The operation is only performed if there's a mode match
 
1315
        according to typefunc.
 
1316
        """
 
1317
        if mode_id is None:
 
1318
            mode_id = trans_id
 
1319
        try:
 
1320
            old_path = self._tree_id_paths[mode_id]
 
1321
        except KeyError:
 
1322
            return
 
1323
        try:
 
1324
            mode = os.stat(self._tree.abspath(old_path)).st_mode
 
1325
        except OSError, e:
 
1326
            if e.errno in (errno.ENOENT, errno.ENOTDIR):
 
1327
                # Either old_path doesn't exist, or the parent of the
 
1328
                # target is not a directory (but will be one eventually)
 
1329
                # Either way, we know it doesn't exist *right now*
 
1330
                # See also bug #248448
 
1331
                return
 
1332
            else:
 
1333
                raise
 
1334
        if typefunc(mode):
 
1335
            os.chmod(self._limbo_name(trans_id), mode)
 
1336
 
 
1337
    def iter_tree_children(self, parent_id):
 
1338
        """Iterate through the entry's tree children, if any"""
 
1339
        try:
 
1340
            path = self._tree_id_paths[parent_id]
 
1341
        except KeyError:
 
1342
            return
 
1343
        try:
 
1344
            children = os.listdir(self._tree.abspath(path))
 
1345
        except OSError, e:
 
1346
            if not (osutils._is_error_enotdir(e)
 
1347
                    or e.errno in (errno.ENOENT, errno.ESRCH)):
 
1348
                raise
 
1349
            return
 
1350
 
 
1351
        for child in children:
 
1352
            childpath = joinpath(path, child)
 
1353
            if self._tree.is_control_filename(childpath):
 
1354
                continue
 
1355
            yield self.trans_id_tree_path(childpath)
 
1356
 
 
1357
 
 
1358
    def apply(self, no_conflicts=False, precomputed_delta=None, _mover=None):
 
1359
        """Apply all changes to the inventory and filesystem.
 
1360
 
 
1361
        If filesystem or inventory conflicts are present, MalformedTransform
 
1362
        will be thrown.
 
1363
 
 
1364
        If apply succeeds, finalize is not necessary.
 
1365
 
 
1366
        :param no_conflicts: if True, the caller guarantees there are no
 
1367
            conflicts, so no check is made.
 
1368
        :param precomputed_delta: An inventory delta to use instead of
 
1369
            calculating one.
 
1370
        :param _mover: Supply an alternate FileMover, for testing
 
1371
        """
 
1372
        if not no_conflicts:
 
1373
            conflicts = self.find_conflicts()
 
1374
            if len(conflicts) != 0:
 
1375
                raise MalformedTransform(conflicts=conflicts)
 
1376
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1377
        try:
 
1378
            if precomputed_delta is None:
 
1379
                child_pb.update('Apply phase', 0, 2)
 
1380
                inventory_delta = self._generate_inventory_delta()
 
1381
                offset = 1
 
1382
            else:
 
1383
                inventory_delta = precomputed_delta
 
1384
                offset = 0
 
1385
            if _mover is None:
 
1386
                mover = _FileMover()
 
1387
            else:
 
1388
                mover = _mover
 
1389
            try:
 
1390
                child_pb.update('Apply phase', 0 + offset, 2 + offset)
 
1391
                self._apply_removals(mover)
 
1392
                child_pb.update('Apply phase', 1 + offset, 2 + offset)
 
1393
                modified_paths = self._apply_insertions(mover)
 
1394
            except:
 
1395
                mover.rollback()
 
1396
                raise
 
1397
            else:
 
1398
                mover.apply_deletions()
 
1399
        finally:
 
1400
            child_pb.finished()
 
1401
        self._tree.apply_inventory_delta(inventory_delta)
 
1402
        self._done = True
 
1403
        self.finalize()
 
1404
        return _TransformResults(modified_paths, self.rename_count)
 
1405
 
 
1406
    def _generate_inventory_delta(self):
 
1407
        """Generate an inventory delta for the current transform."""
 
1408
        inventory_delta = []
 
1409
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1410
        new_paths = self._inventory_altered()
 
1411
        total_entries = len(new_paths) + len(self._removed_id)
 
1412
        try:
 
1413
            for num, trans_id in enumerate(self._removed_id):
 
1414
                if (num % 10) == 0:
 
1415
                    child_pb.update('removing file', num, total_entries)
 
1416
                if trans_id == self._new_root:
 
1417
                    file_id = self._tree.get_root_id()
 
1418
                else:
 
1419
                    file_id = self.tree_file_id(trans_id)
 
1420
                # File-id isn't really being deleted, just moved
 
1421
                if file_id in self._r_new_id:
 
1422
                    continue
 
1423
                path = self._tree_id_paths[trans_id]
 
1424
                inventory_delta.append((path, None, file_id, None))
 
1425
            new_path_file_ids = dict((t, self.final_file_id(t)) for p, t in
 
1426
                                     new_paths)
 
1427
            entries = self._tree.iter_entries_by_dir(
 
1428
                new_path_file_ids.values())
 
1429
            old_paths = dict((e.file_id, p) for p, e in entries)
 
1430
            final_kinds = {}
 
1431
            for num, (path, trans_id) in enumerate(new_paths):
 
1432
                if (num % 10) == 0:
 
1433
                    child_pb.update('adding file',
 
1434
                                    num + len(self._removed_id), total_entries)
 
1435
                file_id = new_path_file_ids[trans_id]
 
1436
                if file_id is None:
 
1437
                    continue
 
1438
                needs_entry = False
 
1439
                try:
 
1440
                    kind = self.final_kind(trans_id)
 
1441
                except NoSuchFile:
 
1442
                    kind = self._tree.stored_kind(file_id)
 
1443
                parent_trans_id = self.final_parent(trans_id)
 
1444
                parent_file_id = new_path_file_ids.get(parent_trans_id)
 
1445
                if parent_file_id is None:
 
1446
                    parent_file_id = self.final_file_id(parent_trans_id)
 
1447
                if trans_id in self._new_reference_revision:
 
1448
                    new_entry = inventory.TreeReference(
 
1449
                        file_id,
 
1450
                        self._new_name[trans_id],
 
1451
                        self.final_file_id(self._new_parent[trans_id]),
 
1452
                        None, self._new_reference_revision[trans_id])
 
1453
                else:
 
1454
                    new_entry = inventory.make_entry(kind,
 
1455
                        self.final_name(trans_id),
 
1456
                        parent_file_id, file_id)
 
1457
                old_path = old_paths.get(new_entry.file_id)
 
1458
                new_executability = self._new_executability.get(trans_id)
 
1459
                if new_executability is not None:
 
1460
                    new_entry.executable = new_executability
 
1461
                inventory_delta.append(
 
1462
                    (old_path, path, new_entry.file_id, new_entry))
 
1463
        finally:
 
1464
            child_pb.finished()
 
1465
        return inventory_delta
 
1466
 
 
1467
    def _apply_removals(self, mover):
 
1468
        """Perform tree operations that remove directory/inventory names.
 
1469
 
 
1470
        That is, delete files that are to be deleted, and put any files that
 
1471
        need renaming into limbo.  This must be done in strict child-to-parent
 
1472
        order.
 
1473
 
 
1474
        If inventory_delta is None, no inventory delta generation is performed.
 
1475
        """
 
1476
        tree_paths = list(self._tree_path_ids.iteritems())
 
1477
        tree_paths.sort(reverse=True)
 
1478
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1479
        try:
 
1480
            for num, data in enumerate(tree_paths):
 
1481
                path, trans_id = data
 
1482
                child_pb.update('removing file', num, len(tree_paths))
 
1483
                full_path = self._tree.abspath(path)
 
1484
                if trans_id in self._removed_contents:
 
1485
                    mover.pre_delete(full_path, os.path.join(self._deletiondir,
 
1486
                                     trans_id))
 
1487
                elif trans_id in self._new_name or trans_id in \
 
1488
                    self._new_parent:
 
1489
                    try:
 
1490
                        mover.rename(full_path, self._limbo_name(trans_id))
 
1491
                    except OSError, e:
 
1492
                        if e.errno != errno.ENOENT:
 
1493
                            raise
 
1494
                    else:
 
1495
                        self.rename_count += 1
 
1496
        finally:
 
1497
            child_pb.finished()
 
1498
 
 
1499
    def _apply_insertions(self, mover):
 
1500
        """Perform tree operations that insert directory/inventory names.
 
1501
 
 
1502
        That is, create any files that need to be created, and restore from
 
1503
        limbo any files that needed renaming.  This must be done in strict
 
1504
        parent-to-child order.
 
1505
 
 
1506
        If inventory_delta is None, no inventory delta is calculated, and
 
1507
        no list of modified paths is returned.
 
1508
        """
 
1509
        new_paths = self.new_paths(filesystem_only=True)
 
1510
        modified_paths = []
 
1511
        new_path_file_ids = dict((t, self.final_file_id(t)) for p, t in
 
1512
                                 new_paths)
 
1513
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1514
        try:
 
1515
            for num, (path, trans_id) in enumerate(new_paths):
 
1516
                if (num % 10) == 0:
 
1517
                    child_pb.update('adding file', num, len(new_paths))
 
1518
                full_path = self._tree.abspath(path)
 
1519
                if trans_id in self._needs_rename:
 
1520
                    try:
 
1521
                        mover.rename(self._limbo_name(trans_id), full_path)
 
1522
                    except OSError, e:
 
1523
                        # We may be renaming a dangling inventory id
 
1524
                        if e.errno != errno.ENOENT:
 
1525
                            raise
 
1526
                    else:
 
1527
                        self.rename_count += 1
 
1528
                if (trans_id in self._new_contents or
 
1529
                    self.path_changed(trans_id)):
 
1530
                    if trans_id in self._new_contents:
 
1531
                        modified_paths.append(full_path)
 
1532
                if trans_id in self._new_executability:
 
1533
                    self._set_executability(path, trans_id)
 
1534
        finally:
 
1535
            child_pb.finished()
 
1536
        self._new_contents.clear()
 
1537
        return modified_paths
 
1538
 
 
1539
 
 
1540
class TransformPreview(DiskTreeTransform):
 
1541
    """A TreeTransform for generating preview trees.
 
1542
 
 
1543
    Unlike TreeTransform, this version works when the input tree is a
 
1544
    RevisionTree, rather than a WorkingTree.  As a result, it tends to ignore
 
1545
    unversioned files in the input tree.
 
1546
    """
 
1547
 
 
1548
    def __init__(self, tree, pb=DummyProgress(), case_sensitive=True):
 
1549
        tree.lock_read()
 
1550
        limbodir = osutils.mkdtemp(prefix='bzr-limbo-')
 
1551
        DiskTreeTransform.__init__(self, tree, limbodir, pb, case_sensitive)
 
1552
 
 
1553
    def canonical_path(self, path):
 
1554
        return path
 
1555
 
 
1556
    def tree_kind(self, trans_id):
 
1557
        path = self._tree_id_paths.get(trans_id)
 
1558
        if path is None:
 
1559
            raise NoSuchFile(None)
 
1560
        file_id = self._tree.path2id(path)
 
1561
        return self._tree.kind(file_id)
 
1562
 
 
1563
    def _set_mode(self, trans_id, mode_id, typefunc):
 
1564
        """Set the mode of new file contents.
 
1565
        The mode_id is the existing file to get the mode from (often the same
 
1566
        as trans_id).  The operation is only performed if there's a mode match
 
1567
        according to typefunc.
 
1568
        """
 
1569
        # is it ok to ignore this?  probably
 
1570
        pass
 
1571
 
 
1572
    def iter_tree_children(self, parent_id):
 
1573
        """Iterate through the entry's tree children, if any"""
 
1574
        try:
 
1575
            path = self._tree_id_paths[parent_id]
 
1576
        except KeyError:
 
1577
            return
 
1578
        file_id = self.tree_file_id(parent_id)
 
1579
        if file_id is None:
 
1580
            return
 
1581
        entry = self._tree.iter_entries_by_dir([file_id]).next()[1]
 
1582
        children = getattr(entry, 'children', {})
 
1583
        for child in children:
 
1584
            childpath = joinpath(path, child)
 
1585
            yield self.trans_id_tree_path(childpath)
 
1586
 
 
1587
 
 
1588
class _PreviewTree(tree.Tree):
 
1589
    """Partial implementation of Tree to support show_diff_trees"""
 
1590
 
 
1591
    def __init__(self, transform):
 
1592
        self._transform = transform
 
1593
        self._final_paths = FinalPaths(transform)
 
1594
        self.__by_parent = None
 
1595
        self._parent_ids = []
 
1596
        self._all_children_cache = {}
 
1597
        self._path2trans_id_cache = {}
 
1598
        self._final_name_cache = {}
 
1599
 
 
1600
    def _changes(self, file_id):
 
1601
        for changes in self._transform.iter_changes():
 
1602
            if changes[0] == file_id:
 
1603
                return changes
 
1604
 
 
1605
    def _content_change(self, file_id):
 
1606
        """Return True if the content of this file changed"""
 
1607
        changes = self._changes(file_id)
 
1608
        # changes[2] is true if the file content changed.  See
 
1609
        # InterTree.iter_changes.
 
1610
        return (changes is not None and changes[2])
 
1611
 
 
1612
    def _get_repository(self):
 
1613
        repo = getattr(self._transform._tree, '_repository', None)
 
1614
        if repo is None:
 
1615
            repo = self._transform._tree.branch.repository
 
1616
        return repo
 
1617
 
 
1618
    def _iter_parent_trees(self):
 
1619
        for revision_id in self.get_parent_ids():
 
1620
            try:
 
1621
                yield self.revision_tree(revision_id)
 
1622
            except errors.NoSuchRevisionInTree:
 
1623
                yield self._get_repository().revision_tree(revision_id)
 
1624
 
 
1625
    def _get_file_revision(self, file_id, vf, tree_revision):
 
1626
        parent_keys = [(file_id, self._file_revision(t, file_id)) for t in
 
1627
                       self._iter_parent_trees()]
 
1628
        vf.add_lines((file_id, tree_revision), parent_keys,
 
1629
                     self.get_file(file_id).readlines())
 
1630
        repo = self._get_repository()
 
1631
        base_vf = repo.texts
 
1632
        if base_vf not in vf.fallback_versionedfiles:
 
1633
            vf.fallback_versionedfiles.append(base_vf)
 
1634
        return tree_revision
 
1635
 
 
1636
    def _stat_limbo_file(self, file_id):
 
1637
        trans_id = self._transform.trans_id_file_id(file_id)
 
1638
        name = self._transform._limbo_name(trans_id)
 
1639
        return os.lstat(name)
 
1640
 
 
1641
    @property
 
1642
    def _by_parent(self):
 
1643
        if self.__by_parent is None:
 
1644
            self.__by_parent = self._transform.by_parent()
 
1645
        return self.__by_parent
 
1646
 
 
1647
    def _comparison_data(self, entry, path):
 
1648
        kind, size, executable, link_or_sha1 = self.path_content_summary(path)
 
1649
        if kind == 'missing':
 
1650
            kind = None
 
1651
            executable = False
 
1652
        else:
 
1653
            file_id = self._transform.final_file_id(self._path2trans_id(path))
 
1654
            executable = self.is_executable(file_id, path)
 
1655
        return kind, executable, None
 
1656
 
 
1657
    def lock_read(self):
 
1658
        # Perhaps in theory, this should lock the TreeTransform?
 
1659
        pass
 
1660
 
 
1661
    def unlock(self):
 
1662
        pass
 
1663
 
 
1664
    @property
 
1665
    def inventory(self):
 
1666
        """This Tree does not use inventory as its backing data."""
 
1667
        raise NotImplementedError(_PreviewTree.inventory)
 
1668
 
 
1669
    def get_root_id(self):
 
1670
        return self._transform.final_file_id(self._transform.root)
 
1671
 
 
1672
    def all_file_ids(self):
 
1673
        tree_ids = set(self._transform._tree.all_file_ids())
 
1674
        tree_ids.difference_update(self._transform.tree_file_id(t)
 
1675
                                   for t in self._transform._removed_id)
 
1676
        tree_ids.update(self._transform._new_id.values())
 
1677
        return tree_ids
 
1678
 
 
1679
    def __iter__(self):
 
1680
        return iter(self.all_file_ids())
 
1681
 
 
1682
    def has_id(self, file_id):
 
1683
        if file_id in self._transform._r_new_id:
 
1684
            return True
 
1685
        elif file_id in set([self._transform.tree_file_id(trans_id) for
 
1686
            trans_id in self._transform._removed_id]):
 
1687
            return False
 
1688
        else:
 
1689
            return self._transform._tree.has_id(file_id)
 
1690
 
 
1691
    def _path2trans_id(self, path):
 
1692
        # We must not use None here, because that is a valid value to store.
 
1693
        trans_id = self._path2trans_id_cache.get(path, object)
 
1694
        if trans_id is not object:
 
1695
            return trans_id
 
1696
        segments = splitpath(path)
 
1697
        cur_parent = self._transform.root
 
1698
        for cur_segment in segments:
 
1699
            for child in self._all_children(cur_parent):
 
1700
                final_name = self._final_name_cache.get(child)
 
1701
                if final_name is None:
 
1702
                    final_name = self._transform.final_name(child)
 
1703
                    self._final_name_cache[child] = final_name
 
1704
                if final_name == cur_segment:
 
1705
                    cur_parent = child
 
1706
                    break
 
1707
            else:
 
1708
                self._path2trans_id_cache[path] = None
 
1709
                return None
 
1710
        self._path2trans_id_cache[path] = cur_parent
 
1711
        return cur_parent
 
1712
 
 
1713
    def path2id(self, path):
 
1714
        return self._transform.final_file_id(self._path2trans_id(path))
 
1715
 
 
1716
    def id2path(self, file_id):
 
1717
        trans_id = self._transform.trans_id_file_id(file_id)
 
1718
        try:
 
1719
            return self._final_paths._determine_path(trans_id)
 
1720
        except NoFinalPath:
 
1721
            raise errors.NoSuchId(self, file_id)
 
1722
 
 
1723
    def _all_children(self, trans_id):
 
1724
        children = self._all_children_cache.get(trans_id)
 
1725
        if children is not None:
 
1726
            return children
 
1727
        children = set(self._transform.iter_tree_children(trans_id))
 
1728
        # children in the _new_parent set are provided by _by_parent.
 
1729
        children.difference_update(self._transform._new_parent.keys())
 
1730
        children.update(self._by_parent.get(trans_id, []))
 
1731
        self._all_children_cache[trans_id] = children
 
1732
        return children
 
1733
 
 
1734
    def iter_children(self, file_id):
 
1735
        trans_id = self._transform.trans_id_file_id(file_id)
 
1736
        for child_trans_id in self._all_children(trans_id):
 
1737
            yield self._transform.final_file_id(child_trans_id)
 
1738
 
 
1739
    def extras(self):
 
1740
        possible_extras = set(self._transform.trans_id_tree_path(p) for p
 
1741
                              in self._transform._tree.extras())
 
1742
        possible_extras.update(self._transform._new_contents)
 
1743
        possible_extras.update(self._transform._removed_id)
 
1744
        for trans_id in possible_extras:
 
1745
            if self._transform.final_file_id(trans_id) is None:
 
1746
                yield self._final_paths._determine_path(trans_id)
 
1747
 
 
1748
    def _make_inv_entries(self, ordered_entries, specific_file_ids=None):
 
1749
        for trans_id, parent_file_id in ordered_entries:
 
1750
            file_id = self._transform.final_file_id(trans_id)
 
1751
            if file_id is None:
 
1752
                continue
 
1753
            if (specific_file_ids is not None
 
1754
                and file_id not in specific_file_ids):
 
1755
                continue
 
1756
            try:
 
1757
                kind = self._transform.final_kind(trans_id)
 
1758
            except NoSuchFile:
 
1759
                kind = self._transform._tree.stored_kind(file_id)
 
1760
            new_entry = inventory.make_entry(
 
1761
                kind,
 
1762
                self._transform.final_name(trans_id),
 
1763
                parent_file_id, file_id)
 
1764
            yield new_entry, trans_id
 
1765
 
 
1766
    def _list_files_by_dir(self):
 
1767
        todo = [ROOT_PARENT]
 
1768
        ordered_ids = []
 
1769
        while len(todo) > 0:
 
1770
            parent = todo.pop()
 
1771
            parent_file_id = self._transform.final_file_id(parent)
 
1772
            children = list(self._all_children(parent))
 
1773
            paths = dict(zip(children, self._final_paths.get_paths(children)))
 
1774
            children.sort(key=paths.get)
 
1775
            todo.extend(reversed(children))
 
1776
            for trans_id in children:
 
1777
                ordered_ids.append((trans_id, parent_file_id))
 
1778
        return ordered_ids
 
1779
 
 
1780
    def iter_entries_by_dir(self, specific_file_ids=None):
 
1781
        # This may not be a maximally efficient implementation, but it is
 
1782
        # reasonably straightforward.  An implementation that grafts the
 
1783
        # TreeTransform changes onto the tree's iter_entries_by_dir results
 
1784
        # might be more efficient, but requires tricky inferences about stack
 
1785
        # position.
 
1786
        ordered_ids = self._list_files_by_dir()
 
1787
        for entry, trans_id in self._make_inv_entries(ordered_ids,
 
1788
                                                      specific_file_ids):
 
1789
            yield unicode(self._final_paths.get_path(trans_id)), entry
 
1790
 
 
1791
    def _iter_entries_for_dir(self, dir_path):
 
1792
        """Return path, entry for items in a directory without recursing down."""
 
1793
        dir_file_id = self.path2id(dir_path)
 
1794
        ordered_ids = []
 
1795
        for file_id in self.iter_children(dir_file_id):
 
1796
            trans_id = self._transform.trans_id_file_id(file_id)
 
1797
            ordered_ids.append((trans_id, file_id))
 
1798
        for entry, trans_id in self._make_inv_entries(ordered_ids):
 
1799
            yield unicode(self._final_paths.get_path(trans_id)), entry
 
1800
 
 
1801
    def list_files(self, include_root=False, from_dir=None, recursive=True):
 
1802
        """See WorkingTree.list_files."""
 
1803
        # XXX This should behave like WorkingTree.list_files, but is really
 
1804
        # more like RevisionTree.list_files.
 
1805
        if recursive:
 
1806
            prefix = None
 
1807
            if from_dir:
 
1808
                prefix = from_dir + '/'
 
1809
            entries = self.iter_entries_by_dir()
 
1810
            for path, entry in entries:
 
1811
                if entry.name == '' and not include_root:
 
1812
                    continue
 
1813
                if prefix:
 
1814
                    if not path.startswith(prefix):
 
1815
                        continue
 
1816
                    path = path[len(prefix):]
 
1817
                yield path, 'V', entry.kind, entry.file_id, entry
 
1818
        else:
 
1819
            if from_dir is None and include_root is True:
 
1820
                root_entry = inventory.make_entry('directory', '',
 
1821
                    ROOT_PARENT, self.get_root_id())
 
1822
                yield '', 'V', 'directory', root_entry.file_id, root_entry
 
1823
            entries = self._iter_entries_for_dir(from_dir or '')
 
1824
            for path, entry in entries:
 
1825
                yield path, 'V', entry.kind, entry.file_id, entry
 
1826
 
 
1827
    def kind(self, file_id):
 
1828
        trans_id = self._transform.trans_id_file_id(file_id)
 
1829
        return self._transform.final_kind(trans_id)
 
1830
 
 
1831
    def stored_kind(self, file_id):
 
1832
        trans_id = self._transform.trans_id_file_id(file_id)
 
1833
        try:
 
1834
            return self._transform._new_contents[trans_id]
 
1835
        except KeyError:
 
1836
            return self._transform._tree.stored_kind(file_id)
 
1837
 
 
1838
    def get_file_mtime(self, file_id, path=None):
 
1839
        """See Tree.get_file_mtime"""
 
1840
        if not self._content_change(file_id):
 
1841
            return self._transform._tree.get_file_mtime(file_id, path)
 
1842
        return self._stat_limbo_file(file_id).st_mtime
 
1843
 
 
1844
    def _file_size(self, entry, stat_value):
 
1845
        return self.get_file_size(entry.file_id)
 
1846
 
 
1847
    def get_file_size(self, file_id):
 
1848
        """See Tree.get_file_size"""
 
1849
        if self.kind(file_id) == 'file':
 
1850
            return self._transform._tree.get_file_size(file_id)
 
1851
        else:
 
1852
            return None
 
1853
 
 
1854
    def get_file_sha1(self, file_id, path=None, stat_value=None):
 
1855
        trans_id = self._transform.trans_id_file_id(file_id)
 
1856
        kind = self._transform._new_contents.get(trans_id)
 
1857
        if kind is None:
 
1858
            return self._transform._tree.get_file_sha1(file_id)
 
1859
        if kind == 'file':
 
1860
            fileobj = self.get_file(file_id)
 
1861
            try:
 
1862
                return sha_file(fileobj)
 
1863
            finally:
 
1864
                fileobj.close()
 
1865
 
 
1866
    def is_executable(self, file_id, path=None):
 
1867
        if file_id is None:
 
1868
            return False
 
1869
        trans_id = self._transform.trans_id_file_id(file_id)
 
1870
        try:
 
1871
            return self._transform._new_executability[trans_id]
 
1872
        except KeyError:
 
1873
            try:
 
1874
                return self._transform._tree.is_executable(file_id, path)
 
1875
            except OSError, e:
 
1876
                if e.errno == errno.ENOENT:
 
1877
                    return False
 
1878
                raise
 
1879
            except errors.NoSuchId:
 
1880
                return False
 
1881
 
 
1882
    def path_content_summary(self, path):
 
1883
        trans_id = self._path2trans_id(path)
 
1884
        tt = self._transform
 
1885
        tree_path = tt._tree_id_paths.get(trans_id)
 
1886
        kind = tt._new_contents.get(trans_id)
 
1887
        if kind is None:
 
1888
            if tree_path is None or trans_id in tt._removed_contents:
 
1889
                return 'missing', None, None, None
 
1890
            summary = tt._tree.path_content_summary(tree_path)
 
1891
            kind, size, executable, link_or_sha1 = summary
 
1892
        else:
 
1893
            link_or_sha1 = None
 
1894
            limbo_name = tt._limbo_name(trans_id)
 
1895
            if trans_id in tt._new_reference_revision:
 
1896
                kind = 'tree-reference'
 
1897
            if kind == 'file':
 
1898
                statval = os.lstat(limbo_name)
 
1899
                size = statval.st_size
 
1900
                if not supports_executable():
 
1901
                    executable = None
 
1902
                else:
 
1903
                    executable = statval.st_mode & S_IEXEC
 
1904
            else:
 
1905
                size = None
 
1906
                executable = None
 
1907
            if kind == 'symlink':
 
1908
                link_or_sha1 = os.readlink(limbo_name).decode(osutils._fs_enc)
 
1909
        if supports_executable():
 
1910
            executable = tt._new_executability.get(trans_id, executable)
 
1911
        return kind, size, executable, link_or_sha1
 
1912
 
 
1913
    def iter_changes(self, from_tree, include_unchanged=False,
 
1914
                      specific_files=None, pb=None, extra_trees=None,
 
1915
                      require_versioned=True, want_unversioned=False):
 
1916
        """See InterTree.iter_changes.
 
1917
 
 
1918
        This has a fast path that is only used when the from_tree matches
 
1919
        the transform tree, and no fancy options are supplied.
 
1920
        """
 
1921
        if (from_tree is not self._transform._tree or include_unchanged or
 
1922
            specific_files or want_unversioned):
 
1923
            return tree.InterTree(from_tree, self).iter_changes(
 
1924
                include_unchanged=include_unchanged,
 
1925
                specific_files=specific_files,
 
1926
                pb=pb,
 
1927
                extra_trees=extra_trees,
 
1928
                require_versioned=require_versioned,
 
1929
                want_unversioned=want_unversioned)
 
1930
        if want_unversioned:
 
1931
            raise ValueError('want_unversioned is not supported')
 
1932
        return self._transform.iter_changes()
 
1933
 
 
1934
    def get_file(self, file_id, path=None):
 
1935
        """See Tree.get_file"""
 
1936
        if not self._content_change(file_id):
 
1937
            return self._transform._tree.get_file(file_id, path)
 
1938
        trans_id = self._transform.trans_id_file_id(file_id)
 
1939
        name = self._transform._limbo_name(trans_id)
 
1940
        return open(name, 'rb')
 
1941
 
 
1942
    def get_file_with_stat(self, file_id, path=None):
 
1943
        return self.get_file(file_id, path), None
 
1944
 
 
1945
    def annotate_iter(self, file_id,
 
1946
                      default_revision=_mod_revision.CURRENT_REVISION):
 
1947
        changes = self._changes(file_id)
 
1948
        if changes is None:
 
1949
            get_old = True
 
1950
        else:
 
1951
            changed_content, versioned, kind = (changes[2], changes[3],
 
1952
                                                changes[6])
 
1953
            if kind[1] is None:
 
1954
                return None
 
1955
            get_old = (kind[0] == 'file' and versioned[0])
 
1956
        if get_old:
 
1957
            old_annotation = self._transform._tree.annotate_iter(file_id,
 
1958
                default_revision=default_revision)
 
1959
        else:
 
1960
            old_annotation = []
 
1961
        if changes is None:
 
1962
            return old_annotation
 
1963
        if not changed_content:
 
1964
            return old_annotation
 
1965
        return annotate.reannotate([old_annotation],
 
1966
                                   self.get_file(file_id).readlines(),
 
1967
                                   default_revision)
 
1968
 
 
1969
    def get_symlink_target(self, file_id):
 
1970
        """See Tree.get_symlink_target"""
 
1971
        if not self._content_change(file_id):
 
1972
            return self._transform._tree.get_symlink_target(file_id)
 
1973
        trans_id = self._transform.trans_id_file_id(file_id)
 
1974
        name = self._transform._limbo_name(trans_id)
 
1975
        return osutils.readlink(name)
 
1976
 
 
1977
    def walkdirs(self, prefix=''):
 
1978
        pending = [self._transform.root]
 
1979
        while len(pending) > 0:
 
1980
            parent_id = pending.pop()
 
1981
            children = []
 
1982
            subdirs = []
 
1983
            prefix = prefix.rstrip('/')
 
1984
            parent_path = self._final_paths.get_path(parent_id)
 
1985
            parent_file_id = self._transform.final_file_id(parent_id)
 
1986
            for child_id in self._all_children(parent_id):
 
1987
                path_from_root = self._final_paths.get_path(child_id)
 
1988
                basename = self._transform.final_name(child_id)
 
1989
                file_id = self._transform.final_file_id(child_id)
 
1990
                try:
 
1991
                    kind = self._transform.final_kind(child_id)
 
1992
                    versioned_kind = kind
 
1993
                except NoSuchFile:
 
1994
                    kind = 'unknown'
 
1995
                    versioned_kind = self._transform._tree.stored_kind(file_id)
 
1996
                if versioned_kind == 'directory':
 
1997
                    subdirs.append(child_id)
 
1998
                children.append((path_from_root, basename, kind, None,
 
1999
                                 file_id, versioned_kind))
 
2000
            children.sort()
 
2001
            if parent_path.startswith(prefix):
 
2002
                yield (parent_path, parent_file_id), children
 
2003
            pending.extend(sorted(subdirs, key=self._final_paths.get_path,
 
2004
                                  reverse=True))
 
2005
 
 
2006
    def get_parent_ids(self):
 
2007
        return self._parent_ids
 
2008
 
 
2009
    def set_parent_ids(self, parent_ids):
 
2010
        self._parent_ids = parent_ids
 
2011
 
 
2012
    def get_revision_tree(self, revision_id):
 
2013
        return self._transform._tree.get_revision_tree(revision_id)
 
2014
 
1175
2015
 
1176
2016
def joinpath(parent, child):
1177
2017
    """Join tree-relative paths, handling the tree root specially"""
1208
2048
            self._known_paths[trans_id] = self._determine_path(trans_id)
1209
2049
        return self._known_paths[trans_id]
1210
2050
 
 
2051
    def get_paths(self, trans_ids):
 
2052
        return [(self.get_path(t), t) for t in trans_ids]
 
2053
 
 
2054
 
 
2055
 
1211
2056
def topology_sorted_ids(tree):
1212
2057
    """Determine the topological order of the ids in a tree"""
1213
2058
    file_ids = list(tree)
1215
2060
    return file_ids
1216
2061
 
1217
2062
 
1218
 
def build_tree(tree, wt):
 
2063
def build_tree(tree, wt, accelerator_tree=None, hardlink=False,
 
2064
               delta_from_tree=False):
1219
2065
    """Create working tree for a branch, using a TreeTransform.
1220
 
    
 
2066
 
1221
2067
    This function should be used on empty trees, having a tree root at most.
1222
2068
    (see merge and revert functionality for working with existing trees)
1223
2069
 
1224
2070
    Existing files are handled like so:
1225
 
    
 
2071
 
1226
2072
    - Existing bzrdirs take precedence over creating new items.  They are
1227
2073
      created as '%s.diverted' % name.
1228
2074
    - Otherwise, if the content on disk matches the content we are building,
1229
2075
      it is silently replaced.
1230
2076
    - Otherwise, conflict resolution will move the old file to 'oldname.moved'.
 
2077
 
 
2078
    :param tree: The tree to convert wt into a copy of
 
2079
    :param wt: The working tree that files will be placed into
 
2080
    :param accelerator_tree: A tree which can be used for retrieving file
 
2081
        contents more quickly than tree itself, i.e. a workingtree.  tree
 
2082
        will be used for cases where accelerator_tree's content is different.
 
2083
    :param hardlink: If true, hard-link files to accelerator_tree, where
 
2084
        possible.  accelerator_tree must implement abspath, i.e. be a
 
2085
        working tree.
 
2086
    :param delta_from_tree: If true, build_tree may use the input Tree to
 
2087
        generate the inventory delta.
1231
2088
    """
1232
2089
    wt.lock_tree_write()
1233
2090
    try:
1234
2091
        tree.lock_read()
1235
2092
        try:
1236
 
            return _build_tree(tree, wt)
 
2093
            if accelerator_tree is not None:
 
2094
                accelerator_tree.lock_read()
 
2095
            try:
 
2096
                return _build_tree(tree, wt, accelerator_tree, hardlink,
 
2097
                                   delta_from_tree)
 
2098
            finally:
 
2099
                if accelerator_tree is not None:
 
2100
                    accelerator_tree.unlock()
1237
2101
        finally:
1238
2102
            tree.unlock()
1239
2103
    finally:
1240
2104
        wt.unlock()
1241
2105
 
1242
 
def _build_tree(tree, wt):
 
2106
 
 
2107
def _build_tree(tree, wt, accelerator_tree, hardlink, delta_from_tree):
1243
2108
    """See build_tree."""
1244
 
    if len(wt.inventory) > 1:  # more than just a root
1245
 
        raise errors.WorkingTreeAlreadyPopulated(base=wt.basedir)
 
2109
    for num, _unused in enumerate(wt.all_file_ids()):
 
2110
        if num > 0:  # more than just a root
 
2111
            raise errors.WorkingTreeAlreadyPopulated(base=wt.basedir)
 
2112
    existing_files = set()
 
2113
    for dir, files in wt.walkdirs():
 
2114
        existing_files.update(f[0] for f in files)
1246
2115
    file_trans_id = {}
1247
2116
    top_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1248
2117
    pp = ProgressPhase("Build phase", 2, top_pb)
1254
2123
        # is set within the tree, nor setting the root and thus
1255
2124
        # marking the tree as dirty, because we use two different
1256
2125
        # idioms here: tree interfaces and inventory interfaces.
1257
 
        if wt.path2id('') != tree.inventory.root.file_id:
1258
 
            wt.set_root_id(tree.inventory.root.file_id)
 
2126
        if wt.get_root_id() != tree.get_root_id():
 
2127
            wt.set_root_id(tree.get_root_id())
1259
2128
            wt.flush()
1260
2129
    tt = TreeTransform(wt)
1261
2130
    divert = set()
1265
2134
            tt.trans_id_tree_file_id(wt.get_root_id())
1266
2135
        pb = bzrlib.ui.ui_factory.nested_progress_bar()
1267
2136
        try:
 
2137
            deferred_contents = []
 
2138
            num = 0
 
2139
            total = len(tree.inventory)
 
2140
            if delta_from_tree:
 
2141
                precomputed_delta = []
 
2142
            else:
 
2143
                precomputed_delta = None
1268
2144
            for num, (tree_path, entry) in \
1269
2145
                enumerate(tree.inventory.iter_entries_by_dir()):
1270
 
                pb.update("Building tree", num, len(tree.inventory))
 
2146
                pb.update("Building tree", num - len(deferred_contents), total)
1271
2147
                if entry.parent_id is None:
1272
2148
                    continue
1273
2149
                reparent = False
1274
2150
                file_id = entry.file_id
1275
 
                target_path = wt.abspath(tree_path)
1276
 
                try:
 
2151
                if delta_from_tree:
 
2152
                    precomputed_delta.append((None, tree_path, file_id, entry))
 
2153
                if tree_path in existing_files:
 
2154
                    target_path = wt.abspath(tree_path)
1277
2155
                    kind = file_kind(target_path)
1278
 
                except NoSuchFile:
1279
 
                    pass
1280
 
                else:
1281
2156
                    if kind == "directory":
1282
2157
                        try:
1283
2158
                            bzrdir.BzrDir.open(target_path)
1291
2166
                        tt.delete_contents(tt.trans_id_tree_path(tree_path))
1292
2167
                        if kind == 'directory':
1293
2168
                            reparent = True
1294
 
                if entry.parent_id not in file_trans_id:
1295
 
                    raise AssertionError(
1296
 
                        'entry %s parent id %r is not in file_trans_id %r'
1297
 
                        % (entry, entry.parent_id, file_trans_id))
1298
2169
                parent_id = file_trans_id[entry.parent_id]
1299
 
                file_trans_id[file_id] = new_by_entry(tt, entry, parent_id,
1300
 
                                                      tree)
 
2170
                if entry.kind == 'file':
 
2171
                    # We *almost* replicate new_by_entry, so that we can defer
 
2172
                    # getting the file text, and get them all at once.
 
2173
                    trans_id = tt.create_path(entry.name, parent_id)
 
2174
                    file_trans_id[file_id] = trans_id
 
2175
                    tt.version_file(file_id, trans_id)
 
2176
                    executable = tree.is_executable(file_id, tree_path)
 
2177
                    if executable:
 
2178
                        tt.set_executability(executable, trans_id)
 
2179
                    trans_data = (trans_id, tree_path)
 
2180
                    deferred_contents.append((file_id, trans_data))
 
2181
                else:
 
2182
                    file_trans_id[file_id] = new_by_entry(tt, entry, parent_id,
 
2183
                                                          tree)
1301
2184
                if reparent:
1302
2185
                    new_trans_id = file_trans_id[file_id]
1303
2186
                    old_parent = tt.trans_id_tree_path(tree_path)
1304
2187
                    _reparent_children(tt, old_parent, new_trans_id)
 
2188
            offset = num + 1 - len(deferred_contents)
 
2189
            _create_files(tt, tree, deferred_contents, pb, offset,
 
2190
                          accelerator_tree, hardlink)
1305
2191
        finally:
1306
2192
            pb.finished()
1307
2193
        pp.next_phase()
1308
2194
        divert_trans = set(file_trans_id[f] for f in divert)
1309
2195
        resolver = lambda t, c: resolve_checkout(t, c, divert_trans)
1310
2196
        raw_conflicts = resolve_conflicts(tt, pass_func=resolver)
 
2197
        if len(raw_conflicts) > 0:
 
2198
            precomputed_delta = None
1311
2199
        conflicts = cook_conflicts(raw_conflicts, tt)
1312
2200
        for conflict in conflicts:
1313
2201
            warning(conflict)
1315
2203
            wt.add_conflicts(conflicts)
1316
2204
        except errors.UnsupportedOperation:
1317
2205
            pass
1318
 
        result = tt.apply()
 
2206
        result = tt.apply(no_conflicts=True,
 
2207
                          precomputed_delta=precomputed_delta)
1319
2208
    finally:
1320
2209
        tt.finalize()
1321
2210
        top_pb.finished()
1322
2211
    return result
1323
2212
 
1324
2213
 
 
2214
def _create_files(tt, tree, desired_files, pb, offset, accelerator_tree,
 
2215
                  hardlink):
 
2216
    total = len(desired_files) + offset
 
2217
    wt = tt._tree
 
2218
    if accelerator_tree is None:
 
2219
        new_desired_files = desired_files
 
2220
    else:
 
2221
        iter = accelerator_tree.iter_changes(tree, include_unchanged=True)
 
2222
        unchanged = dict((f, p[1]) for (f, p, c, v, d, n, k, e)
 
2223
                         in iter if not (c or e[0] != e[1]))
 
2224
        new_desired_files = []
 
2225
        count = 0
 
2226
        for file_id, (trans_id, tree_path) in desired_files:
 
2227
            accelerator_path = unchanged.get(file_id)
 
2228
            if accelerator_path is None:
 
2229
                new_desired_files.append((file_id, (trans_id, tree_path)))
 
2230
                continue
 
2231
            pb.update('Adding file contents', count + offset, total)
 
2232
            if hardlink:
 
2233
                tt.create_hardlink(accelerator_tree.abspath(accelerator_path),
 
2234
                                   trans_id)
 
2235
            else:
 
2236
                contents = accelerator_tree.get_file(file_id, accelerator_path)
 
2237
                if wt.supports_content_filtering():
 
2238
                    filters = wt._content_filter_stack(tree_path)
 
2239
                    contents = filtered_output_bytes(contents, filters,
 
2240
                        ContentFilterContext(tree_path, tree))
 
2241
                try:
 
2242
                    tt.create_file(contents, trans_id)
 
2243
                finally:
 
2244
                    try:
 
2245
                        contents.close()
 
2246
                    except AttributeError:
 
2247
                        # after filtering, contents may no longer be file-like
 
2248
                        pass
 
2249
            count += 1
 
2250
        offset += count
 
2251
    for count, ((trans_id, tree_path), contents) in enumerate(
 
2252
            tree.iter_files_bytes(new_desired_files)):
 
2253
        if wt.supports_content_filtering():
 
2254
            filters = wt._content_filter_stack(tree_path)
 
2255
            contents = filtered_output_bytes(contents, filters,
 
2256
                ContentFilterContext(tree_path, tree))
 
2257
        tt.create_file(contents, trans_id)
 
2258
        pb.update('Adding file contents', count + offset, total)
 
2259
 
 
2260
 
1325
2261
def _reparent_children(tt, old_parent, new_parent):
1326
2262
    for child in tt.iter_tree_children(old_parent):
1327
2263
        tt.adjust_path(tt.final_name(child), new_parent, child)
1328
2264
 
 
2265
def _reparent_transform_children(tt, old_parent, new_parent):
 
2266
    by_parent = tt.by_parent()
 
2267
    for child in by_parent[old_parent]:
 
2268
        tt.adjust_path(tt.final_name(child), new_parent, child)
 
2269
    return by_parent[old_parent]
1329
2270
 
1330
2271
def _content_match(tree, entry, file_id, kind, target_path):
1331
2272
    if entry.kind != kind:
1345
2286
    new_conflicts = set()
1346
2287
    for c_type, conflict in ((c[0], c) for c in conflicts):
1347
2288
        # Anything but a 'duplicate' would indicate programmer error
1348
 
        assert c_type == 'duplicate', c_type
 
2289
        if c_type != 'duplicate':
 
2290
            raise AssertionError(c_type)
1349
2291
        # Now figure out which is new and which is old
1350
2292
        if tt.new_contents(conflict[1]):
1351
2293
            new_file = conflict[1]
1377
2319
    if kind == 'file':
1378
2320
        contents = tree.get_file(entry.file_id).readlines()
1379
2321
        executable = tree.is_executable(entry.file_id)
1380
 
        return tt.new_file(name, parent_id, contents, entry.file_id, 
 
2322
        return tt.new_file(name, parent_id, contents, entry.file_id,
1381
2323
                           executable)
1382
2324
    elif kind in ('directory', 'tree-reference'):
1383
2325
        trans_id = tt.new_directory(name, parent_id, entry.file_id)
1384
2326
        if kind == 'tree-reference':
1385
2327
            tt.set_tree_reference(entry.reference_revision, trans_id)
1386
 
        return trans_id 
 
2328
        return trans_id
1387
2329
    elif kind == 'symlink':
1388
2330
        target = tree.get_symlink_target(entry.file_id)
1389
2331
        return tt.new_symlink(name, parent_id, target, entry.file_id)
1390
2332
    else:
1391
2333
        raise errors.BadFileKindError(name, kind)
1392
2334
 
 
2335
 
 
2336
@deprecated_function(deprecated_in((1, 9, 0)))
1393
2337
def create_by_entry(tt, entry, tree, trans_id, lines=None, mode_id=None):
1394
 
    """Create new file contents according to an inventory entry."""
 
2338
    """Create new file contents according to an inventory entry.
 
2339
 
 
2340
    DEPRECATED.  Use create_from_tree instead.
 
2341
    """
1395
2342
    if entry.kind == "file":
1396
2343
        if lines is None:
1397
2344
            lines = tree.get_file(entry.file_id).readlines()
1401
2348
    elif entry.kind == "directory":
1402
2349
        tt.create_directory(trans_id)
1403
2350
 
 
2351
 
 
2352
def create_from_tree(tt, trans_id, tree, file_id, bytes=None):
 
2353
    """Create new file contents according to tree contents."""
 
2354
    kind = tree.kind(file_id)
 
2355
    if kind == 'directory':
 
2356
        tt.create_directory(trans_id)
 
2357
    elif kind == "file":
 
2358
        if bytes is None:
 
2359
            tree_file = tree.get_file(file_id)
 
2360
            try:
 
2361
                bytes = tree_file.readlines()
 
2362
            finally:
 
2363
                tree_file.close()
 
2364
        tt.create_file(bytes, trans_id)
 
2365
    elif kind == "symlink":
 
2366
        tt.create_symlink(tree.get_symlink_target(file_id), trans_id)
 
2367
    else:
 
2368
        raise AssertionError('Unknown kind %r' % kind)
 
2369
 
 
2370
 
1404
2371
def create_entry_executability(tt, entry, trans_id):
1405
2372
    """Set the executability of a trans_id according to an inventory entry"""
1406
2373
    if entry.kind == "file":
1407
2374
        tt.set_executability(entry.executable, trans_id)
1408
2375
 
1409
2376
 
1410
 
@deprecated_function(zero_fifteen)
1411
 
def find_interesting(working_tree, target_tree, filenames):
1412
 
    """Find the ids corresponding to specified filenames.
1413
 
    
1414
 
    Deprecated: Please use tree1.paths2ids(filenames, [tree2]).
1415
 
    """
1416
 
    working_tree.lock_read()
1417
 
    try:
1418
 
        target_tree.lock_read()
1419
 
        try:
1420
 
            return working_tree.paths2ids(filenames, [target_tree])
1421
 
        finally:
1422
 
            target_tree.unlock()
1423
 
    finally:
1424
 
        working_tree.unlock()
1425
 
 
1426
 
 
1427
 
def change_entry(tt, file_id, working_tree, target_tree, 
1428
 
                 trans_id_file_id, backups, trans_id, by_parent):
1429
 
    """Replace a file_id's contents with those from a target tree."""
1430
 
    e_trans_id = trans_id_file_id(file_id)
1431
 
    entry = target_tree.inventory[file_id]
1432
 
    has_contents, contents_mod, meta_mod, = _entry_changes(file_id, entry, 
1433
 
                                                           working_tree)
1434
 
    if contents_mod:
1435
 
        mode_id = e_trans_id
1436
 
        if has_contents:
1437
 
            if not backups:
1438
 
                tt.delete_contents(e_trans_id)
1439
 
            else:
1440
 
                parent_trans_id = trans_id_file_id(entry.parent_id)
1441
 
                backup_name = get_backup_name(entry, by_parent,
1442
 
                                              parent_trans_id, tt)
1443
 
                tt.adjust_path(backup_name, parent_trans_id, e_trans_id)
1444
 
                tt.unversion_file(e_trans_id)
1445
 
                e_trans_id = tt.create_path(entry.name, parent_trans_id)
1446
 
                tt.version_file(file_id, e_trans_id)
1447
 
                trans_id[file_id] = e_trans_id
1448
 
        create_by_entry(tt, entry, target_tree, e_trans_id, mode_id=mode_id)
1449
 
        create_entry_executability(tt, entry, e_trans_id)
1450
 
 
1451
 
    elif meta_mod:
1452
 
        tt.set_executability(entry.executable, e_trans_id)
1453
 
    if tt.final_name(e_trans_id) != entry.name:
1454
 
        adjust_path  = True
1455
 
    else:
1456
 
        parent_id = tt.final_parent(e_trans_id)
1457
 
        parent_file_id = tt.final_file_id(parent_id)
1458
 
        if parent_file_id != entry.parent_id:
1459
 
            adjust_path = True
1460
 
        else:
1461
 
            adjust_path = False
1462
 
    if adjust_path:
1463
 
        parent_trans_id = trans_id_file_id(entry.parent_id)
1464
 
        tt.adjust_path(entry.name, parent_trans_id, e_trans_id)
1465
 
 
1466
 
 
1467
2377
def get_backup_name(entry, by_parent, parent_trans_id, tt):
1468
2378
    return _get_backup_name(entry.name, by_parent, parent_trans_id, tt)
1469
2379
 
1500
2410
        if entry.kind != working_kind:
1501
2411
            contents_mod, meta_mod = True, False
1502
2412
        else:
1503
 
            cur_entry._read_tree_state(working_tree.id2path(file_id), 
 
2413
            cur_entry._read_tree_state(working_tree.id2path(file_id),
1504
2414
                                       working_tree)
1505
2415
            contents_mod, meta_mod = entry.detect_changes(cur_entry)
1506
2416
            cur_entry._forget_tree_state()
1514
2424
    tt = TreeTransform(working_tree, pb)
1515
2425
    try:
1516
2426
        pp = ProgressPhase("Revert phase", 3, pb)
1517
 
        pp.next_phase()
1518
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1519
 
        try:
1520
 
            merge_modified = _alter_files(working_tree, target_tree, tt,
1521
 
                                          child_pb, filenames, backups)
1522
 
        finally:
1523
 
            child_pb.finished()
1524
 
        pp.next_phase()
1525
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1526
 
        try:
1527
 
            raw_conflicts = resolve_conflicts(tt, child_pb)
1528
 
        finally:
1529
 
            child_pb.finished()
1530
 
        conflicts = cook_conflicts(raw_conflicts, tt)
 
2427
        conflicts, merge_modified = _prepare_revert_transform(
 
2428
            working_tree, target_tree, tt, filenames, backups, pp)
1531
2429
        if change_reporter:
1532
2430
            change_reporter = delta._ChangeReporter(
1533
2431
                unversioned_filter=working_tree.is_ignored)
1534
 
            delta.report_changes(tt._iter_changes(), change_reporter)
 
2432
            delta.report_changes(tt.iter_changes(), change_reporter)
1535
2433
        for conflict in conflicts:
1536
2434
            warning(conflict)
1537
2435
        pp.next_phase()
1544
2442
    return conflicts
1545
2443
 
1546
2444
 
 
2445
def _prepare_revert_transform(working_tree, target_tree, tt, filenames,
 
2446
                              backups, pp, basis_tree=None,
 
2447
                              merge_modified=None):
 
2448
    pp.next_phase()
 
2449
    child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
2450
    try:
 
2451
        if merge_modified is None:
 
2452
            merge_modified = working_tree.merge_modified()
 
2453
        merge_modified = _alter_files(working_tree, target_tree, tt,
 
2454
                                      child_pb, filenames, backups,
 
2455
                                      merge_modified, basis_tree)
 
2456
    finally:
 
2457
        child_pb.finished()
 
2458
    pp.next_phase()
 
2459
    child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
2460
    try:
 
2461
        raw_conflicts = resolve_conflicts(tt, child_pb,
 
2462
            lambda t, c: conflict_pass(t, c, target_tree))
 
2463
    finally:
 
2464
        child_pb.finished()
 
2465
    conflicts = cook_conflicts(raw_conflicts, tt)
 
2466
    return conflicts, merge_modified
 
2467
 
 
2468
 
1547
2469
def _alter_files(working_tree, target_tree, tt, pb, specific_files,
1548
 
                 backups):
1549
 
    merge_modified = working_tree.merge_modified()
1550
 
    change_list = target_tree._iter_changes(working_tree,
 
2470
                 backups, merge_modified, basis_tree=None):
 
2471
    if basis_tree is not None:
 
2472
        basis_tree.lock_read()
 
2473
    change_list = target_tree.iter_changes(working_tree,
1551
2474
        specific_files=specific_files, pb=pb)
1552
 
    if target_tree.inventory.root is None:
 
2475
    if target_tree.get_root_id() is None:
1553
2476
        skip_root = True
1554
2477
    else:
1555
2478
        skip_root = False
1556
 
    basis_tree = None
1557
2479
    try:
 
2480
        deferred_files = []
1558
2481
        for id_num, (file_id, path, changed_content, versioned, parent, name,
1559
2482
                kind, executable) in enumerate(change_list):
1560
2483
            if skip_root and file_id[0] is not None and parent[0] is None:
1594
2517
                        # contents
1595
2518
                        mode_id = trans_id
1596
2519
                        trans_id = new_trans_id
1597
 
                if kind[1] == 'directory':
 
2520
                if kind[1] in ('directory', 'tree-reference'):
1598
2521
                    tt.create_directory(trans_id)
 
2522
                    if kind[1] == 'tree-reference':
 
2523
                        revision = target_tree.get_reference_revision(file_id,
 
2524
                                                                      path[1])
 
2525
                        tt.set_tree_reference(revision, trans_id)
1599
2526
                elif kind[1] == 'symlink':
1600
2527
                    tt.create_symlink(target_tree.get_symlink_target(file_id),
1601
2528
                                      trans_id)
1602
2529
                elif kind[1] == 'file':
1603
 
                    tt.create_file(target_tree.get_file_lines(file_id),
1604
 
                                   trans_id, mode_id)
 
2530
                    deferred_files.append((file_id, (trans_id, mode_id)))
1605
2531
                    if basis_tree is None:
1606
2532
                        basis_tree = working_tree.basis_tree()
1607
2533
                        basis_tree.lock_read()
1616
2542
                    # preserve the execute bit when backing up
1617
2543
                    if keep_content and executable[0] == executable[1]:
1618
2544
                        tt.set_executability(executable[1], trans_id)
1619
 
                else:
1620
 
                    assert kind[1] is None
 
2545
                elif kind[1] is not None:
 
2546
                    raise AssertionError(kind[1])
1621
2547
            if versioned == (False, True):
1622
2548
                tt.version_file(file_id, trans_id)
1623
2549
            if versioned == (True, False):
1624
2550
                tt.unversion_file(trans_id)
1625
 
            if (name[1] is not None and 
 
2551
            if (name[1] is not None and
1626
2552
                (name[0] != name[1] or parent[0] != parent[1])):
1627
 
                tt.adjust_path(
1628
 
                    name[1], tt.trans_id_file_id(parent[1]), trans_id)
 
2553
                if name[1] == '' and parent[1] is None:
 
2554
                    parent_trans = ROOT_PARENT
 
2555
                else:
 
2556
                    parent_trans = tt.trans_id_file_id(parent[1])
 
2557
                tt.adjust_path(name[1], parent_trans, trans_id)
1629
2558
            if executable[0] != executable[1] and kind[1] == "file":
1630
2559
                tt.set_executability(executable[1], trans_id)
 
2560
        for (trans_id, mode_id), bytes in target_tree.iter_files_bytes(
 
2561
            deferred_files):
 
2562
            tt.create_file(bytes, trans_id, mode_id)
1631
2563
    finally:
1632
2564
        if basis_tree is not None:
1633
2565
            basis_tree.unlock()
1666
2598
                               conflict[1], conflict[2], ))
1667
2599
        elif c_type == 'duplicate':
1668
2600
            # files that were renamed take precedence
1669
 
            new_name = tt.final_name(conflict[1])+'.moved'
1670
2601
            final_parent = tt.final_parent(conflict[1])
1671
2602
            if tt.path_changed(conflict[1]):
1672
 
                tt.adjust_path(new_name, final_parent, conflict[2])
1673
 
                new_conflicts.add((c_type, 'Moved existing file to', 
1674
 
                                   conflict[2], conflict[1]))
 
2603
                existing_file, new_file = conflict[2], conflict[1]
1675
2604
            else:
1676
 
                tt.adjust_path(new_name, final_parent, conflict[1])
1677
 
                new_conflicts.add((c_type, 'Moved existing file to', 
1678
 
                                  conflict[1], conflict[2]))
 
2605
                existing_file, new_file = conflict[1], conflict[2]
 
2606
            new_name = tt.final_name(existing_file)+'.moved'
 
2607
            tt.adjust_path(new_name, final_parent, existing_file)
 
2608
            new_conflicts.add((c_type, 'Moved existing file to',
 
2609
                               existing_file, new_file))
1679
2610
        elif c_type == 'parent loop':
1680
2611
            # break the loop by undoing one of the ops that caused the loop
1681
2612
            cur = conflict[1]
1684
2615
            new_conflicts.add((c_type, 'Cancelled move', cur,
1685
2616
                               tt.final_parent(cur),))
1686
2617
            tt.adjust_path(tt.final_name(cur), tt.get_tree_parent(cur), cur)
1687
 
            
 
2618
 
1688
2619
        elif c_type == 'missing parent':
1689
2620
            trans_id = conflict[1]
1690
2621
            try:
1691
2622
                tt.cancel_deletion(trans_id)
1692
 
                new_conflicts.add(('deleting parent', 'Not deleting', 
 
2623
                new_conflicts.add(('deleting parent', 'Not deleting',
1693
2624
                                   trans_id))
1694
2625
            except KeyError:
1695
 
                tt.create_directory(trans_id)
1696
 
                new_conflicts.add((c_type, 'Created directory', trans_id))
 
2626
                create = True
1697
2627
                try:
1698
2628
                    tt.final_name(trans_id)
1699
2629
                except NoFinalPath:
1700
 
                    file_id = tt.final_file_id(trans_id)
1701
 
                    entry = path_tree.inventory[file_id]
1702
 
                    parent_trans_id = tt.trans_id_file_id(entry.parent_id)
1703
 
                    tt.adjust_path(entry.name, parent_trans_id, trans_id)
 
2630
                    if path_tree is not None:
 
2631
                        file_id = tt.final_file_id(trans_id)
 
2632
                        if file_id is None:
 
2633
                            file_id = tt.inactive_file_id(trans_id)
 
2634
                        entry = path_tree.inventory[file_id]
 
2635
                        # special-case the other tree root (move its
 
2636
                        # children to current root)
 
2637
                        if entry.parent_id is None:
 
2638
                            create=False
 
2639
                            moved = _reparent_transform_children(
 
2640
                                tt, trans_id, tt.root)
 
2641
                            for child in moved:
 
2642
                                new_conflicts.add((c_type, 'Moved to root',
 
2643
                                                   child))
 
2644
                        else:
 
2645
                            parent_trans_id = tt.trans_id_file_id(
 
2646
                                entry.parent_id)
 
2647
                            tt.adjust_path(entry.name, parent_trans_id,
 
2648
                                           trans_id)
 
2649
                if create:
 
2650
                    tt.create_directory(trans_id)
 
2651
                    new_conflicts.add((c_type, 'Created directory', trans_id))
1704
2652
        elif c_type == 'unversioned parent':
1705
 
            tt.version_file(tt.inactive_file_id(conflict[1]), conflict[1])
 
2653
            file_id = tt.inactive_file_id(conflict[1])
 
2654
            # special-case the other tree root (move its children instead)
 
2655
            if path_tree and file_id in path_tree:
 
2656
                if path_tree.inventory[file_id].parent_id is None:
 
2657
                    continue
 
2658
            tt.version_file(file_id, conflict[1])
1706
2659
            new_conflicts.add((c_type, 'Versioned directory', conflict[1]))
 
2660
        elif c_type == 'non-directory parent':
 
2661
            parent_id = conflict[1]
 
2662
            parent_parent = tt.final_parent(parent_id)
 
2663
            parent_name = tt.final_name(parent_id)
 
2664
            parent_file_id = tt.final_file_id(parent_id)
 
2665
            new_parent_id = tt.new_directory(parent_name + '.new',
 
2666
                parent_parent, parent_file_id)
 
2667
            _reparent_transform_children(tt, parent_id, new_parent_id)
 
2668
            if parent_file_id is not None:
 
2669
                tt.unversion_file(parent_id)
 
2670
            new_conflicts.add((c_type, 'Created directory', new_parent_id))
 
2671
        elif c_type == 'versioning no contents':
 
2672
            tt.cancel_versioning(conflict[1])
1707
2673
    return new_conflicts
1708
2674
 
1709
2675
 
1725
2691
        if len(conflict) == 3:
1726
2692
            yield Conflict.factory(c_type, action=action, path=modified_path,
1727
2693
                                     file_id=modified_id)
1728
 
             
 
2694
 
1729
2695
        else:
1730
2696
            conflicting_path = fp.get_path(conflict[3])
1731
2697
            conflicting_id = tt.final_file_id(conflict[3])
1732
2698
            yield Conflict.factory(c_type, action=action, path=modified_path,
1733
 
                                   file_id=modified_id, 
 
2699
                                   file_id=modified_id,
1734
2700
                                   conflict_path=conflicting_path,
1735
2701
                                   conflict_file_id=conflicting_id)
 
2702
 
 
2703
 
 
2704
class _FileMover(object):
 
2705
    """Moves and deletes files for TreeTransform, tracking operations"""
 
2706
 
 
2707
    def __init__(self):
 
2708
        self.past_renames = []
 
2709
        self.pending_deletions = []
 
2710
 
 
2711
    def rename(self, from_, to):
 
2712
        """Rename a file from one path to another.  Functions like os.rename"""
 
2713
        try:
 
2714
            os.rename(from_, to)
 
2715
        except OSError, e:
 
2716
            if e.errno in (errno.EEXIST, errno.ENOTEMPTY):
 
2717
                raise errors.FileExists(to, str(e))
 
2718
            raise
 
2719
        self.past_renames.append((from_, to))
 
2720
 
 
2721
    def pre_delete(self, from_, to):
 
2722
        """Rename a file out of the way and mark it for deletion.
 
2723
 
 
2724
        Unlike os.unlink, this works equally well for files and directories.
 
2725
        :param from_: The current file path
 
2726
        :param to: A temporary path for the file
 
2727
        """
 
2728
        self.rename(from_, to)
 
2729
        self.pending_deletions.append(to)
 
2730
 
 
2731
    def rollback(self):
 
2732
        """Reverse all renames that have been performed"""
 
2733
        for from_, to in reversed(self.past_renames):
 
2734
            os.rename(to, from_)
 
2735
        # after rollback, don't reuse _FileMover
 
2736
        past_renames = None
 
2737
        pending_deletions = None
 
2738
 
 
2739
    def apply_deletions(self):
 
2740
        """Apply all marked deletions"""
 
2741
        for path in self.pending_deletions:
 
2742
            delete_any(path)
 
2743
        # after apply_deletions, don't reuse _FileMover
 
2744
        past_renames = None
 
2745
        pending_deletions = None