← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transform.py

  • Committer: Martin Pool
  • Date: 2010-01-29 10:36:23 UTC
  • mto: This revision was merged to the branch mainline in revision 4992.
  • Revision ID: mbp@sourcefrog.net-20100129103623-hywka5hymo5z13jw
Change url to canonical.com or wiki, plus some doc improvements in passing

Show diffs side-by-side

added added

removed removed

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