~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/mutabletree.py

  • Committer: Aaron Bentley
  • Date: 2007-06-11 14:59:52 UTC
  • mto: (2520.5.2 bzr.mpbundle)
  • mto: This revision was merged to the branch mainline in revision 2631.
  • Revision ID: abentley@panoramicfeedback.com-20070611145952-cwt4480gphdhen6l
Get installation started

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""MutableTree object.
18
18
 
19
19
See MutableTree for more details.
20
20
"""
21
21
 
22
 
from __future__ import absolute_import
23
 
 
24
 
from bzrlib.lazy_import import lazy_import
25
 
lazy_import(globals(), """
26
 
import operator
27
 
import os
28
 
import re
29
22
 
30
23
from bzrlib import (
31
 
    add,
32
 
    controldir,
33
24
    errors,
34
 
    hooks,
35
 
    inventory as _mod_inventory,
36
25
    osutils,
37
 
    revisiontree,
38
 
    trace,
39
 
    transport as _mod_transport,
40
26
    tree,
41
27
    )
42
 
""")
43
 
 
44
28
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
29
from bzrlib.osutils import splitpath
 
30
from bzrlib.symbol_versioning import DEPRECATED_PARAMETER
45
31
 
46
32
 
47
33
def needs_tree_write_lock(unbound):
69
55
    entirely in memory.
70
56
 
71
57
    For now, we are not treating MutableTree as an interface to provide
72
 
    conformance tests for - rather we are testing MemoryTree specifically, and
 
58
    conformance tests for - rather we are testing MemoryTree specifically, and 
73
59
    interface testing implementations of WorkingTree.
74
60
 
75
 
    A mutable tree always has an associated Branch and ControlDir object - the
 
61
    A mutable tree always has an associated Branch and BzrDir object - the
76
62
    branch and bzrdir attributes.
77
63
    """
78
 
    def __init__(self, *args, **kw):
79
 
        super(MutableTree, self).__init__(*args, **kw)
80
 
        # Is this tree on a case-insensitive or case-preserving file-system?
81
 
        # Sub-classes may initialize to False if they detect they are being
82
 
        # used on media which doesn't differentiate the case of names.
83
 
        self.case_sensitive = True
84
 
 
85
 
    def is_control_filename(self, filename):
86
 
        """True if filename is the name of a control file in this tree.
87
 
 
88
 
        :param filename: A filename within the tree. This is a relative path
89
 
            from the root of this tree.
90
 
 
91
 
        This is true IF and ONLY IF the filename is part of the meta data
92
 
        that bzr controls in this tree. I.E. a random .bzr directory placed
93
 
        on disk will not be a control file for this tree.
94
 
        """
95
 
        raise NotImplementedError(self.is_control_filename)
96
64
 
97
65
    @needs_tree_write_lock
98
66
    def add(self, files, ids=None, kinds=None):
114
82
        TODO: Perhaps callback with the ids and paths as they're added.
115
83
        """
116
84
        if isinstance(files, basestring):
117
 
            # XXX: Passing a single string is inconsistent and should be
118
 
            # deprecated.
119
 
            if not (ids is None or isinstance(ids, basestring)):
120
 
                raise AssertionError()
121
 
            if not (kinds is None or isinstance(kinds, basestring)):
122
 
                raise AssertionError()
 
85
            assert(ids is None or isinstance(ids, basestring))
 
86
            assert(kinds is None or isinstance(kinds, basestring))
123
87
            files = [files]
124
88
            if ids is not None:
125
89
                ids = [ids]
131
95
        if ids is None:
132
96
            ids = [None] * len(files)
133
97
        else:
134
 
            if not (len(ids) == len(files)):
135
 
                raise AssertionError()
 
98
            assert(len(ids) == len(files))
 
99
            ids = [osutils.safe_file_id(file_id) for file_id in ids]
 
100
 
136
101
        if kinds is None:
137
102
            kinds = [None] * len(files)
138
 
        elif not len(kinds) == len(files):
139
 
            raise AssertionError()
 
103
        else:
 
104
            assert(len(kinds) == len(files))
140
105
        for f in files:
141
106
            # generic constraint checks:
142
107
            if self.is_control_filename(f):
143
108
                raise errors.ForbiddenControlFileError(filename=f)
144
 
            fp = osutils.splitpath(f)
145
 
        # fill out file kinds for all files [not needed when we stop
 
109
            fp = splitpath(f)
 
110
        # fill out file kinds for all files [not needed when we stop 
146
111
        # caring about the instantaneous file kind within a uncommmitted tree
147
112
        #
148
113
        self._gather_kinds(files, kinds)
163
128
        if sub_tree_id == self.get_root_id():
164
129
            raise errors.BadReferenceTarget(self, sub_tree,
165
130
                                     'Trees have the same root id.')
166
 
        if self.has_id(sub_tree_id):
 
131
        if sub_tree_id in self.inventory:
167
132
            raise errors.BadReferenceTarget(self, sub_tree,
168
133
                                            'Root id already present in tree')
169
134
        self._add([sub_tree_path], [sub_tree_id], ['tree-reference'])
178
143
        """
179
144
        raise NotImplementedError(self._add)
180
145
 
 
146
    @needs_tree_write_lock
181
147
    def apply_inventory_delta(self, changes):
182
148
        """Apply changes to the inventory as an atomic operation.
183
149
 
184
 
        :param changes: An inventory delta to apply to the working tree's
185
 
            inventory.
186
 
        :return None:
187
 
        :seealso Inventory.apply_delta: For details on the changes parameter.
 
150
        The argument is a set of changes to apply.  It must describe a
 
151
        valid result, but the order is not important.  Specifically,
 
152
        intermediate stages *may* be invalid, such as when two files
 
153
        swap names.
 
154
 
 
155
        The changes should be structured as a list of tuples, of the form
 
156
        (old_path, new_path, file_id, new_entry).  For creation, old_path
 
157
        must be None.  For deletion, new_path and new_entry must be None.
 
158
        file_id is always non-None.  For renames and other mutations, all
 
159
        values must be non-None.
 
160
 
 
161
        If the new_entry is a directory, its children should be an empty
 
162
        dict.  Children are handled by apply_inventory_delta itself.
 
163
 
 
164
        :param changes: A list of tuples for the change to apply:
 
165
            [(old_path, new_path, file_id, new_inventory_entry), ...]
188
166
        """
189
 
        raise NotImplementedError(self.apply_inventory_delta)
 
167
        self.flush()
 
168
        inv = self.inventory
 
169
        children = {}
 
170
        for old_path, file_id in sorted(((op, f) for op, np, f, e in changes
 
171
                                        if op is not None), reverse=True):
 
172
            if file_id not in inv:
 
173
                continue
 
174
            children[file_id] = getattr(inv[file_id], 'children', {})
 
175
            inv.remove_recursive_id(file_id)
 
176
        for new_path, new_entry in sorted((np, e) for op, np, f, e in
 
177
                                          changes if np is not None):
 
178
            if getattr(new_entry, 'children', None) is not None:
 
179
                new_entry.children = children.get(new_entry.file_id, {})
 
180
            inv.add(new_entry)
 
181
        self._write_inventory(inv)
190
182
 
191
183
    @needs_write_lock
192
184
    def commit(self, message=None, revprops=None, *args,
193
185
               **kwargs):
194
186
        # avoid circular imports
195
187
        from bzrlib import commit
196
 
        possible_master_transports=[]
197
 
        revprops = commit.Commit.update_revprops(
198
 
                revprops,
199
 
                self.branch,
200
 
                kwargs.pop('authors', None),
201
 
                kwargs.pop('author', None),
202
 
                kwargs.get('local', False),
203
 
                possible_master_transports)
 
188
        if revprops is None:
 
189
            revprops = {}
 
190
        if not 'branch-nick' in revprops:
 
191
            revprops['branch-nick'] = self.branch.nick
204
192
        # args for wt.commit start at message from the Commit.commit method,
205
193
        args = (message, ) + args
206
 
        for hook in MutableTree.hooks['start_commit']:
207
 
            hook(self)
208
194
        committed_id = commit.Commit().commit(working_tree=self,
209
 
            revprops=revprops,
210
 
            possible_master_transports=possible_master_transports,
211
 
            *args, **kwargs)
212
 
        post_hook_params = PostCommitHookParams(self)
213
 
        for hook in MutableTree.hooks['post_commit']:
214
 
            hook(post_hook_params)
 
195
            revprops=revprops, *args, **kwargs)
215
196
        return committed_id
216
197
 
217
198
    def _gather_kinds(self, files, kinds):
219
200
        raise NotImplementedError(self._gather_kinds)
220
201
 
221
202
    @needs_read_lock
222
 
    def has_changes(self, _from_tree=None):
223
 
        """Quickly check that the tree contains at least one commitable change.
224
 
 
225
 
        :param _from_tree: tree to compare against to find changes (default to
226
 
            the basis tree and is intended to be used by tests).
227
 
 
228
 
        :return: True if a change is found. False otherwise
229
 
        """
230
 
        # Check pending merges
231
 
        if len(self.get_parent_ids()) > 1:
232
 
            return True
233
 
        if _from_tree is None:
234
 
            _from_tree = self.basis_tree()
235
 
        changes = self.iter_changes(_from_tree)
236
 
        try:
237
 
            change = changes.next()
238
 
            # Exclude root (talk about black magic... --vila 20090629)
239
 
            if change[4] == (None, None):
240
 
                change = changes.next()
241
 
            return True
242
 
        except StopIteration:
243
 
            # No changes
244
 
            return False
245
 
 
246
 
    @needs_read_lock
247
 
    def check_changed_or_out_of_date(self, strict, opt_name,
248
 
                                     more_error, more_warning):
249
 
        """Check the tree for uncommitted changes and branch synchronization.
250
 
 
251
 
        If strict is None and not set in the config files, a warning is issued.
252
 
        If strict is True, an error is raised.
253
 
        If strict is False, no checks are done and no warning is issued.
254
 
 
255
 
        :param strict: True, False or None, searched in branch config if None.
256
 
 
257
 
        :param opt_name: strict option name to search in config file.
258
 
 
259
 
        :param more_error: Details about how to avoid the check.
260
 
 
261
 
        :param more_warning: Details about what is happening.
262
 
        """
263
 
        if strict is None:
264
 
            strict = self.branch.get_config_stack().get(opt_name)
265
 
        if strict is not False:
266
 
            err_class = None
267
 
            if (self.has_changes()):
268
 
                err_class = errors.UncommittedChanges
269
 
            elif self.last_revision() != self.branch.last_revision():
270
 
                # The tree has lost sync with its branch, there is little
271
 
                # chance that the user is aware of it but he can still force
272
 
                # the action with --no-strict
273
 
                err_class = errors.OutOfDateTree
274
 
            if err_class is not None:
275
 
                if strict is None:
276
 
                    err = err_class(self, more=more_warning)
277
 
                    # We don't want to interrupt the user if he expressed no
278
 
                    # preference about strict.
279
 
                    trace.warning('%s', err._format())
280
 
                else:
281
 
                    err = err_class(self, more=more_error)
282
 
                    raise err
283
 
 
284
 
    @needs_read_lock
285
203
    def last_revision(self):
286
204
        """Return the revision id of the last commit performed in this tree.
287
205
 
288
206
        In early tree formats the result of last_revision is the same as the
289
207
        branch last_revision, but that is no longer the case for modern tree
290
208
        formats.
291
 
 
 
209
        
292
210
        last_revision returns the left most parent id, or None if there are no
293
211
        parents.
294
212
 
311
229
    def lock_write(self):
312
230
        """Lock the tree and its branch. This allows mutating calls to be made.
313
231
 
314
 
        Some mutating methods will take out implicit write locks, but in
 
232
        Some mutating methods will take out implicit write locks, but in 
315
233
        general you should always obtain a write lock before calling mutating
316
234
        methods on a tree.
317
235
        """
327
245
        """
328
246
        raise NotImplementedError(self.mkdir)
329
247
 
330
 
    def _observed_sha1(self, file_id, path, (sha1, stat_value)):
331
 
        """Tell the tree we have observed a paths sha1.
332
 
 
333
 
        The intent of this function is to allow trees that have a hashcache to
334
 
        update the hashcache during commit. If the observed file is too new
335
 
        (based on the stat_value) to be safely hash-cached the tree will ignore
336
 
        it.
337
 
 
338
 
        The default implementation does nothing.
339
 
 
340
 
        :param file_id: The file id
341
 
        :param path: The file path
342
 
        :param sha1: The sha 1 that was observed.
343
 
        :param stat_value: A stat result for the file the sha1 was read from.
344
 
        :return: None
345
 
        """
346
 
 
347
 
    @needs_write_lock
348
 
    def put_file_bytes_non_atomic(self, file_id, bytes):
349
 
        """Update the content of a file in the tree.
350
 
 
351
 
        Note that the file is written in-place rather than being
352
 
        written to a temporary location and renamed. As a consequence,
353
 
        readers can potentially see the file half-written.
354
 
 
355
 
        :param file_id: file-id of the file
356
 
        :param bytes: the new file contents
357
 
        """
358
 
        raise NotImplementedError(self.put_file_bytes_non_atomic)
359
 
 
360
248
    def set_parent_ids(self, revision_ids, allow_leftmost_as_ghost=False):
361
249
        """Set the parents ids of the working tree.
362
250
 
367
255
    def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
368
256
        """Set the parents of the working tree.
369
257
 
370
 
        :param parents_list: A list of (revision_id, tree) tuples.
 
258
        :param parents_list: A list of (revision_id, tree) tuples. 
371
259
            If tree is None, then that element is treated as an unreachable
372
260
            parent tree - i.e. a ghost.
373
261
        """
374
262
        raise NotImplementedError(self.set_parent_trees)
375
 
 
376
 
    def smart_add(self, file_list, recurse=True, action=None, save=True):
377
 
        """Version file_list, optionally recursing into directories.
378
 
 
379
 
        This is designed more towards DWIM for humans than API clarity.
380
 
        For the specific behaviour see the help for cmd_add().
381
 
 
382
 
        :param file_list: List of zero or more paths.  *NB: these are 
383
 
            interpreted relative to the process cwd, not relative to the 
384
 
            tree.*  (Add and most other tree methods use tree-relative
385
 
            paths.)
386
 
        :param action: A reporter to be called with the inventory, parent_ie,
387
 
            path and kind of the path being added. It may return a file_id if
388
 
            a specific one should be used.
389
 
        :param save: Save the inventory after completing the adds. If False
390
 
            this provides dry-run functionality by doing the add and not saving
391
 
            the inventory.
392
 
        :return: A tuple - files_added, ignored_files. files_added is the count
393
 
            of added files, and ignored_files is a dict mapping files that were
394
 
            ignored to the rule that caused them to be ignored.
395
 
        """
396
 
        raise NotImplementedError(self.smart_add)
397
 
 
398
 
 
399
 
class MutableInventoryTree(MutableTree, tree.InventoryTree):
400
 
 
401
 
    @needs_tree_write_lock
402
 
    def apply_inventory_delta(self, changes):
403
 
        """Apply changes to the inventory as an atomic operation.
404
 
 
405
 
        :param changes: An inventory delta to apply to the working tree's
406
 
            inventory.
407
 
        :return None:
408
 
        :seealso Inventory.apply_delta: For details on the changes parameter.
409
 
        """
410
 
        self.flush()
411
 
        inv = self.inventory
412
 
        inv.apply_delta(changes)
413
 
        self._write_inventory(inv)
414
 
 
415
 
    def _fix_case_of_inventory_path(self, path):
416
 
        """If our tree isn't case sensitive, return the canonical path"""
417
 
        if not self.case_sensitive:
418
 
            path = self.get_canonical_inventory_path(path)
419
 
        return path
420
 
 
421
 
    @needs_tree_write_lock
422
 
    def smart_add(self, file_list, recurse=True, action=None, save=True):
423
 
        """Version file_list, optionally recursing into directories.
424
 
 
425
 
        This is designed more towards DWIM for humans than API clarity.
426
 
        For the specific behaviour see the help for cmd_add().
427
 
 
428
 
        :param file_list: List of zero or more paths.  *NB: these are 
429
 
            interpreted relative to the process cwd, not relative to the 
430
 
            tree.*  (Add and most other tree methods use tree-relative
431
 
            paths.)
432
 
        :param action: A reporter to be called with the inventory, parent_ie,
433
 
            path and kind of the path being added. It may return a file_id if
434
 
            a specific one should be used.
435
 
        :param save: Save the inventory after completing the adds. If False
436
 
            this provides dry-run functionality by doing the add and not saving
437
 
            the inventory.
438
 
        :return: A tuple - files_added, ignored_files. files_added is the count
439
 
            of added files, and ignored_files is a dict mapping files that were
440
 
            ignored to the rule that caused them to be ignored.
441
 
        """
442
 
        # Not all mutable trees can have conflicts
443
 
        if getattr(self, 'conflicts', None) is not None:
444
 
            # Collect all related files without checking whether they exist or
445
 
            # are versioned. It's cheaper to do that once for all conflicts
446
 
            # than trying to find the relevant conflict for each added file.
447
 
            conflicts_related = set()
448
 
            for c in self.conflicts():
449
 
                conflicts_related.update(c.associated_filenames())
450
 
        else:
451
 
            conflicts_related = None
452
 
        adder = _SmartAddHelper(self, action, conflicts_related)
453
 
        adder.add(file_list, recurse=recurse)
454
 
        if save:
455
 
            invdelta = adder.get_inventory_delta()
456
 
            self.apply_inventory_delta(invdelta)
457
 
        return adder.added, adder.ignored
458
 
 
459
 
    def update_basis_by_delta(self, new_revid, delta):
460
 
        """Update the parents of this tree after a commit.
461
 
 
462
 
        This gives the tree one parent, with revision id new_revid. The
463
 
        inventory delta is applied to the current basis tree to generate the
464
 
        inventory for the parent new_revid, and all other parent trees are
465
 
        discarded.
466
 
 
467
 
        All the changes in the delta should be changes synchronising the basis
468
 
        tree with some or all of the working tree, with a change to a directory
469
 
        requiring that its contents have been recursively included. That is,
470
 
        this is not a general purpose tree modification routine, but a helper
471
 
        for commit which is not required to handle situations that do not arise
472
 
        outside of commit.
473
 
 
474
 
        See the inventory developers documentation for the theory behind
475
 
        inventory deltas.
476
 
 
477
 
        :param new_revid: The new revision id for the trees parent.
478
 
        :param delta: An inventory delta (see apply_inventory_delta) describing
479
 
            the changes from the current left most parent revision to new_revid.
480
 
        """
481
 
        # if the tree is updated by a pull to the branch, as happens in
482
 
        # WorkingTree2, when there was no separation between branch and tree,
483
 
        # then just clear merges, efficiency is not a concern for now as this
484
 
        # is legacy environments only, and they are slow regardless.
485
 
        if self.last_revision() == new_revid:
486
 
            self.set_parent_ids([new_revid])
487
 
            return
488
 
        # generic implementation based on Inventory manipulation. See
489
 
        # WorkingTree classes for optimised versions for specific format trees.
490
 
        basis = self.basis_tree()
491
 
        basis.lock_read()
492
 
        # TODO: Consider re-evaluating the need for this with CHKInventory
493
 
        # we don't strictly need to mutate an inventory for this
494
 
        # it only makes sense when apply_delta is cheaper than get_inventory()
495
 
        inventory = _mod_inventory.mutable_inventory_from_tree(basis)
496
 
        basis.unlock()
497
 
        inventory.apply_delta(delta)
498
 
        rev_tree = revisiontree.InventoryRevisionTree(self.branch.repository,
499
 
                                             inventory, new_revid)
500
 
        self.set_parent_trees([(new_revid, rev_tree)])
501
 
 
502
 
 
503
 
class MutableTreeHooks(hooks.Hooks):
504
 
    """A dictionary mapping a hook name to a list of callables for mutabletree
505
 
    hooks.
506
 
    """
507
 
 
508
 
    def __init__(self):
509
 
        """Create the default hooks.
510
 
 
511
 
        """
512
 
        hooks.Hooks.__init__(self, "bzrlib.mutabletree", "MutableTree.hooks")
513
 
        self.add_hook('start_commit',
514
 
            "Called before a commit is performed on a tree. The start commit "
515
 
            "hook is able to change the tree before the commit takes place. "
516
 
            "start_commit is called with the bzrlib.mutabletree.MutableTree "
517
 
            "that the commit is being performed on.", (1, 4))
518
 
        self.add_hook('post_commit',
519
 
            "Called after a commit is performed on a tree. The hook is "
520
 
            "called with a bzrlib.mutabletree.PostCommitHookParams object. "
521
 
            "The mutable tree the commit was performed on is available via "
522
 
            "the mutable_tree attribute of that object.", (2, 0))
523
 
 
524
 
 
525
 
# install the default hooks into the MutableTree class.
526
 
MutableTree.hooks = MutableTreeHooks()
527
 
 
528
 
 
529
 
class PostCommitHookParams(object):
530
 
    """Parameters for the post_commit hook.
531
 
 
532
 
    To access the parameters, use the following attributes:
533
 
 
534
 
    * mutable_tree - the MutableTree object
535
 
    """
536
 
 
537
 
    def __init__(self, mutable_tree):
538
 
        """Create the parameters for the post_commit hook."""
539
 
        self.mutable_tree = mutable_tree
540
 
 
541
 
 
542
 
class _SmartAddHelper(object):
543
 
    """Helper for MutableTree.smart_add."""
544
 
 
545
 
    def get_inventory_delta(self):
546
 
        return self._invdelta.values()
547
 
 
548
 
    def _get_ie(self, inv_path):
549
 
        """Retrieve the most up to date inventory entry for a path.
550
 
 
551
 
        :param inv_path: Normalized inventory path
552
 
        :return: Inventory entry (with possibly invalid .children for
553
 
            directories)
554
 
        """
555
 
        entry = self._invdelta.get(inv_path)
556
 
        if entry is not None:
557
 
            return entry[3]
558
 
        # Find a 'best fit' match if the filesystem is case-insensitive
559
 
        inv_path = self.tree._fix_case_of_inventory_path(inv_path)
560
 
        file_id = self.tree.path2id(inv_path)
561
 
        if file_id is not None:
562
 
            return self.tree.iter_entries_by_dir([file_id]).next()[1]
563
 
        return None
564
 
 
565
 
    def _convert_to_directory(self, this_ie, inv_path):
566
 
        """Convert an entry to a directory.
567
 
 
568
 
        :param this_ie: Inventory entry
569
 
        :param inv_path: Normalized path for the inventory entry
570
 
        :return: The new inventory entry
571
 
        """
572
 
        # Same as in _add_one below, if the inventory doesn't
573
 
        # think this is a directory, update the inventory
574
 
        this_ie = _mod_inventory.InventoryDirectory(
575
 
            this_ie.file_id, this_ie.name, this_ie.parent_id)
576
 
        self._invdelta[inv_path] = (inv_path, inv_path, this_ie.file_id,
577
 
            this_ie)
578
 
        return this_ie
579
 
 
580
 
    def _add_one_and_parent(self, parent_ie, path, kind, inv_path):
581
 
        """Add a new entry to the inventory and automatically add unversioned parents.
582
 
 
583
 
        :param parent_ie: Parent inventory entry if known, or None.  If
584
 
            None, the parent is looked up by name and used if present, otherwise it
585
 
            is recursively added.
586
 
        :param path: 
587
 
        :param kind: Kind of new entry (file, directory, etc)
588
 
        :param inv_path:
589
 
        :return: Inventory entry for path and a list of paths which have been added.
590
 
        """
591
 
        # Nothing to do if path is already versioned.
592
 
        # This is safe from infinite recursion because the tree root is
593
 
        # always versioned.
594
 
        inv_dirname = osutils.dirname(inv_path)
595
 
        dirname, basename = osutils.split(path)
596
 
        if parent_ie is None:
597
 
            # slower but does not need parent_ie
598
 
            this_ie = self._get_ie(inv_path)
599
 
            if this_ie is not None:
600
 
                return this_ie
601
 
            # its really not there : add the parent
602
 
            # note that the dirname use leads to some extra str copying etc but as
603
 
            # there are a limited number of dirs we can be nested under, it should
604
 
            # generally find it very fast and not recurse after that.
605
 
            parent_ie = self._add_one_and_parent(None,
606
 
                dirname, 'directory', 
607
 
                inv_dirname)
608
 
        # if the parent exists, but isn't a directory, we have to do the
609
 
        # kind change now -- really the inventory shouldn't pretend to know
610
 
        # the kind of wt files, but it does.
611
 
        if parent_ie.kind != 'directory':
612
 
            # nb: this relies on someone else checking that the path we're using
613
 
            # doesn't contain symlinks.
614
 
            parent_ie = self._convert_to_directory(parent_ie, inv_dirname)
615
 
        file_id = self.action(self.tree.inventory, parent_ie, path, kind)
616
 
        entry = _mod_inventory.make_entry(kind, basename, parent_ie.file_id,
617
 
            file_id=file_id)
618
 
        self._invdelta[inv_path] = (None, inv_path, entry.file_id, entry)
619
 
        self.added.append(inv_path)
620
 
        return entry
621
 
 
622
 
    def _gather_dirs_to_add(self, user_dirs):
623
 
        # only walk the minimal parents needed: we have user_dirs to override
624
 
        # ignores.
625
 
        prev_dir = None
626
 
 
627
 
        is_inside = osutils.is_inside_or_parent_of_any
628
 
        for path, (inv_path, this_ie) in sorted(
629
 
                user_dirs.iteritems(), key=operator.itemgetter(0)):
630
 
            if (prev_dir is None or not is_inside([prev_dir], path)):
631
 
                yield (path, inv_path, this_ie, None)
632
 
            prev_dir = path
633
 
        
634
 
    def __init__(self, tree, action, conflicts_related=None):
635
 
        self.tree = tree
636
 
        if action is None:
637
 
            self.action = add.AddAction()
638
 
        else:
639
 
            self.action = action
640
 
        self._invdelta = {}
641
 
        self.added = []
642
 
        self.ignored = {}
643
 
        if conflicts_related is None:
644
 
            self.conflicts_related = frozenset()
645
 
        else:
646
 
            self.conflicts_related = conflicts_related
647
 
 
648
 
    def add(self, file_list, recurse=True):
649
 
        from bzrlib.inventory import InventoryEntry
650
 
        if not file_list:
651
 
            # no paths supplied: add the entire tree.
652
 
            # FIXME: this assumes we are running in a working tree subdir :-/
653
 
            # -- vila 20100208
654
 
            file_list = [u'.']
655
 
 
656
 
        # expand any symlinks in the directory part, while leaving the
657
 
        # filename alone
658
 
        # only expanding if symlinks are supported avoids windows path bugs
659
 
        if osutils.has_symlinks():
660
 
            file_list = map(osutils.normalizepath, file_list)
661
 
 
662
 
        user_dirs = {}
663
 
        # validate user file paths and convert all paths to tree
664
 
        # relative : it's cheaper to make a tree relative path an abspath
665
 
        # than to convert an abspath to tree relative, and it's cheaper to
666
 
        # perform the canonicalization in bulk.
667
 
        for filepath in osutils.canonical_relpaths(self.tree.basedir, file_list):
668
 
            # validate user parameters. Our recursive code avoids adding new
669
 
            # files that need such validation
670
 
            if self.tree.is_control_filename(filepath):
671
 
                raise errors.ForbiddenControlFileError(filename=filepath)
672
 
 
673
 
            abspath = self.tree.abspath(filepath)
674
 
            kind = osutils.file_kind(abspath)
675
 
            # ensure the named path is added, so that ignore rules in the later
676
 
            # directory walk dont skip it.
677
 
            # we dont have a parent ie known yet.: use the relatively slower
678
 
            # inventory probing method
679
 
            inv_path, _ = osutils.normalized_filename(filepath)
680
 
            this_ie = self._get_ie(inv_path)
681
 
            if this_ie is None:
682
 
                this_ie = self._add_one_and_parent(None, filepath, kind, inv_path)
683
 
            if kind == 'directory':
684
 
                # schedule the dir for scanning
685
 
                user_dirs[filepath] = (inv_path, this_ie)
686
 
 
687
 
        if not recurse:
688
 
            # no need to walk any directories at all.
689
 
            return
690
 
 
691
 
        things_to_add = list(self._gather_dirs_to_add(user_dirs))
692
 
 
693
 
        illegalpath_re = re.compile(r'[\r\n]')
694
 
        for directory, inv_path, this_ie, parent_ie in things_to_add:
695
 
            # directory is tree-relative
696
 
            abspath = self.tree.abspath(directory)
697
 
 
698
 
            # get the contents of this directory.
699
 
 
700
 
            # find the kind of the path being added, and save stat_value
701
 
            # for reuse
702
 
            stat_value = None
703
 
            if this_ie is None:
704
 
                stat_value = osutils.file_stat(abspath)
705
 
                kind = osutils.file_kind_from_stat_mode(stat_value.st_mode)
706
 
            else:
707
 
                kind = this_ie.kind
708
 
            
709
 
            # allow AddAction to skip this file
710
 
            if self.action.skip_file(self.tree,  abspath,  kind,  stat_value):
711
 
                continue
712
 
            if not InventoryEntry.versionable_kind(kind):
713
 
                trace.warning("skipping %s (can't add file of kind '%s')",
714
 
                              abspath, kind)
715
 
                continue
716
 
            if illegalpath_re.search(directory):
717
 
                trace.warning("skipping %r (contains \\n or \\r)" % abspath)
718
 
                continue
719
 
            if directory in self.conflicts_related:
720
 
                # If the file looks like one generated for a conflict, don't
721
 
                # add it.
722
 
                trace.warning(
723
 
                    'skipping %s (generated to help resolve conflicts)',
724
 
                    abspath)
725
 
                continue
726
 
 
727
 
            if kind == 'directory' and directory != '':
728
 
                try:
729
 
                    transport = _mod_transport.get_transport_from_path(abspath)
730
 
                    controldir.ControlDirFormat.find_format(transport)
731
 
                    sub_tree = True
732
 
                except errors.NotBranchError:
733
 
                    sub_tree = False
734
 
                except errors.UnsupportedFormatError:
735
 
                    sub_tree = True
736
 
            else:
737
 
                sub_tree = False
738
 
 
739
 
            if this_ie is not None:
740
 
                pass
741
 
            elif sub_tree:
742
 
                # XXX: This is wrong; people *might* reasonably be trying to
743
 
                # add subtrees as subtrees.  This should probably only be done
744
 
                # in formats which can represent subtrees, and even then
745
 
                # perhaps only when the user asked to add subtrees.  At the
746
 
                # moment you can add them specially through 'join --reference',
747
 
                # which is perhaps reasonable: adding a new reference is a
748
 
                # special operation and can have a special behaviour.  mbp
749
 
                # 20070306
750
 
                trace.warning("skipping nested tree %r", abspath)
751
 
            else:
752
 
                this_ie = self._add_one_and_parent(parent_ie, directory, kind,
753
 
                    inv_path)
754
 
 
755
 
            if kind == 'directory' and not sub_tree:
756
 
                if this_ie.kind != 'directory':
757
 
                    this_ie = self._convert_to_directory(this_ie, inv_path)
758
 
 
759
 
                for subf in sorted(os.listdir(abspath)):
760
 
                    inv_f, _ = osutils.normalized_filename(subf)
761
 
                    # here we could use TreeDirectory rather than
762
 
                    # string concatenation.
763
 
                    subp = osutils.pathjoin(directory, subf)
764
 
                    # TODO: is_control_filename is very slow. Make it faster.
765
 
                    # TreeDirectory.is_control_filename could also make this
766
 
                    # faster - its impossible for a non root dir to have a
767
 
                    # control file.
768
 
                    if self.tree.is_control_filename(subp):
769
 
                        trace.mutter("skip control directory %r", subp)
770
 
                        continue
771
 
                    sub_invp = osutils.pathjoin(inv_path, inv_f)
772
 
                    entry = self._invdelta.get(sub_invp)
773
 
                    if entry is not None:
774
 
                        sub_ie = entry[3]
775
 
                    else:
776
 
                        sub_ie = this_ie.children.get(inv_f)
777
 
                    if sub_ie is not None:
778
 
                        # recurse into this already versioned subdir.
779
 
                        things_to_add.append((subp, sub_invp, sub_ie, this_ie))
780
 
                    else:
781
 
                        # user selection overrides ignores
782
 
                        # ignore while selecting files - if we globbed in the
783
 
                        # outer loop we would ignore user files.
784
 
                        ignore_glob = self.tree.is_ignored(subp)
785
 
                        if ignore_glob is not None:
786
 
                            self.ignored.setdefault(ignore_glob, []).append(subp)
787
 
                        else:
788
 
                            things_to_add.append((subp, sub_invp, None, this_ie))