← Back to branch summary

~bzr/ubuntu/lucid/bzr/beta-ppa

« back to all changes in this revision

Viewing changes to bzrlib/mutabletree.py

  • Committer: Martin Pool
  • Date: 2010-07-02 07:29:40 UTC
  • mfrom: (129.1.7 packaging-karmic)
  • Revision ID: mbp@sourcefrog.net-20100702072940-hpzq5elg8wjve8rh
http://bugs.debian.org/452024
http://bugs.debian.org/464688
http://bugs.debian.org/523595
http://bugs.debian.org/526233
http://bugs.debian.org/537708
http://bugs.debian.org/555336
http://bugs.debian.org/555343
https://launchpad.net/bugs/249452
https://launchpad.net/bugs/385074
* PPA rebuild.
* PPA rebuild for Karmic.
* PPA rebuild for Jaunty.
* PPA rebuild for Hardy.
* From postinst, actually remove the example bash completion scripts.
  (LP: #249452)
* New upstream release.
* New upstream release.
* New upstream release.
* Revert change to Build-depends: Dapper does not have python-central.
  Should be python-support..
* Target ppa..
* Target ppa..
* Target ppa..
* Target ppa..
* New upstream release.
* Switch to dpkg-source 3.0 (quilt) format.
* Bump standards version to 3.8.4.
* Remove embedded copy of python-configobj. Closes: #555336
* Remove embedded copy of python-elementtree. Closes: #555343
* Change section from 'Devel' to 'Vcs'..
* Change section from 'Devel' to 'Vcs'..
* Change section from 'Devel' to 'Vcs'..
* Change section from 'Devel' to 'Vcs'..
* Change section from 'Devel' to 'Vcs'..
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* debian/control: Fix obsolete-relation-form-in-source
  lintian warning. 
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* Split out docs into bzr-doc package.
* New upstream release.
* Added John Francesco Ferlito to Uploaders.
* Fix install path to quick-reference guide
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* Fix FTBFS due to path changes, again.
* Fix FTBFS due to doc paths changing
* New upstream release.
* Fix FTBFS due to path changes, again.
* Fix FTBFS due to doc paths changing
* New upstream release.
* Fix FTBFS due to path changes, again.
* Fix FTBFS due to doc paths changing
* New upstream release.
* Fix FTBFS due to path changes, again, again.
* Fix FTBFS due to path changes, again.
* Fix FTBFS due to path changes.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* Bump standards version to 3.8.3.
* Remove unused patch system.
* New upstream release.
* New upstream release.
* New upstream release.
* Fix copy and paste tab error in .install file
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
 + Fixes compatibility with Python 2.4. Closes: #537708
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream version.
* Bump standards version to 3.8.2.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* Add python-pyrex to build-deps to ensure C extensions are always build.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* Split documentation into bzr-doc package. ((LP: #385074)
* Multiple packaging changes to make us more linitan clean.
* New upstream release.
* Split documentation into bzr-doc package. ((LP: #385074)
* Multiple packaging changes to make us more linitan clean.
* New upstream release.
* Split documentation into bzr-doc package. ((LP: #385074)
* Multiple packaging changes to make us more linitan clean.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* Fix API compatibility version. (Closes: #526233)
* New upstream release.
  + Fixes default format for upgrade command. (Closes: #464688)
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* Add missing dependency on zlib development library. (Closes:
  #523595)
* Add zlib build-depends.
* Add zlib build-depends.
* Add zlib build-depends.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* Move to section vcs.
* Bump standards version to 3.8.1.
* New upstream release.
* Remove temporary patch for missing .c files from distribution
* New upstream release.
* Remove temporary patch for missing .c files from distribution
* New upstream release.
* Remove temporary patch for missing .c files from distribution
* Add temporary patch for missing .c files from distribution
* Add temporary patch for missing .c files from distribution
* Add temporary patch for missing .c files from distribution
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* Recommend ca-certificates. (Closes: #452024)
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* Update watch file. bazaar now uses launchpad to host its sources.
* Remove patch for inventory root revision copy, applied upstream.
* New upstream release.
* New upstream release.
* New upstream release
* Force removal of files installed in error to /etc/bash_completion.d/
  (LP: #249452)
* New upstream release.
* New upstream release
* New upstream release.
* Bump standards version.
* Include patch for inventory root revision copy, required for bzr-svn.
* New upstream release.
* Remove unused lintian overrides.
* Correct the package version not to be native.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* New upstream release.
* Final 1.5 release.
* New upstream release.
* New upstream release.
* New upstream release.
* Add myself as a co-maintainer.
* Add a Dm-Upload-Allowed: yes header.
* New upstream bugfix release.
* New upstream release.
* Final 1.3 release.
* New upstream release.
* First release candidate of the upcoming 1.3 release.
* Rebuild to fix the problem caused by a build with a broken python-central.
* New upstream release.
* Rebuild for dapper PPA.
* Apply Lamont's patches to fix build-dependencies on dapper.
  (See: https://bugs.launchpad.net/bzr/+bug/189915)

Show diffs side-by-side

added added

removed removed

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