~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/mutabletree.py

  • Committer: Vincent Ladeuil
  • Date: 2010-04-28 10:33:44 UTC
  • mfrom: (5171.2.3 401599-strict-warnings)
  • mto: This revision was merged to the branch mainline in revision 5191.
  • Revision ID: v.ladeuil+lp@free.fr-20100428103344-e32qf3cn1avdd2cb
Don't mention --no-strict when we just issue the warning about unclean trees

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2006-2011 Canonical Ltd
 
1
# Copyright (C) 2006-2010 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
22
22
 
23
23
from bzrlib.lazy_import import lazy_import
24
24
lazy_import(globals(), """
25
 
import operator
26
25
import os
27
26
import re
28
27
 
29
28
from bzrlib import (
30
29
    add,
31
 
    controldir,
 
30
    bzrdir,
32
31
    errors,
33
32
    hooks,
34
 
    inventory as _mod_inventory,
35
33
    osutils,
36
34
    revisiontree,
 
35
    symbol_versioning,
37
36
    trace,
38
 
    transport as _mod_transport,
39
37
    tree,
40
38
    )
41
39
""")
81
79
        # used on media which doesn't differentiate the case of names.
82
80
        self.case_sensitive = True
83
81
 
84
 
    def is_control_filename(self, filename):
85
 
        """True if filename is the name of a control file in this tree.
86
 
 
87
 
        :param filename: A filename within the tree. This is a relative path
88
 
            from the root of this tree.
89
 
 
90
 
        This is true IF and ONLY IF the filename is part of the meta data
91
 
        that bzr controls in this tree. I.E. a random .bzr directory placed
92
 
        on disk will not be a control file for this tree.
93
 
        """
94
 
        raise NotImplementedError(self.is_control_filename)
95
 
 
96
82
    @needs_tree_write_lock
97
83
    def add(self, files, ids=None, kinds=None):
98
84
        """Add paths to the set of versioned paths.
162
148
        if sub_tree_id == self.get_root_id():
163
149
            raise errors.BadReferenceTarget(self, sub_tree,
164
150
                                     'Trees have the same root id.')
165
 
        if self.has_id(sub_tree_id):
 
151
        if sub_tree_id in self.inventory:
166
152
            raise errors.BadReferenceTarget(self, sub_tree,
167
153
                                            'Root id already present in tree')
168
154
        self._add([sub_tree_path], [sub_tree_id], ['tree-reference'])
177
163
        """
178
164
        raise NotImplementedError(self._add)
179
165
 
 
166
    @needs_tree_write_lock
180
167
    def apply_inventory_delta(self, changes):
181
168
        """Apply changes to the inventory as an atomic operation.
182
169
 
185
172
        :return None:
186
173
        :seealso Inventory.apply_delta: For details on the changes parameter.
187
174
        """
188
 
        raise NotImplementedError(self.apply_inventory_delta)
 
175
        self.flush()
 
176
        inv = self.inventory
 
177
        inv.apply_delta(changes)
 
178
        self._write_inventory(inv)
189
179
 
190
180
    @needs_write_lock
191
181
    def commit(self, message=None, revprops=None, *args,
192
182
               **kwargs):
193
183
        # avoid circular imports
194
184
        from bzrlib import commit
 
185
        if revprops is None:
 
186
            revprops = {}
195
187
        possible_master_transports=[]
196
 
        revprops = commit.Commit.update_revprops(
197
 
                revprops,
198
 
                self.branch,
199
 
                kwargs.pop('authors', None),
200
 
                kwargs.pop('author', None),
 
188
        if not 'branch-nick' in revprops:
 
189
            revprops['branch-nick'] = self.branch._get_nick(
201
190
                kwargs.get('local', False),
202
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
203
218
        # args for wt.commit start at message from the Commit.commit method,
204
219
        args = (message, ) + args
205
220
        for hook in MutableTree.hooks['start_commit']:
260
275
        :param more_warning: Details about what is happening.
261
276
        """
262
277
        if strict is None:
263
 
            strict = self.branch.get_config_stack().get(opt_name)
 
278
            strict = self.branch.get_config().get_user_option_as_bool(opt_name)
264
279
        if strict is not False:
265
280
            err_class = None
266
281
            if (self.has_changes()):
343
358
        :return: None
344
359
        """
345
360
 
 
361
    def _fix_case_of_inventory_path(self, path):
 
362
        """If our tree isn't case sensitive, return the canonical path"""
 
363
        if not self.case_sensitive:
 
364
            path = self.get_canonical_inventory_path(path)
 
365
        return path
 
366
 
346
367
    @needs_write_lock
347
368
    def put_file_bytes_non_atomic(self, file_id, bytes):
348
369
        """Update the content of a file in the tree.
372
393
        """
373
394
        raise NotImplementedError(self.set_parent_trees)
374
395
 
 
396
    @needs_tree_write_lock
375
397
    def smart_add(self, file_list, recurse=True, action=None, save=True):
376
398
        """Version file_list, optionally recursing into directories.
377
399
 
378
400
        This is designed more towards DWIM for humans than API clarity.
379
401
        For the specific behaviour see the help for cmd_add().
380
402
 
381
 
        :param file_list: List of zero or more paths.  *NB: these are 
382
 
            interpreted relative to the process cwd, not relative to the 
383
 
            tree.*  (Add and most other tree methods use tree-relative
384
 
            paths.)
385
403
        :param action: A reporter to be called with the inventory, parent_ie,
386
404
            path and kind of the path being added. It may return a file_id if
387
405
            a specific one should be used.
392
410
            of added files, and ignored_files is a dict mapping files that were
393
411
            ignored to the rule that caused them to be ignored.
394
412
        """
395
 
        raise NotImplementedError(self.smart_add)
396
 
 
397
 
 
398
 
class MutableInventoryTree(MutableTree, tree.InventoryTree):
399
 
 
400
 
    @needs_tree_write_lock
401
 
    def apply_inventory_delta(self, changes):
402
 
        """Apply changes to the inventory as an atomic operation.
403
 
 
404
 
        :param changes: An inventory delta to apply to the working tree's
405
 
            inventory.
406
 
        :return None:
407
 
        :seealso Inventory.apply_delta: For details on the changes parameter.
408
 
        """
409
 
        self.flush()
 
413
        # not in an inner loop; and we want to remove direct use of this,
 
414
        # so here as a reminder for now. RBC 20070703
 
415
        from bzrlib.inventory import InventoryEntry
 
416
        if action is None:
 
417
            action = add.AddAction()
 
418
 
 
419
        if not file_list:
 
420
            # no paths supplied: add the entire tree.
 
421
            # FIXME: this assumes we are running in a working tree subdir :-/
 
422
            # -- vila 20100208
 
423
            file_list = [u'.']
 
424
        # mutter("smart add of %r")
410
425
        inv = self.inventory
411
 
        inv.apply_delta(changes)
412
 
        self._write_inventory(inv)
413
 
 
414
 
    def _fix_case_of_inventory_path(self, path):
415
 
        """If our tree isn't case sensitive, return the canonical path"""
416
 
        if not self.case_sensitive:
417
 
            path = self.get_canonical_inventory_path(path)
418
 
        return path
419
 
 
420
 
    @needs_tree_write_lock
421
 
    def smart_add(self, file_list, recurse=True, action=None, save=True):
422
 
        """Version file_list, optionally recursing into directories.
423
 
 
424
 
        This is designed more towards DWIM for humans than API clarity.
425
 
        For the specific behaviour see the help for cmd_add().
426
 
 
427
 
        :param file_list: List of zero or more paths.  *NB: these are 
428
 
            interpreted relative to the process cwd, not relative to the 
429
 
            tree.*  (Add and most other tree methods use tree-relative
430
 
            paths.)
431
 
        :param action: A reporter to be called with the inventory, parent_ie,
432
 
            path and kind of the path being added. It may return a file_id if
433
 
            a specific one should be used.
434
 
        :param save: Save the inventory after completing the adds. If False
435
 
            this provides dry-run functionality by doing the add and not saving
436
 
            the inventory.
437
 
        :return: A tuple - files_added, ignored_files. files_added is the count
438
 
            of added files, and ignored_files is a dict mapping files that were
439
 
            ignored to the rule that caused them to be ignored.
440
 
        """
 
426
        added = []
 
427
        ignored = {}
 
428
        dirs_to_add = []
 
429
        user_dirs = set()
 
430
        conflicts_related = set()
441
431
        # Not all mutable trees can have conflicts
442
432
        if getattr(self, 'conflicts', None) is not None:
443
433
            # Collect all related files without checking whether they exist or
444
434
            # are versioned. It's cheaper to do that once for all conflicts
445
435
            # than trying to find the relevant conflict for each added file.
446
 
            conflicts_related = set()
447
436
            for c in self.conflicts():
448
437
                conflicts_related.update(c.associated_filenames())
449
 
        else:
450
 
            conflicts_related = None
451
 
        adder = _SmartAddHelper(self, action, conflicts_related)
452
 
        adder.add(file_list, recurse=recurse)
453
 
        if save:
454
 
            invdelta = adder.get_inventory_delta()
455
 
            self.apply_inventory_delta(invdelta)
456
 
        return adder.added, adder.ignored
 
438
 
 
439
        # validate user file paths and convert all paths to tree
 
440
        # relative : it's cheaper to make a tree relative path an abspath
 
441
        # than to convert an abspath to tree relative, and it's cheaper to
 
442
        # perform the canonicalization in bulk.
 
443
        for filepath in osutils.canonical_relpaths(self.basedir, file_list):
 
444
            rf = _FastPath(filepath)
 
445
            # validate user parameters. Our recursive code avoids adding new
 
446
            # files that need such validation
 
447
            if self.is_control_filename(rf.raw_path):
 
448
                raise errors.ForbiddenControlFileError(filename=rf.raw_path)
 
449
 
 
450
            abspath = self.abspath(rf.raw_path)
 
451
            kind = osutils.file_kind(abspath)
 
452
            if kind == 'directory':
 
453
                # schedule the dir for scanning
 
454
                user_dirs.add(rf)
 
455
            else:
 
456
                if not InventoryEntry.versionable_kind(kind):
 
457
                    raise errors.BadFileKindError(filename=abspath, kind=kind)
 
458
            # ensure the named path is added, so that ignore rules in the later
 
459
            # directory walk dont skip it.
 
460
            # we dont have a parent ie known yet.: use the relatively slower
 
461
            # inventory probing method
 
462
            versioned = inv.has_filename(rf.raw_path)
 
463
            if versioned:
 
464
                continue
 
465
            added.extend(_add_one_and_parent(self, inv, None, rf, kind, action))
 
466
 
 
467
        if not recurse:
 
468
            # no need to walk any directories at all.
 
469
            if len(added) > 0 and save:
 
470
                self._write_inventory(inv)
 
471
            return added, ignored
 
472
 
 
473
        # only walk the minimal parents needed: we have user_dirs to override
 
474
        # ignores.
 
475
        prev_dir = None
 
476
 
 
477
        is_inside = osutils.is_inside_or_parent_of_any
 
478
        for path in sorted(user_dirs):
 
479
            if (prev_dir is None or not is_inside([prev_dir], path.raw_path)):
 
480
                dirs_to_add.append((path, None))
 
481
            prev_dir = path.raw_path
 
482
 
 
483
        illegalpath_re = re.compile(r'[\r\n]')
 
484
        # dirs_to_add is initialised to a list of directories, but as we scan
 
485
        # directories we append files to it.
 
486
        # XXX: We should determine kind of files when we scan them rather than
 
487
        # adding to this list. RBC 20070703
 
488
        for directory, parent_ie in dirs_to_add:
 
489
            # directory is tree-relative
 
490
            abspath = self.abspath(directory.raw_path)
 
491
 
 
492
            # get the contents of this directory.
 
493
 
 
494
            # find the kind of the path being added.
 
495
            kind = osutils.file_kind(abspath)
 
496
 
 
497
            if not InventoryEntry.versionable_kind(kind):
 
498
                trace.warning("skipping %s (can't add file of kind '%s')",
 
499
                              abspath, kind)
 
500
                continue
 
501
            if illegalpath_re.search(directory.raw_path):
 
502
                trace.warning("skipping %r (contains \\n or \\r)" % abspath)
 
503
                continue
 
504
            if directory.raw_path in conflicts_related:
 
505
                # If the file looks like one generated for a conflict, don't
 
506
                # add it.
 
507
                trace.warning(
 
508
                    'skipping %s (generated to help resolve conflicts)',
 
509
                    abspath)
 
510
                continue
 
511
 
 
512
            if parent_ie is not None:
 
513
                versioned = directory.base_path in parent_ie.children
 
514
            else:
 
515
                # without the parent ie, use the relatively slower inventory
 
516
                # probing method
 
517
                versioned = inv.has_filename(
 
518
                        self._fix_case_of_inventory_path(directory.raw_path))
 
519
 
 
520
            if kind == 'directory':
 
521
                try:
 
522
                    sub_branch = bzrdir.BzrDir.open(abspath)
 
523
                    sub_tree = True
 
524
                except errors.NotBranchError:
 
525
                    sub_tree = False
 
526
                except errors.UnsupportedFormatError:
 
527
                    sub_tree = True
 
528
            else:
 
529
                sub_tree = False
 
530
 
 
531
            if directory.raw_path == '':
 
532
                # mutter("tree root doesn't need to be added")
 
533
                sub_tree = False
 
534
            elif versioned:
 
535
                pass
 
536
                # mutter("%r is already versioned", abspath)
 
537
            elif sub_tree:
 
538
                # XXX: This is wrong; people *might* reasonably be trying to
 
539
                # add subtrees as subtrees.  This should probably only be done
 
540
                # in formats which can represent subtrees, and even then
 
541
                # perhaps only when the user asked to add subtrees.  At the
 
542
                # moment you can add them specially through 'join --reference',
 
543
                # which is perhaps reasonable: adding a new reference is a
 
544
                # special operation and can have a special behaviour.  mbp
 
545
                # 20070306
 
546
                trace.mutter("%r is a nested bzr tree", abspath)
 
547
            else:
 
548
                _add_one(self, inv, parent_ie, directory, kind, action)
 
549
                added.append(directory.raw_path)
 
550
 
 
551
            if kind == 'directory' and not sub_tree:
 
552
                if parent_ie is not None:
 
553
                    # must be present:
 
554
                    this_ie = parent_ie.children[directory.base_path]
 
555
                else:
 
556
                    # without the parent ie, use the relatively slower inventory
 
557
                    # probing method
 
558
                    this_id = inv.path2id(
 
559
                        self._fix_case_of_inventory_path(directory.raw_path))
 
560
                    if this_id is None:
 
561
                        this_ie = None
 
562
                    else:
 
563
                        this_ie = inv[this_id]
 
564
 
 
565
                for subf in sorted(os.listdir(abspath)):
 
566
                    # here we could use TreeDirectory rather than
 
567
                    # string concatenation.
 
568
                    subp = osutils.pathjoin(directory.raw_path, subf)
 
569
                    # TODO: is_control_filename is very slow. Make it faster.
 
570
                    # TreeDirectory.is_control_filename could also make this
 
571
                    # faster - its impossible for a non root dir to have a
 
572
                    # control file.
 
573
                    if self.is_control_filename(subp):
 
574
                        trace.mutter("skip control directory %r", subp)
 
575
                    elif subf in this_ie.children:
 
576
                        # recurse into this already versioned subdir.
 
577
                        dirs_to_add.append((_FastPath(subp, subf), this_ie))
 
578
                    else:
 
579
                        # user selection overrides ignoes
 
580
                        # ignore while selecting files - if we globbed in the
 
581
                        # outer loop we would ignore user files.
 
582
                        ignore_glob = self.is_ignored(subp)
 
583
                        if ignore_glob is not None:
 
584
                            # mutter("skip ignored sub-file %r", subp)
 
585
                            ignored.setdefault(ignore_glob, []).append(subp)
 
586
                        else:
 
587
                            #mutter("queue to add sub-file %r", subp)
 
588
                            dirs_to_add.append((_FastPath(subp, subf), this_ie))
 
589
 
 
590
        if len(added) > 0:
 
591
            if save:
 
592
                self._write_inventory(inv)
 
593
            else:
 
594
                self.read_working_inventory()
 
595
        return added, ignored
457
596
 
458
597
    def update_basis_by_delta(self, new_revid, delta):
459
598
        """Update the parents of this tree after a commit.
491
630
        # TODO: Consider re-evaluating the need for this with CHKInventory
492
631
        # we don't strictly need to mutate an inventory for this
493
632
        # it only makes sense when apply_delta is cheaper than get_inventory()
494
 
        inventory = _mod_inventory.mutable_inventory_from_tree(basis)
 
633
        inventory = basis.inventory._get_mutable_inventory()
495
634
        basis.unlock()
496
635
        inventory.apply_delta(delta)
497
 
        rev_tree = revisiontree.InventoryRevisionTree(self.branch.repository,
 
636
        rev_tree = revisiontree.RevisionTree(self.branch.repository,
498
637
                                             inventory, new_revid)
499
638
        self.set_parent_trees([(new_revid, rev_tree)])
500
639
 
508
647
        """Create the default hooks.
509
648
 
510
649
        """
511
 
        hooks.Hooks.__init__(self, "bzrlib.mutabletree", "MutableTree.hooks")
512
 
        self.add_hook('start_commit',
 
650
        hooks.Hooks.__init__(self)
 
651
        self.create_hook(hooks.HookPoint('start_commit',
513
652
            "Called before a commit is performed on a tree. The start commit "
514
653
            "hook is able to change the tree before the commit takes place. "
515
654
            "start_commit is called with the bzrlib.mutabletree.MutableTree "
516
 
            "that the commit is being performed on.", (1, 4))
517
 
        self.add_hook('post_commit',
 
655
            "that the commit is being performed on.", (1, 4), None))
 
656
        self.create_hook(hooks.HookPoint('post_commit',
518
657
            "Called after a commit is performed on a tree. The hook is "
519
658
            "called with a bzrlib.mutabletree.PostCommitHookParams object. "
520
659
            "The mutable tree the commit was performed on is available via "
521
 
            "the mutable_tree attribute of that object.", (2, 0))
 
660
            "the mutable_tree attribute of that object.", (2, 0), None))
522
661
 
523
662
 
524
663
# install the default hooks into the MutableTree class.
538
677
        self.mutable_tree = mutable_tree
539
678
 
540
679
 
541
 
class _SmartAddHelper(object):
542
 
    """Helper for MutableTree.smart_add."""
543
 
 
544
 
    def get_inventory_delta(self):
545
 
        return self._invdelta.values()
546
 
 
547
 
    def _get_ie(self, inv_path):
548
 
        """Retrieve the most up to date inventory entry for a path.
549
 
 
550
 
        :param inv_path: Normalized inventory path
551
 
        :return: Inventory entry (with possibly invalid .children for
552
 
            directories)
553
 
        """
554
 
        entry = self._invdelta.get(inv_path)
555
 
        if entry is not None:
556
 
            return entry[3]
557
 
        # Find a 'best fit' match if the filesystem is case-insensitive
558
 
        inv_path = self.tree._fix_case_of_inventory_path(inv_path)
559
 
        file_id = self.tree.path2id(inv_path)
560
 
        if file_id is not None:
561
 
            return self.tree.iter_entries_by_dir([file_id]).next()[1]
562
 
        return None
563
 
 
564
 
    def _convert_to_directory(self, this_ie, inv_path):
565
 
        """Convert an entry to a directory.
566
 
 
567
 
        :param this_ie: Inventory entry
568
 
        :param inv_path: Normalized path for the inventory entry
569
 
        :return: The new inventory entry
570
 
        """
571
 
        # Same as in _add_one below, if the inventory doesn't
572
 
        # think this is a directory, update the inventory
573
 
        this_ie = _mod_inventory.InventoryDirectory(
574
 
            this_ie.file_id, this_ie.name, this_ie.parent_id)
575
 
        self._invdelta[inv_path] = (inv_path, inv_path, this_ie.file_id,
576
 
            this_ie)
577
 
        return this_ie
578
 
 
579
 
    def _add_one_and_parent(self, parent_ie, path, kind, inv_path):
580
 
        """Add a new entry to the inventory and automatically add unversioned parents.
581
 
 
582
 
        :param parent_ie: Parent inventory entry if known, or None.  If
583
 
            None, the parent is looked up by name and used if present, otherwise it
584
 
            is recursively added.
585
 
        :param path: 
586
 
        :param kind: Kind of new entry (file, directory, etc)
587
 
        :param inv_path:
588
 
        :return: Inventory entry for path and a list of paths which have been added.
589
 
        """
590
 
        # Nothing to do if path is already versioned.
591
 
        # This is safe from infinite recursion because the tree root is
592
 
        # always versioned.
593
 
        inv_dirname = osutils.dirname(inv_path)
594
 
        dirname, basename = osutils.split(path)
595
 
        if parent_ie is None:
596
 
            # slower but does not need parent_ie
597
 
            this_ie = self._get_ie(inv_path)
598
 
            if this_ie is not None:
599
 
                return this_ie
600
 
            # its really not there : add the parent
601
 
            # note that the dirname use leads to some extra str copying etc but as
602
 
            # there are a limited number of dirs we can be nested under, it should
603
 
            # generally find it very fast and not recurse after that.
604
 
            parent_ie = self._add_one_and_parent(None,
605
 
                dirname, 'directory', 
606
 
                inv_dirname)
607
 
        # if the parent exists, but isn't a directory, we have to do the
608
 
        # kind change now -- really the inventory shouldn't pretend to know
609
 
        # the kind of wt files, but it does.
610
 
        if parent_ie.kind != 'directory':
611
 
            # nb: this relies on someone else checking that the path we're using
612
 
            # doesn't contain symlinks.
613
 
            parent_ie = self._convert_to_directory(parent_ie, inv_dirname)
614
 
        file_id = self.action(self.tree.inventory, parent_ie, path, kind)
615
 
        entry = _mod_inventory.make_entry(kind, basename, parent_ie.file_id,
616
 
            file_id=file_id)
617
 
        self._invdelta[inv_path] = (None, inv_path, entry.file_id, entry)
618
 
        self.added.append(inv_path)
619
 
        return entry
620
 
 
621
 
    def _gather_dirs_to_add(self, user_dirs):
622
 
        # only walk the minimal parents needed: we have user_dirs to override
623
 
        # ignores.
624
 
        prev_dir = None
625
 
 
626
 
        is_inside = osutils.is_inside_or_parent_of_any
627
 
        for path, (inv_path, this_ie) in sorted(
628
 
                user_dirs.iteritems(), key=operator.itemgetter(0)):
629
 
            if (prev_dir is None or not is_inside([prev_dir], path)):
630
 
                yield (path, inv_path, this_ie, None)
631
 
            prev_dir = path
632
 
        
633
 
    def __init__(self, tree, action, conflicts_related=None):
634
 
        self.tree = tree
635
 
        if action is None:
636
 
            self.action = add.AddAction()
637
 
        else:
638
 
            self.action = action
639
 
        self._invdelta = {}
640
 
        self.added = []
641
 
        self.ignored = {}
642
 
        if conflicts_related is None:
643
 
            self.conflicts_related = frozenset()
644
 
        else:
645
 
            self.conflicts_related = conflicts_related
646
 
 
647
 
    def add(self, file_list, recurse=True):
648
 
        from bzrlib.inventory import InventoryEntry
649
 
        if not file_list:
650
 
            # no paths supplied: add the entire tree.
651
 
            # FIXME: this assumes we are running in a working tree subdir :-/
652
 
            # -- vila 20100208
653
 
            file_list = [u'.']
654
 
 
655
 
        # expand any symlinks in the directory part, while leaving the
656
 
        # filename alone
657
 
        # only expanding if symlinks are supported avoids windows path bugs
658
 
        if osutils.has_symlinks():
659
 
            file_list = map(osutils.normalizepath, file_list)
660
 
 
661
 
        user_dirs = {}
662
 
        # validate user file paths and convert all paths to tree
663
 
        # relative : it's cheaper to make a tree relative path an abspath
664
 
        # than to convert an abspath to tree relative, and it's cheaper to
665
 
        # perform the canonicalization in bulk.
666
 
        for filepath in osutils.canonical_relpaths(self.tree.basedir, file_list):
667
 
            # validate user parameters. Our recursive code avoids adding new
668
 
            # files that need such validation
669
 
            if self.tree.is_control_filename(filepath):
670
 
                raise errors.ForbiddenControlFileError(filename=filepath)
671
 
 
672
 
            abspath = self.tree.abspath(filepath)
673
 
            kind = osutils.file_kind(abspath)
674
 
            # ensure the named path is added, so that ignore rules in the later
675
 
            # directory walk dont skip it.
676
 
            # we dont have a parent ie known yet.: use the relatively slower
677
 
            # inventory probing method
678
 
            inv_path, _ = osutils.normalized_filename(filepath)
679
 
            this_ie = self._get_ie(inv_path)
680
 
            if this_ie is None:
681
 
                this_ie = self._add_one_and_parent(None, filepath, kind, inv_path)
682
 
            if kind == 'directory':
683
 
                # schedule the dir for scanning
684
 
                user_dirs[filepath] = (inv_path, this_ie)
685
 
 
686
 
        if not recurse:
687
 
            # no need to walk any directories at all.
688
 
            return
689
 
 
690
 
        things_to_add = list(self._gather_dirs_to_add(user_dirs))
691
 
 
692
 
        illegalpath_re = re.compile(r'[\r\n]')
693
 
        for directory, inv_path, this_ie, parent_ie in things_to_add:
694
 
            # directory is tree-relative
695
 
            abspath = self.tree.abspath(directory)
696
 
 
697
 
            # get the contents of this directory.
698
 
 
699
 
            # find the kind of the path being added, and save stat_value
700
 
            # for reuse
701
 
            stat_value = None
702
 
            if this_ie is None:
703
 
                stat_value = osutils.file_stat(abspath)
704
 
                kind = osutils.file_kind_from_stat_mode(stat_value.st_mode)
705
 
            else:
706
 
                kind = this_ie.kind
707
 
            
708
 
            # allow AddAction to skip this file
709
 
            if self.action.skip_file(self.tree,  abspath,  kind,  stat_value):
710
 
                continue
711
 
            if not InventoryEntry.versionable_kind(kind):
712
 
                trace.warning("skipping %s (can't add file of kind '%s')",
713
 
                              abspath, kind)
714
 
                continue
715
 
            if illegalpath_re.search(directory):
716
 
                trace.warning("skipping %r (contains \\n or \\r)" % abspath)
717
 
                continue
718
 
            if directory in self.conflicts_related:
719
 
                # If the file looks like one generated for a conflict, don't
720
 
                # add it.
721
 
                trace.warning(
722
 
                    'skipping %s (generated to help resolve conflicts)',
723
 
                    abspath)
724
 
                continue
725
 
 
726
 
            if kind == 'directory' and directory != '':
727
 
                try:
728
 
                    transport = _mod_transport.get_transport_from_path(abspath)
729
 
                    controldir.ControlDirFormat.find_format(transport)
730
 
                    sub_tree = True
731
 
                except errors.NotBranchError:
732
 
                    sub_tree = False
733
 
                except errors.UnsupportedFormatError:
734
 
                    sub_tree = True
735
 
            else:
736
 
                sub_tree = False
737
 
 
738
 
            if this_ie is not None:
739
 
                pass
740
 
            elif sub_tree:
741
 
                # XXX: This is wrong; people *might* reasonably be trying to
742
 
                # add subtrees as subtrees.  This should probably only be done
743
 
                # in formats which can represent subtrees, and even then
744
 
                # perhaps only when the user asked to add subtrees.  At the
745
 
                # moment you can add them specially through 'join --reference',
746
 
                # which is perhaps reasonable: adding a new reference is a
747
 
                # special operation and can have a special behaviour.  mbp
748
 
                # 20070306
749
 
                trace.warning("skipping nested tree %r", abspath)
750
 
            else:
751
 
                this_ie = self._add_one_and_parent(parent_ie, directory, kind,
752
 
                    inv_path)
753
 
 
754
 
            if kind == 'directory' and not sub_tree:
755
 
                if this_ie.kind != 'directory':
756
 
                    this_ie = self._convert_to_directory(this_ie, inv_path)
757
 
 
758
 
                for subf in sorted(os.listdir(abspath)):
759
 
                    inv_f, _ = osutils.normalized_filename(subf)
760
 
                    # here we could use TreeDirectory rather than
761
 
                    # string concatenation.
762
 
                    subp = osutils.pathjoin(directory, subf)
763
 
                    # TODO: is_control_filename is very slow. Make it faster.
764
 
                    # TreeDirectory.is_control_filename could also make this
765
 
                    # faster - its impossible for a non root dir to have a
766
 
                    # control file.
767
 
                    if self.tree.is_control_filename(subp):
768
 
                        trace.mutter("skip control directory %r", subp)
769
 
                        continue
770
 
                    sub_invp = osutils.pathjoin(inv_path, inv_f)
771
 
                    entry = self._invdelta.get(sub_invp)
772
 
                    if entry is not None:
773
 
                        sub_ie = entry[3]
774
 
                    else:
775
 
                        sub_ie = this_ie.children.get(inv_f)
776
 
                    if sub_ie is not None:
777
 
                        # recurse into this already versioned subdir.
778
 
                        things_to_add.append((subp, sub_invp, sub_ie, this_ie))
779
 
                    else:
780
 
                        # user selection overrides ignores
781
 
                        # ignore while selecting files - if we globbed in the
782
 
                        # outer loop we would ignore user files.
783
 
                        ignore_glob = self.tree.is_ignored(subp)
784
 
                        if ignore_glob is not None:
785
 
                            self.ignored.setdefault(ignore_glob, []).append(subp)
786
 
                        else:
787
 
                            things_to_add.append((subp, sub_invp, None, this_ie))
 
680
class _FastPath(object):
 
681
    """A path object with fast accessors for things like basename."""
 
682
 
 
683
    __slots__ = ['raw_path', 'base_path']
 
684
 
 
685
    def __init__(self, path, base_path=None):
 
686
        """Construct a FastPath from path."""
 
687
        if base_path is None:
 
688
            self.base_path = osutils.basename(path)
 
689
        else:
 
690
            self.base_path = base_path
 
691
        self.raw_path = path
 
692
 
 
693
    def __cmp__(self, other):
 
694
        return cmp(self.raw_path, other.raw_path)
 
695
 
 
696
    def __hash__(self):
 
697
        return hash(self.raw_path)
 
698
 
 
699
 
 
700
def _add_one_and_parent(tree, inv, parent_ie, path, kind, action):
 
701
    """Add a new entry to the inventory and automatically add unversioned parents.
 
702
 
 
703
    :param inv: Inventory which will receive the new entry.
 
704
    :param parent_ie: Parent inventory entry if known, or None.  If
 
705
        None, the parent is looked up by name and used if present, otherwise it
 
706
        is recursively added.
 
707
    :param kind: Kind of new entry (file, directory, etc)
 
708
    :param action: callback(inv, parent_ie, path, kind); return ignored.
 
709
    :return: A list of paths which have been added.
 
710
    """
 
711
    # Nothing to do if path is already versioned.
 
712
    # This is safe from infinite recursion because the tree root is
 
713
    # always versioned.
 
714
    if parent_ie is not None:
 
715
        # we have a parent ie already
 
716
        added = []
 
717
    else:
 
718
        # slower but does not need parent_ie
 
719
        if inv.has_filename(tree._fix_case_of_inventory_path(path.raw_path)):
 
720
            return []
 
721
        # its really not there : add the parent
 
722
        # note that the dirname use leads to some extra str copying etc but as
 
723
        # there are a limited number of dirs we can be nested under, it should
 
724
        # generally find it very fast and not recurse after that.
 
725
        added = _add_one_and_parent(tree, inv, None,
 
726
            _FastPath(osutils.dirname(path.raw_path)), 'directory', action)
 
727
        parent_id = inv.path2id(osutils.dirname(path.raw_path))
 
728
        parent_ie = inv[parent_id]
 
729
    _add_one(tree, inv, parent_ie, path, kind, action)
 
730
    return added + [path.raw_path]
 
731
 
 
732
 
 
733
def _add_one(tree, inv, parent_ie, path, kind, file_id_callback):
 
734
    """Add a new entry to the inventory.
 
735
 
 
736
    :param inv: Inventory which will receive the new entry.
 
737
    :param parent_ie: Parent inventory entry.
 
738
    :param kind: Kind of new entry (file, directory, etc)
 
739
    :param file_id_callback: callback(inv, parent_ie, path, kind); return a
 
740
        file_id or None to generate a new file id
 
741
    :returns: None
 
742
    """
 
743
    file_id = file_id_callback(inv, parent_ie, path, kind)
 
744
    entry = inv.make_entry(kind, path.base_path, parent_ie.file_id,
 
745
        file_id=file_id)
 
746
    inv.add(entry)