/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 bzrlib/mutabletree.py

  • Committer: Joe Julian
  • Date: 2010-01-10 02:25:31 UTC
  • mto: (4634.119.7 2.0)
  • mto: This revision was merged to the branch mainline in revision 4959.
  • Revision ID: joe@julianfamily.org-20100110022531-wqk61rsagz8xsiga
https://launchpad.net/bugs/175839
Added MANIFEST.in to allow bdist_rpm to have all the required include files and tools. bdist_rpm will still fail to build correctly on some distributions due to a disttools bug http://bugs.python.org/issue644744

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/mutabletree.py
1
 
# Copyright (C) 2006-2011 Canonical Ltd
 
1
# Copyright (C) 2006, 2007 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
19
19
See MutableTree for more details.
20
20
"""
21
21
 
22
 
from . import (
 
22
 
 
23
from bzrlib.lazy_import import lazy_import
 
24
lazy_import(globals(), """
 
25
import os
 
26
import re
 
27
 
 
28
from bzrlib import (
 
29
    add,
 
30
    bzrdir,
 
31
    hooks,
 
32
    symbol_versioning,
 
33
    )
 
34
from bzrlib.osutils import dirname
 
35
from bzrlib.revisiontree import RevisionTree
 
36
from bzrlib.trace import mutter, warning
 
37
""")
 
38
 
 
39
from bzrlib import (
23
40
    errors,
24
 
    hooks,
25
41
    osutils,
26
 
    trace,
27
42
    tree,
28
43
    )
29
 
 
30
 
 
31
 
 
32
 
class BadReferenceTarget(errors.InternalBzrError):
33
 
 
34
 
    _fmt = "Can't add reference to %(other_tree)s into %(tree)s." \
35
 
           "%(reason)s"
36
 
 
37
 
    def __init__(self, tree, other_tree, reason):
38
 
        self.tree = tree
39
 
        self.other_tree = other_tree
40
 
        self.reason = reason
 
44
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
45
from bzrlib.osutils import splitpath
 
46
 
 
47
 
 
48
def needs_tree_write_lock(unbound):
 
49
    """Decorate unbound to take out and release a tree_write lock."""
 
50
    def tree_write_locked(self, *args, **kwargs):
 
51
        self.lock_tree_write()
 
52
        try:
 
53
            return unbound(self, *args, **kwargs)
 
54
        finally:
 
55
            self.unlock()
 
56
    tree_write_locked.__doc__ = unbound.__doc__
 
57
    tree_write_locked.__name__ = unbound.__name__
 
58
    return tree_write_locked
41
59
 
42
60
 
43
61
class MutableTree(tree.Tree):
47
65
    context, and will revert if the lock is broken abnormally - but this cannot
48
66
    be guaranteed - depending on the exact implementation of the mutable state.
49
67
 
50
 
    The most common form of Mutable Tree is WorkingTree, see breezy.workingtree.
 
68
    The most common form of Mutable Tree is WorkingTree, see bzrlib.workingtree.
51
69
    For tests we also have MemoryTree which is a MutableTree whose contents are
52
70
    entirely in memory.
53
71
 
55
73
    conformance tests for - rather we are testing MemoryTree specifically, and
56
74
    interface testing implementations of WorkingTree.
57
75
 
58
 
    A mutable tree always has an associated Branch and ControlDir object - the
 
76
    A mutable tree always has an associated Branch and BzrDir object - the
59
77
    branch and bzrdir attributes.
60
78
    """
61
 
 
62
79
    def __init__(self, *args, **kw):
63
80
        super(MutableTree, self).__init__(*args, **kw)
64
81
        # Is this tree on a case-insensitive or case-preserving file-system?
66
83
        # used on media which doesn't differentiate the case of names.
67
84
        self.case_sensitive = True
68
85
 
69
 
    def is_control_filename(self, filename):
70
 
        """True if filename is the name of a control file in this tree.
71
 
 
72
 
        :param filename: A filename within the tree. This is a relative path
73
 
            from the root of this tree.
74
 
 
75
 
        This is true IF and ONLY IF the filename is part of the meta data
76
 
        that bzr controls in this tree. I.E. a random .bzr directory placed
77
 
        on disk will not be a control file for this tree.
78
 
        """
79
 
        raise NotImplementedError(self.is_control_filename)
80
 
 
 
86
    @needs_tree_write_lock
81
87
    def add(self, files, ids=None, kinds=None):
82
88
        """Add paths to the set of versioned paths.
83
89
 
84
90
        Note that the command line normally calls smart_add instead,
85
91
        which can automatically recurse.
86
92
 
87
 
        This adds the files to the tree, so that they will be
 
93
        This adds the files to the inventory, so that they will be
88
94
        recorded by the next commit.
89
95
 
90
96
        :param files: List of paths to add, relative to the base of the tree.
96
102
 
97
103
        TODO: Perhaps callback with the ids and paths as they're added.
98
104
        """
99
 
        if isinstance(files, str):
 
105
        if isinstance(files, basestring):
100
106
            # XXX: Passing a single string is inconsistent and should be
101
107
            # deprecated.
102
 
            if not (ids is None or isinstance(ids, bytes)):
 
108
            if not (ids is None or isinstance(ids, basestring)):
103
109
                raise AssertionError()
104
 
            if not (kinds is None or isinstance(kinds, str)):
 
110
            if not (kinds is None or isinstance(kinds, basestring)):
105
111
                raise AssertionError()
106
112
            files = [files]
107
113
            if ids is not None:
120
126
            kinds = [None] * len(files)
121
127
        elif not len(kinds) == len(files):
122
128
            raise AssertionError()
123
 
        with self.lock_tree_write():
124
 
            for f in files:
125
 
                # generic constraint checks:
126
 
                if self.is_control_filename(f):
127
 
                    raise errors.ForbiddenControlFileError(filename=f)
128
 
                fp = osutils.splitpath(f)
129
 
            # fill out file kinds for all files [not needed when we stop
130
 
            # caring about the instantaneous file kind within a uncommmitted tree
131
 
            #
132
 
            self._gather_kinds(files, kinds)
133
 
            self._add(files, ids, kinds)
 
129
        for f in files:
 
130
            # generic constraint checks:
 
131
            if self.is_control_filename(f):
 
132
                raise errors.ForbiddenControlFileError(filename=f)
 
133
            fp = splitpath(f)
 
134
        # fill out file kinds for all files [not needed when we stop
 
135
        # caring about the instantaneous file kind within a uncommmitted tree
 
136
        #
 
137
        self._gather_kinds(files, kinds)
 
138
        self._add(files, ids, kinds)
134
139
 
135
140
    def add_reference(self, sub_tree):
136
 
        """Add a TreeReference to the tree, pointing at sub_tree.
137
 
 
138
 
        :param sub_tree: subtree to add.
139
 
        """
 
141
        """Add a TreeReference to the tree, pointing at sub_tree"""
140
142
        raise errors.UnsupportedOperation(self.add_reference, self)
141
143
 
 
144
    def _add_reference(self, sub_tree):
 
145
        """Standard add_reference implementation, for use by subclasses"""
 
146
        try:
 
147
            sub_tree_path = self.relpath(sub_tree.basedir)
 
148
        except errors.PathNotChild:
 
149
            raise errors.BadReferenceTarget(self, sub_tree,
 
150
                                            'Target not inside tree.')
 
151
        sub_tree_id = sub_tree.get_root_id()
 
152
        if sub_tree_id == self.get_root_id():
 
153
            raise errors.BadReferenceTarget(self, sub_tree,
 
154
                                     'Trees have the same root id.')
 
155
        if sub_tree_id in self.inventory:
 
156
            raise errors.BadReferenceTarget(self, sub_tree,
 
157
                                            'Root id already present in tree')
 
158
        self._add([sub_tree_path], [sub_tree_id], ['tree-reference'])
 
159
 
142
160
    def _add(self, files, ids, kinds):
143
161
        """Helper function for add - updates the inventory.
144
162
 
149
167
        """
150
168
        raise NotImplementedError(self._add)
151
169
 
152
 
    def commit(self, message=None, revprops=None, *args, **kwargs):
 
170
    @needs_tree_write_lock
 
171
    def apply_inventory_delta(self, changes):
 
172
        """Apply changes to the inventory as an atomic operation.
 
173
 
 
174
        :param changes: An inventory delta to apply to the working tree's
 
175
            inventory.
 
176
        :return None:
 
177
        :seealso Inventory.apply_delta: For details on the changes parameter.
 
178
        """
 
179
        self.flush()
 
180
        inv = self.inventory
 
181
        inv.apply_delta(changes)
 
182
        self._write_inventory(inv)
 
183
 
 
184
    @needs_write_lock
 
185
    def commit(self, message=None, revprops=None, *args,
 
186
               **kwargs):
153
187
        # avoid circular imports
154
 
        from breezy import commit
155
 
        possible_master_transports = []
156
 
        with self.lock_write():
157
 
            revprops = commit.Commit.update_revprops(
158
 
                revprops,
159
 
                self.branch,
160
 
                kwargs.pop('authors', None),
 
188
        from bzrlib import commit
 
189
        if revprops is None:
 
190
            revprops = {}
 
191
        possible_master_transports=[]
 
192
        if not 'branch-nick' in revprops:
 
193
            revprops['branch-nick'] = self.branch._get_nick(
161
194
                kwargs.get('local', False),
162
195
                possible_master_transports)
163
 
            # args for wt.commit start at message from the Commit.commit method,
164
 
            args = (message, ) + args
165
 
            for hook in MutableTree.hooks['start_commit']:
166
 
                hook(self)
167
 
            committed_id = commit.Commit().commit(working_tree=self,
168
 
                                                  revprops=revprops,
169
 
                                                  possible_master_transports=possible_master_transports,
170
 
                                                  *args, **kwargs)
171
 
            post_hook_params = PostCommitHookParams(self)
172
 
            for hook in MutableTree.hooks['post_commit']:
173
 
                hook(post_hook_params)
174
 
            return committed_id
 
196
        authors = kwargs.pop('authors', None)
 
197
        author = kwargs.pop('author', None)
 
198
        if authors is not None:
 
199
            if author is not None:
 
200
                raise AssertionError('Specifying both author and authors '
 
201
                        'is not allowed. Specify just authors instead')
 
202
            if 'author' in revprops or 'authors' in revprops:
 
203
                # XXX: maybe we should just accept one of them?
 
204
                raise AssertionError('author property given twice')
 
205
            if authors:
 
206
                for individual in authors:
 
207
                    if '\n' in individual:
 
208
                        raise AssertionError('\\n is not a valid character '
 
209
                                'in an author identity')
 
210
                revprops['authors'] = '\n'.join(authors)
 
211
        if author is not None:
 
212
            symbol_versioning.warn('The parameter author was deprecated'
 
213
                   ' in version 1.13. Use authors instead',
 
214
                   DeprecationWarning)
 
215
            if 'author' in revprops or 'authors' in revprops:
 
216
                # XXX: maybe we should just accept one of them?
 
217
                raise AssertionError('author property given twice')
 
218
            if '\n' in author:
 
219
                raise AssertionError('\\n is not a valid character '
 
220
                        'in an author identity')
 
221
            revprops['authors'] = author
 
222
        # args for wt.commit start at message from the Commit.commit method,
 
223
        args = (message, ) + args
 
224
        for hook in MutableTree.hooks['start_commit']:
 
225
            hook(self)
 
226
        committed_id = commit.Commit().commit(working_tree=self,
 
227
            revprops=revprops,
 
228
            possible_master_transports=possible_master_transports,
 
229
            *args, **kwargs)
 
230
        post_hook_params = PostCommitHookParams(self)
 
231
        for hook in MutableTree.hooks['post_commit']:
 
232
            hook(post_hook_params)
 
233
        return committed_id
175
234
 
176
235
    def _gather_kinds(self, files, kinds):
177
236
        """Helper function for add - sets the entries of kinds."""
178
237
        raise NotImplementedError(self._gather_kinds)
179
238
 
180
 
    def has_changes(self, _from_tree=None):
181
 
        """Quickly check that the tree contains at least one commitable change.
182
 
 
183
 
        :param _from_tree: tree to compare against to find changes (default to
184
 
            the basis tree and is intended to be used by tests).
 
239
    @needs_read_lock
 
240
    def has_changes(self, from_tree):
 
241
        """Quickly check that the tree contains at least one change.
185
242
 
186
243
        :return: True if a change is found. False otherwise
187
244
        """
188
 
        with self.lock_read():
189
 
            # Check pending merges
190
 
            if len(self.get_parent_ids()) > 1:
191
 
                return True
192
 
            if _from_tree is None:
193
 
                _from_tree = self.basis_tree()
194
 
            changes = self.iter_changes(_from_tree)
195
 
            if self.supports_symlinks():
196
 
                # Fast path for has_changes.
197
 
                try:
198
 
                    change = next(changes)
199
 
                    # Exclude root (talk about black magic... --vila 20090629)
200
 
                    if change.parent_id == (None, None):
201
 
                        change = next(changes)
202
 
                    return True
203
 
                except StopIteration:
204
 
                    # No changes
205
 
                    return False
206
 
            else:
207
 
                # Slow path for has_changes.
208
 
                # Handle platforms that do not support symlinks in the
209
 
                # conditional below. This is slower than the try/except
210
 
                # approach below that but we don't have a choice as we
211
 
                # need to be sure that all symlinks are removed from the
212
 
                # entire changeset. This is because in platforms that
213
 
                # do not support symlinks, they show up as None in the
214
 
                # working copy as compared to the repository.
215
 
                # Also, exclude root as mention in the above fast path.
216
 
                changes = filter(
217
 
                    lambda c: c[6][0] != 'symlink' and c[4] != (None, None),
218
 
                    changes)
219
 
                try:
220
 
                    next(iter(changes))
221
 
                except StopIteration:
222
 
                    return False
223
 
                return True
224
 
 
225
 
    def check_changed_or_out_of_date(self, strict, opt_name,
226
 
                                     more_error, more_warning):
227
 
        """Check the tree for uncommitted changes and branch synchronization.
228
 
 
229
 
        If strict is None and not set in the config files, a warning is issued.
230
 
        If strict is True, an error is raised.
231
 
        If strict is False, no checks are done and no warning is issued.
232
 
 
233
 
        :param strict: True, False or None, searched in branch config if None.
234
 
 
235
 
        :param opt_name: strict option name to search in config file.
236
 
 
237
 
        :param more_error: Details about how to avoid the check.
238
 
 
239
 
        :param more_warning: Details about what is happening.
240
 
        """
241
 
        with self.lock_read():
242
 
            if strict is None:
243
 
                strict = self.branch.get_config_stack().get(opt_name)
244
 
            if strict is not False:
245
 
                err_class = None
246
 
                if (self.has_changes()):
247
 
                    err_class = errors.UncommittedChanges
248
 
                elif self.last_revision() != self.branch.last_revision():
249
 
                    # The tree has lost sync with its branch, there is little
250
 
                    # chance that the user is aware of it but he can still
251
 
                    # force the action with --no-strict
252
 
                    err_class = errors.OutOfDateTree
253
 
                if err_class is not None:
254
 
                    if strict is None:
255
 
                        err = err_class(self, more=more_warning)
256
 
                        # We don't want to interrupt the user if he expressed
257
 
                        # no preference about strict.
258
 
                        trace.warning('%s', err._format())
259
 
                    else:
260
 
                        err = err_class(self, more=more_error)
261
 
                        raise err
262
 
 
 
245
        changes = self.iter_changes(from_tree)
 
246
        try:
 
247
            change = changes.next()
 
248
            # Exclude root (talk about black magic... --vila 20090629)
 
249
            if change[4] == (None, None):
 
250
                change = changes.next()
 
251
            return True
 
252
        except StopIteration:
 
253
            # No changes
 
254
            return False
 
255
 
 
256
    @needs_read_lock
263
257
    def last_revision(self):
264
258
        """Return the revision id of the last commit performed in this tree.
265
259
 
295
289
        """
296
290
        raise NotImplementedError(self.lock_write)
297
291
 
 
292
    @needs_write_lock
298
293
    def mkdir(self, path, file_id=None):
299
294
        """Create a directory in the tree. if file_id is None, one is assigned.
300
295
 
304
299
        """
305
300
        raise NotImplementedError(self.mkdir)
306
301
 
307
 
    def _observed_sha1(self, path, sha_and_stat):
 
302
    def _observed_sha1(self, file_id, path, (sha1, stat_value)):
308
303
        """Tell the tree we have observed a paths sha1.
309
304
 
310
305
        The intent of this function is to allow trees that have a hashcache to
314
309
 
315
310
        The default implementation does nothing.
316
311
 
 
312
        :param file_id: The file id
317
313
        :param path: The file path
318
 
        :param sha_and_stat: The sha 1 and stat result observed.
 
314
        :param sha1: The sha 1 that was observed.
 
315
        :param stat_value: A stat result for the file the sha1 was read from.
319
316
        :return: None
320
317
        """
321
318
 
322
 
    def put_file_bytes_non_atomic(self, path, bytes):
 
319
    def _fix_case_of_inventory_path(self, path):
 
320
        """If our tree isn't case sensitive, return the canonical path"""
 
321
        if not self.case_sensitive:
 
322
            path = self.get_canonical_inventory_path(path)
 
323
        return path
 
324
 
 
325
    @needs_write_lock
 
326
    def put_file_bytes_non_atomic(self, file_id, bytes):
323
327
        """Update the content of a file in the tree.
324
328
 
325
329
        Note that the file is written in-place rather than being
347
351
        """
348
352
        raise NotImplementedError(self.set_parent_trees)
349
353
 
 
354
    @needs_tree_write_lock
350
355
    def smart_add(self, file_list, recurse=True, action=None, save=True):
351
356
        """Version file_list, optionally recursing into directories.
352
357
 
353
358
        This is designed more towards DWIM for humans than API clarity.
354
359
        For the specific behaviour see the help for cmd_add().
355
360
 
356
 
        :param file_list: List of zero or more paths.  *NB: these are
357
 
            interpreted relative to the process cwd, not relative to the
358
 
            tree.*  (Add and most other tree methods use tree-relative
359
 
            paths.)
360
 
        :param action: A reporter to be called with the working tree, parent_ie,
 
361
        :param action: A reporter to be called with the inventory, parent_ie,
361
362
            path and kind of the path being added. It may return a file_id if
362
363
            a specific one should be used.
363
 
        :param save: Save the changes after completing the adds. If False
 
364
        :param save: Save the inventory after completing the adds. If False
364
365
            this provides dry-run functionality by doing the add and not saving
365
 
            the changes.
 
366
            the inventory.
366
367
        :return: A tuple - files_added, ignored_files. files_added is the count
367
368
            of added files, and ignored_files is a dict mapping files that were
368
369
            ignored to the rule that caused them to be ignored.
369
370
        """
370
 
        raise NotImplementedError(self.smart_add)
371
 
 
372
 
    def rename_one(self, from_rel, to_rel, after=False):
373
 
        """Rename one file.
374
 
 
375
 
        This can change the directory or the filename or both.
376
 
 
377
 
        rename_one has several 'modes' to work. First, it can rename a physical
378
 
        file and change the file_id. That is the normal mode. Second, it can
379
 
        only change the file_id without touching any physical file.
380
 
 
381
 
        rename_one uses the second mode if 'after == True' and 'to_rel' is
382
 
        either not versioned or newly added, and present in the working tree.
383
 
 
384
 
        rename_one uses the second mode if 'after == False' and 'from_rel' is
385
 
        versioned but no longer in the working tree, and 'to_rel' is not
386
 
        versioned but present in the working tree.
387
 
 
388
 
        rename_one uses the first mode if 'after == False' and 'from_rel' is
389
 
        versioned and present in the working tree, and 'to_rel' is not
390
 
        versioned and not present in the working tree.
391
 
 
392
 
        Everything else results in an error.
393
 
        """
394
 
        raise NotImplementedError(self.rename_one)
395
 
 
396
 
    def copy_one(self, from_rel, to_rel):
397
 
        """Copy one file or directory.
398
 
 
399
 
        This can change the directory or the filename or both.
400
 
 
401
 
        """
402
 
        raise NotImplementedError(self.copy_one)
403
 
 
404
 
    def transform(self, pb=None):
405
 
        """Return a transform object for use with this tree."""
406
 
        raise NotImplementedError(self.transform)
 
371
        # not in an inner loop; and we want to remove direct use of this,
 
372
        # so here as a reminder for now. RBC 20070703
 
373
        from bzrlib.inventory import InventoryEntry
 
374
        if action is None:
 
375
            action = add.AddAction()
 
376
 
 
377
        if not file_list:
 
378
            # no paths supplied: add the entire tree.
 
379
            file_list = [u'.']
 
380
        # mutter("smart add of %r")
 
381
        inv = self.inventory
 
382
        added = []
 
383
        ignored = {}
 
384
        dirs_to_add = []
 
385
        user_dirs = set()
 
386
 
 
387
        # validate user file paths and convert all paths to tree
 
388
        # relative : it's cheaper to make a tree relative path an abspath
 
389
        # than to convert an abspath to tree relative, and it's cheaper to
 
390
        # perform the canonicalization in bulk.
 
391
        for filepath in osutils.canonical_relpaths(self.basedir, file_list):
 
392
            rf = _FastPath(filepath)
 
393
            # validate user parameters. Our recursive code avoids adding new files
 
394
            # that need such validation
 
395
            if self.is_control_filename(rf.raw_path):
 
396
                raise errors.ForbiddenControlFileError(filename=rf.raw_path)
 
397
 
 
398
            abspath = self.abspath(rf.raw_path)
 
399
            kind = osutils.file_kind(abspath)
 
400
            if kind == 'directory':
 
401
                # schedule the dir for scanning
 
402
                user_dirs.add(rf)
 
403
            else:
 
404
                if not InventoryEntry.versionable_kind(kind):
 
405
                    raise errors.BadFileKindError(filename=abspath, kind=kind)
 
406
            # ensure the named path is added, so that ignore rules in the later directory
 
407
            # walk dont skip it.
 
408
            # we dont have a parent ie known yet.: use the relatively slower inventory
 
409
            # probing method
 
410
            versioned = inv.has_filename(rf.raw_path)
 
411
            if versioned:
 
412
                continue
 
413
            added.extend(_add_one_and_parent(self, inv, None, rf, kind, action))
 
414
 
 
415
        if not recurse:
 
416
            # no need to walk any directories at all.
 
417
            if len(added) > 0 and save:
 
418
                self._write_inventory(inv)
 
419
            return added, ignored
 
420
 
 
421
        # only walk the minimal parents needed: we have user_dirs to override
 
422
        # ignores.
 
423
        prev_dir = None
 
424
 
 
425
        is_inside = osutils.is_inside_or_parent_of_any
 
426
        for path in sorted(user_dirs):
 
427
            if (prev_dir is None or not is_inside([prev_dir], path.raw_path)):
 
428
                dirs_to_add.append((path, None))
 
429
            prev_dir = path.raw_path
 
430
 
 
431
        illegalpath_re = re.compile(r'[\r\n]')
 
432
        # dirs_to_add is initialised to a list of directories, but as we scan
 
433
        # directories we append files to it.
 
434
        # XXX: We should determine kind of files when we scan them rather than
 
435
        # adding to this list. RBC 20070703
 
436
        for directory, parent_ie in dirs_to_add:
 
437
            # directory is tree-relative
 
438
            abspath = self.abspath(directory.raw_path)
 
439
 
 
440
            # get the contents of this directory.
 
441
 
 
442
            # find the kind of the path being added.
 
443
            kind = osutils.file_kind(abspath)
 
444
 
 
445
            if not InventoryEntry.versionable_kind(kind):
 
446
                warning("skipping %s (can't add file of kind '%s')", abspath, kind)
 
447
                continue
 
448
            if illegalpath_re.search(directory.raw_path):
 
449
                warning("skipping %r (contains \\n or \\r)" % abspath)
 
450
                continue
 
451
 
 
452
            if parent_ie is not None:
 
453
                versioned = directory.base_path in parent_ie.children
 
454
            else:
 
455
                # without the parent ie, use the relatively slower inventory
 
456
                # probing method
 
457
                versioned = inv.has_filename(
 
458
                        self._fix_case_of_inventory_path(directory.raw_path))
 
459
 
 
460
            if kind == 'directory':
 
461
                try:
 
462
                    sub_branch = bzrdir.BzrDir.open(abspath)
 
463
                    sub_tree = True
 
464
                except errors.NotBranchError:
 
465
                    sub_tree = False
 
466
                except errors.UnsupportedFormatError:
 
467
                    sub_tree = True
 
468
            else:
 
469
                sub_tree = False
 
470
 
 
471
            if directory.raw_path == '':
 
472
                # mutter("tree root doesn't need to be added")
 
473
                sub_tree = False
 
474
            elif versioned:
 
475
                pass
 
476
                # mutter("%r is already versioned", abspath)
 
477
            elif sub_tree:
 
478
                # XXX: This is wrong; people *might* reasonably be trying to add
 
479
                # subtrees as subtrees.  This should probably only be done in formats
 
480
                # which can represent subtrees, and even then perhaps only when
 
481
                # the user asked to add subtrees.  At the moment you can add them
 
482
                # specially through 'join --reference', which is perhaps
 
483
                # reasonable: adding a new reference is a special operation and
 
484
                # can have a special behaviour.  mbp 20070306
 
485
                mutter("%r is a nested bzr tree", abspath)
 
486
            else:
 
487
                _add_one(self, inv, parent_ie, directory, kind, action)
 
488
                added.append(directory.raw_path)
 
489
 
 
490
            if kind == 'directory' and not sub_tree:
 
491
                if parent_ie is not None:
 
492
                    # must be present:
 
493
                    this_ie = parent_ie.children[directory.base_path]
 
494
                else:
 
495
                    # without the parent ie, use the relatively slower inventory
 
496
                    # probing method
 
497
                    this_id = inv.path2id(
 
498
                            self._fix_case_of_inventory_path(directory.raw_path))
 
499
                    if this_id is None:
 
500
                        this_ie = None
 
501
                    else:
 
502
                        this_ie = inv[this_id]
 
503
 
 
504
                for subf in sorted(os.listdir(abspath)):
 
505
                    # here we could use TreeDirectory rather than
 
506
                    # string concatenation.
 
507
                    subp = osutils.pathjoin(directory.raw_path, subf)
 
508
                    # TODO: is_control_filename is very slow. Make it faster.
 
509
                    # TreeDirectory.is_control_filename could also make this
 
510
                    # faster - its impossible for a non root dir to have a
 
511
                    # control file.
 
512
                    if self.is_control_filename(subp):
 
513
                        mutter("skip control directory %r", subp)
 
514
                    elif subf in this_ie.children:
 
515
                        # recurse into this already versioned subdir.
 
516
                        dirs_to_add.append((_FastPath(subp, subf), this_ie))
 
517
                    else:
 
518
                        # user selection overrides ignoes
 
519
                        # ignore while selecting files - if we globbed in the
 
520
                        # outer loop we would ignore user files.
 
521
                        ignore_glob = self.is_ignored(subp)
 
522
                        if ignore_glob is not None:
 
523
                            # mutter("skip ignored sub-file %r", subp)
 
524
                            ignored.setdefault(ignore_glob, []).append(subp)
 
525
                        else:
 
526
                            #mutter("queue to add sub-file %r", subp)
 
527
                            dirs_to_add.append((_FastPath(subp, subf), this_ie))
 
528
 
 
529
        if len(added) > 0:
 
530
            if save:
 
531
                self._write_inventory(inv)
 
532
            else:
 
533
                self.read_working_inventory()
 
534
        return added, ignored
 
535
 
 
536
    def update_basis_by_delta(self, new_revid, delta):
 
537
        """Update the parents of this tree after a commit.
 
538
 
 
539
        This gives the tree one parent, with revision id new_revid. The
 
540
        inventory delta is applied to the current basis tree to generate the
 
541
        inventory for the parent new_revid, and all other parent trees are
 
542
        discarded.
 
543
 
 
544
        All the changes in the delta should be changes synchronising the basis
 
545
        tree with some or all of the working tree, with a change to a directory
 
546
        requiring that its contents have been recursively included. That is,
 
547
        this is not a general purpose tree modification routine, but a helper
 
548
        for commit which is not required to handle situations that do not arise
 
549
        outside of commit.
 
550
 
 
551
        See the inventory developers documentation for the theory behind
 
552
        inventory deltas.
 
553
 
 
554
        :param new_revid: The new revision id for the trees parent.
 
555
        :param delta: An inventory delta (see apply_inventory_delta) describing
 
556
            the changes from the current left most parent revision to new_revid.
 
557
        """
 
558
        # if the tree is updated by a pull to the branch, as happens in
 
559
        # WorkingTree2, when there was no separation between branch and tree,
 
560
        # then just clear merges, efficiency is not a concern for now as this
 
561
        # is legacy environments only, and they are slow regardless.
 
562
        if self.last_revision() == new_revid:
 
563
            self.set_parent_ids([new_revid])
 
564
            return
 
565
        # generic implementation based on Inventory manipulation. See
 
566
        # WorkingTree classes for optimised versions for specific format trees.
 
567
        basis = self.basis_tree()
 
568
        basis.lock_read()
 
569
        # TODO: Consider re-evaluating the need for this with CHKInventory
 
570
        # we don't strictly need to mutate an inventory for this
 
571
        # it only makes sense when apply_delta is cheaper than get_inventory()
 
572
        inventory = basis.inventory._get_mutable_inventory()
 
573
        basis.unlock()
 
574
        inventory.apply_delta(delta)
 
575
        rev_tree = RevisionTree(self.branch.repository, inventory, new_revid)
 
576
        self.set_parent_trees([(new_revid, rev_tree)])
407
577
 
408
578
 
409
579
class MutableTreeHooks(hooks.Hooks):
415
585
        """Create the default hooks.
416
586
 
417
587
        """
418
 
        hooks.Hooks.__init__(self, "breezy.mutabletree", "MutableTree.hooks")
419
 
        self.add_hook('start_commit',
420
 
                      "Called before a commit is performed on a tree. The start commit "
421
 
                      "hook is able to change the tree before the commit takes place. "
422
 
                      "start_commit is called with the breezy.mutabletree.MutableTree "
423
 
                      "that the commit is being performed on.", (1, 4))
424
 
        self.add_hook('post_commit',
425
 
                      "Called after a commit is performed on a tree. The hook is "
426
 
                      "called with a breezy.mutabletree.PostCommitHookParams object. "
427
 
                      "The mutable tree the commit was performed on is available via "
428
 
                      "the mutable_tree attribute of that object.", (2, 0))
429
 
        self.add_hook('pre_transform',
430
 
                      "Called before a tree transform on this tree. The hook is called "
431
 
                      "with the tree that is being transformed and the transform.",
432
 
                      (2, 5))
433
 
        self.add_hook('post_build_tree',
434
 
                      "Called after a completely new tree is built. The hook is "
435
 
                      "called with the tree as its only argument.", (2, 5))
436
 
        self.add_hook('post_transform',
437
 
                      "Called after a tree transform has been performed on a tree. "
438
 
                      "The hook is called with the tree that is being transformed and "
439
 
                      "the transform.",
440
 
                      (2, 5))
 
588
        hooks.Hooks.__init__(self)
 
589
        self.create_hook(hooks.HookPoint('start_commit',
 
590
            "Called before a commit is performed on a tree. The start commit "
 
591
            "hook is able to change the tree before the commit takes place. "
 
592
            "start_commit is called with the bzrlib.mutabletree.MutableTree "
 
593
            "that the commit is being performed on.", (1, 4), None))
 
594
        self.create_hook(hooks.HookPoint('post_commit',
 
595
            "Called after a commit is performed on a tree. The hook is "
 
596
            "called with a bzrlib.mutabletree.PostCommitHookParams object. "
 
597
            "The mutable tree the commit was performed on is available via "
 
598
            "the mutable_tree attribute of that object.", (2, 0), None))
441
599
 
442
600
 
443
601
# install the default hooks into the MutableTree class.
455
613
    def __init__(self, mutable_tree):
456
614
        """Create the parameters for the post_commit hook."""
457
615
        self.mutable_tree = mutable_tree
 
616
 
 
617
 
 
618
class _FastPath(object):
 
619
    """A path object with fast accessors for things like basename."""
 
620
 
 
621
    __slots__ = ['raw_path', 'base_path']
 
622
 
 
623
    def __init__(self, path, base_path=None):
 
624
        """Construct a FastPath from path."""
 
625
        if base_path is None:
 
626
            self.base_path = osutils.basename(path)
 
627
        else:
 
628
            self.base_path = base_path
 
629
        self.raw_path = path
 
630
 
 
631
    def __cmp__(self, other):
 
632
        return cmp(self.raw_path, other.raw_path)
 
633
 
 
634
    def __hash__(self):
 
635
        return hash(self.raw_path)
 
636
 
 
637
 
 
638
def _add_one_and_parent(tree, inv, parent_ie, path, kind, action):
 
639
    """Add a new entry to the inventory and automatically add unversioned parents.
 
640
 
 
641
    :param inv: Inventory which will receive the new entry.
 
642
    :param parent_ie: Parent inventory entry if known, or None.  If
 
643
        None, the parent is looked up by name and used if present, otherwise it
 
644
        is recursively added.
 
645
    :param kind: Kind of new entry (file, directory, etc)
 
646
    :param action: callback(inv, parent_ie, path, kind); return ignored.
 
647
    :return: A list of paths which have been added.
 
648
    """
 
649
    # Nothing to do if path is already versioned.
 
650
    # This is safe from infinite recursion because the tree root is
 
651
    # always versioned.
 
652
    if parent_ie is not None:
 
653
        # we have a parent ie already
 
654
        added = []
 
655
    else:
 
656
        # slower but does not need parent_ie
 
657
        if inv.has_filename(tree._fix_case_of_inventory_path(path.raw_path)):
 
658
            return []
 
659
        # its really not there : add the parent
 
660
        # note that the dirname use leads to some extra str copying etc but as
 
661
        # there are a limited number of dirs we can be nested under, it should
 
662
        # generally find it very fast and not recurse after that.
 
663
        added = _add_one_and_parent(tree, inv, None,
 
664
            _FastPath(dirname(path.raw_path)), 'directory', action)
 
665
        parent_id = inv.path2id(dirname(path.raw_path))
 
666
        parent_ie = inv[parent_id]
 
667
    _add_one(tree, inv, parent_ie, path, kind, action)
 
668
    return added + [path.raw_path]
 
669
 
 
670
 
 
671
def _add_one(tree, inv, parent_ie, path, kind, file_id_callback):
 
672
    """Add a new entry to the inventory.
 
673
 
 
674
    :param inv: Inventory which will receive the new entry.
 
675
    :param parent_ie: Parent inventory entry.
 
676
    :param kind: Kind of new entry (file, directory, etc)
 
677
    :param file_id_callback: callback(inv, parent_ie, path, kind); return a
 
678
        file_id or None to generate a new file id
 
679
    :returns: None
 
680
    """
 
681
    file_id = file_id_callback(inv, parent_ie, path, kind)
 
682
    entry = inv.make_entry(kind, path.base_path, parent_ie.file_id,
 
683
        file_id=file_id)
 
684
    inv.add(entry)