/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: Breezy landing bot
  • Author(s): Jelmer Vernooij
  • Date: 2018-05-20 17:21:41 UTC
  • mfrom: (6968.2.10 archive)
  • Revision ID: breezy.the.bot@gmail.com-20180520172141-fz1rgat80bbdi77j
Refactor the export API.

Merged from https://code.launchpad.net/~jelmer/brz/archive/+merge/346369

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