/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to breezy/transform.py

  • Committer: Jelmer Vernooij
  • Date: 2017-12-03 15:14:22 UTC
  • mfrom: (6829.1.1 no-branch-nick)
  • Revision ID: jelmer@jelmer.uk-20171203151422-54pwtld2ae5cx11l
Merge lp:~jelmer/brz/no-branch-nick.

Show diffs side-by-side

added added

removed removed

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