« back to all changes in this revision
Viewing changes to bzrlib/mutabletree.py
- browse files at revision 5952
- compare with another revision
- compare with revision 5952.1.23
- download diff
- download tarball
- view history from revision 5952
- Committer: Canonical.com Patch Queue Manager
- Date: 2011-06-01 14:59:16 UTC
- mfrom: (5870.1.44 smart-add-invdelta)
- Revision ID: pqm@pqm.ubuntu.com-20110601145916-5uuwhu9e764po62d
(jelmer) (jelmer) Bug #146165,
use apply_inventory_delta instead of _write_inventory for 'bzr add'" (Jelmer
Vernooij)
use apply_inventory_delta instead of _write_inventory for 'bzr add'" (Jelmer
Vernooij)
added
removed
bzrlib/mutabletree.py
22
22
23
23
from bzrlib.lazy_import import lazy_import
24
24
lazy_import(globals(), """
25
import operator
25
26
import os
26
27
import re
27
28
28
29
from bzrlib import (
29
30
add,
30
bzrdir,
31
controldir,
31
32
errors,
32
33
hooks,
33
34
inventory as _mod_inventory,
34
35
osutils,
35
36
revisiontree,
36
37
trace,
38
transport as _mod_transport,
37
39
tree,
38
40
)
39
41
""")
392
394
"""
393
395
raise NotImplementedError(self.smart_add)
394
396
395
def update_basis_by_delta(self, new_revid, delta):
396
"""Update the parents of this tree after a commit.
397
398
This gives the tree one parent, with revision id new_revid. The
399
inventory delta is applied to the current basis tree to generate the
400
inventory for the parent new_revid, and all other parent trees are
401
discarded.
402
403
All the changes in the delta should be changes synchronising the basis
404
tree with some or all of the working tree, with a change to a directory
405
requiring that its contents have been recursively included. That is,
406
this is not a general purpose tree modification routine, but a helper
407
for commit which is not required to handle situations that do not arise
408
outside of commit.
409
410
See the inventory developers documentation for the theory behind
411
inventory deltas.
412
413
:param new_revid: The new revision id for the trees parent.
414
:param delta: An inventory delta (see apply_inventory_delta) describing
415
the changes from the current left most parent revision to new_revid.
416
"""
417
raise NotImplementedError(self.update_basis_by_delta)
418
419
420
class MutableInventoryTree(MutableTree,tree.InventoryTree):
397
398
class MutableInventoryTree(MutableTree, tree.InventoryTree):
421
399
422
400
@needs_tree_write_lock
423
401
def apply_inventory_delta(self, changes):
460
438
of added files, and ignored_files is a dict mapping files that were
461
439
ignored to the rule that caused them to be ignored.
462
440
"""
463
# not in an inner loop; and we want to remove direct use of this,
464
# so here as a reminder for now. RBC 20070703
465
from bzrlib.inventory import InventoryEntry
466
if action is None:
467
action = add.AddAction()
468
469
if not file_list:
470
# no paths supplied: add the entire tree.
471
# FIXME: this assumes we are running in a working tree subdir :-/
472
# -- vila 20100208
473
file_list = [u'.']
474
# mutter("smart add of %r")
475
inv = self.inventory
476
added = []
477
ignored = {}
478
dirs_to_add = []
479
user_dirs = set()
480
conflicts_related = set()
481
441
# Not all mutable trees can have conflicts
482
442
if getattr(self, 'conflicts', None) is not None:
483
443
# Collect all related files without checking whether they exist or
484
444
# are versioned. It's cheaper to do that once for all conflicts
485
445
# than trying to find the relevant conflict for each added file.
446
conflicts_related = set()
486
447
for c in self.conflicts():
487
448
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
457
458
def update_basis_by_delta(self, new_revid, delta):
459
"""Update the parents of this tree after a commit.
460
461
This gives the tree one parent, with revision id new_revid. The
462
inventory delta is applied to the current basis tree to generate the
463
inventory for the parent new_revid, and all other parent trees are
464
discarded.
465
466
All the changes in the delta should be changes synchronising the basis
467
tree with some or all of the working tree, with a change to a directory
468
requiring that its contents have been recursively included. That is,
469
this is not a general purpose tree modification routine, but a helper
470
for commit which is not required to handle situations that do not arise
471
outside of commit.
472
473
See the inventory developers documentation for the theory behind
474
inventory deltas.
475
476
:param new_revid: The new revision id for the trees parent.
477
:param delta: An inventory delta (see apply_inventory_delta) describing
478
the changes from the current left most parent revision to new_revid.
479
"""
480
# if the tree is updated by a pull to the branch, as happens in
481
# WorkingTree2, when there was no separation between branch and tree,
482
# then just clear merges, efficiency is not a concern for now as this
483
# is legacy environments only, and they are slow regardless.
484
if self.last_revision() == new_revid:
485
self.set_parent_ids([new_revid])
486
return
487
# generic implementation based on Inventory manipulation. See
488
# WorkingTree classes for optimised versions for specific format trees.
489
basis = self.basis_tree()
490
basis.lock_read()
491
# TODO: Consider re-evaluating the need for this with CHKInventory
492
# we don't strictly need to mutate an inventory for this
493
# it only makes sense when apply_delta is cheaper than get_inventory()
494
inventory = _mod_inventory.mutable_inventory_from_tree(basis)
495
basis.unlock()
496
inventory.apply_delta(delta)
497
rev_tree = revisiontree.InventoryRevisionTree(self.branch.repository,
498
inventory, new_revid)
499
self.set_parent_trees([(new_revid, rev_tree)])
500
501
502
class MutableTreeHooks(hooks.Hooks):
503
"""A dictionary mapping a hook name to a list of callables for mutabletree
504
hooks.
505
"""
506
507
def __init__(self):
508
"""Create the default hooks.
509
510
"""
511
hooks.Hooks.__init__(self, "bzrlib.mutabletree", "MutableTree.hooks")
512
self.add_hook('start_commit',
513
"Called before a commit is performed on a tree. The start commit "
514
"hook is able to change the tree before the commit takes place. "
515
"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',
518
"Called after a commit is performed on a tree. The hook is "
519
"called with a bzrlib.mutabletree.PostCommitHookParams object. "
520
"The mutable tree the commit was performed on is available via "
521
"the mutable_tree attribute of that object.", (2, 0))
522
523
524
# install the default hooks into the MutableTree class.
525
MutableTree.hooks = MutableTreeHooks()
526
527
528
class PostCommitHookParams(object):
529
"""Parameters for the post_commit hook.
530
531
To access the parameters, use the following attributes:
532
533
* mutable_tree - the MutableTree object
534
"""
535
536
def __init__(self, mutable_tree):
537
"""Create the parameters for the post_commit hook."""
538
self.mutable_tree = mutable_tree
539
540
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
file_id = self.tree.path2id(inv_path)
558
if file_id is not None:
559
return self.tree.iter_entries_by_dir([file_id]).next()[1]
560
return None
561
562
def _convert_to_directory(self, this_ie, inv_path):
563
"""Convert an entry to a directory.
564
565
:param this_ie: Inventory entry
566
:param inv_path: Normalized path for the inventory entry
567
:return: The new inventory entry
568
"""
569
# Same as in _add_one below, if the inventory doesn't
570
# think this is a directory, update the inventory
571
this_ie = _mod_inventory.InventoryDirectory(
572
this_ie.file_id, this_ie.name, this_ie.parent_id)
573
self._invdelta[inv_path] = (inv_path, inv_path, this_ie.file_id,
574
this_ie)
575
return this_ie
576
577
def _add_one_and_parent(self, parent_ie, path, kind, inv_path):
578
"""Add a new entry to the inventory and automatically add unversioned parents.
579
580
:param parent_ie: Parent inventory entry if known, or None. If
581
None, the parent is looked up by name and used if present, otherwise it
582
is recursively added.
583
:param kind: Kind of new entry (file, directory, etc)
584
:param action: callback(tree, parent_ie, path, kind); can return file_id
585
:return: Inventory entry for path and a list of paths which have been added.
586
"""
587
# Nothing to do if path is already versioned.
588
# This is safe from infinite recursion because the tree root is
589
# always versioned.
590
inv_dirname = osutils.dirname(inv_path)
591
dirname, basename = osutils.split(path)
592
if parent_ie is None:
593
# slower but does not need parent_ie
594
this_ie = self._get_ie(inv_path)
595
if this_ie is not None:
596
return this_ie
597
# its really not there : add the parent
598
# note that the dirname use leads to some extra str copying etc but as
599
# there are a limited number of dirs we can be nested under, it should
600
# generally find it very fast and not recurse after that.
601
parent_ie = self._add_one_and_parent(None,
602
dirname, 'directory',
603
inv_dirname)
604
# if the parent exists, but isn't a directory, we have to do the
605
# kind change now -- really the inventory shouldn't pretend to know
606
# the kind of wt files, but it does.
607
if parent_ie.kind != 'directory':
608
# nb: this relies on someone else checking that the path we're using
609
# doesn't contain symlinks.
610
parent_ie = self._convert_to_directory(parent_ie, inv_dirname)
611
file_id = self.action(self.tree.inventory, parent_ie, path, kind)
612
entry = _mod_inventory.make_entry(kind, basename, parent_ie.file_id,
613
file_id=file_id)
614
self._invdelta[inv_path] = (None, inv_path, entry.file_id, entry)
615
self.added.append(inv_path)
616
return entry
617
618
def _gather_dirs_to_add(self, user_dirs):
619
# only walk the minimal parents needed: we have user_dirs to override
620
# ignores.
621
prev_dir = None
622
623
is_inside = osutils.is_inside_or_parent_of_any
624
for path, (inv_path, this_ie) in sorted(
625
user_dirs.iteritems(), key=operator.itemgetter(0)):
626
if (prev_dir is None or not is_inside([prev_dir], path)):
627
yield (path, inv_path, this_ie, None)
628
prev_dir = path
629
630
def __init__(self, tree, action, conflicts_related=None):
631
self.tree = tree
632
if action is None:
633
self.action = add.AddAction()
634
else:
635
self.action = action
636
self._invdelta = {}
637
self.added = []
638
self.ignored = {}
639
if conflicts_related is None:
640
self.conflicts_related = frozenset()
641
else:
642
self.conflicts_related = conflicts_related
643
644
def add(self, file_list, recurse=True):
645
from bzrlib.inventory import InventoryEntry
646
if not file_list:
647
# no paths supplied: add the entire tree.
648
# FIXME: this assumes we are running in a working tree subdir :-/
649
# -- vila 20100208
650
file_list = [u'.']
488
651
489
652
# expand any symlinks in the directory part, while leaving the
490
653
# filename alone
492
655
if osutils.has_symlinks():
493
656
file_list = map(osutils.normalizepath, file_list)
494
657
658
user_dirs = {}
495
659
# validate user file paths and convert all paths to tree
496
660
# relative : it's cheaper to make a tree relative path an abspath
497
661
# than to convert an abspath to tree relative, and it's cheaper to
498
662
# perform the canonicalization in bulk.
499
for filepath in osutils.canonical_relpaths(self.basedir, file_list):
500
rf = _FastPath(filepath)
663
for filepath in osutils.canonical_relpaths(self.tree.basedir, file_list):
501
664
# validate user parameters. Our recursive code avoids adding new
502
665
# files that need such validation
503
if self.is_control_filename(rf.raw_path):
504
raise errors.ForbiddenControlFileError(filename=rf.raw_path)
666
if self.tree.is_control_filename(filepath):
667
raise errors.ForbiddenControlFileError(filename=filepath)
505
668
506
abspath = self.abspath(rf.raw_path)
669
abspath = self.tree.abspath(filepath)
507
670
kind = osutils.file_kind(abspath)
508
if kind == 'directory':
509
# schedule the dir for scanning
510
user_dirs.add(rf)
511
else:
512
if not InventoryEntry.versionable_kind(kind):
513
raise errors.BadFileKindError(filename=abspath, kind=kind)
514
671
# ensure the named path is added, so that ignore rules in the later
515
672
# directory walk dont skip it.
516
673
# we dont have a parent ie known yet.: use the relatively slower
517
674
# inventory probing method
518
versioned = inv.has_filename(rf.raw_path)
519
if versioned:
520
continue
521
added.extend(_add_one_and_parent(self, inv, None, rf, kind, action))
675
inv_path, _ = osutils.normalized_filename(filepath)
676
this_ie = self._get_ie(inv_path)
677
if this_ie is None:
678
this_ie = self._add_one_and_parent(None, filepath, kind, inv_path)
679
if kind == 'directory':
680
# schedule the dir for scanning
681
user_dirs[filepath] = (inv_path, this_ie)
522
682
523
683
if not recurse:
524
684
# no need to walk any directories at all.
525
if len(added) > 0 and save:
526
self._write_inventory(inv)
527
return added, ignored
528
529
# only walk the minimal parents needed: we have user_dirs to override
530
# ignores.
531
prev_dir = None
532
533
is_inside = osutils.is_inside_or_parent_of_any
534
for path in sorted(user_dirs):
535
if (prev_dir is None or not is_inside([prev_dir], path.raw_path)):
536
dirs_to_add.append((path, None))
537
prev_dir = path.raw_path
685
return
686
687
things_to_add = list(self._gather_dirs_to_add(user_dirs))
538
688
539
689
illegalpath_re = re.compile(r'[\r\n]')
540
# dirs_to_add is initialised to a list of directories, but as we scan
541
# directories we append files to it.
542
# XXX: We should determine kind of files when we scan them rather than
543
# adding to this list. RBC 20070703
544
for directory, parent_ie in dirs_to_add:
690
for directory, inv_path, this_ie, parent_ie in things_to_add:
545
691
# directory is tree-relative
546
abspath = self.abspath(directory.raw_path)
692
abspath = self.tree.abspath(directory)
547
693
548
694
# get the contents of this directory.
549
695
550
696
# find the kind of the path being added.
551
kind = osutils.file_kind(abspath)
697
if this_ie is None:
698
kind = osutils.file_kind(abspath)
699
else:
700
kind = this_ie.kind
552
701
553
702
if not InventoryEntry.versionable_kind(kind):
554
703
trace.warning("skipping %s (can't add file of kind '%s')",
555
704
abspath, kind)
556
705
continue
557
if illegalpath_re.search(directory.raw_path):
706
if illegalpath_re.search(directory):
558
707
trace.warning("skipping %r (contains \\n or \\r)" % abspath)
559
708
continue
560
if directory.raw_path in conflicts_related:
709
if directory in self.conflicts_related:
561
710
# If the file looks like one generated for a conflict, don't
562
711
# add it.
563
712
trace.warning(
565
714
abspath)
566
715
continue
567
716
568
if parent_ie is not None:
569
versioned = directory.base_path in parent_ie.children
570
else:
571
# without the parent ie, use the relatively slower inventory
572
# probing method
573
versioned = inv.has_filename(
574
self._fix_case_of_inventory_path(directory.raw_path))
575
576
if kind == 'directory':
717
if kind == 'directory' and directory != '':
577
718
try:
578
sub_branch = bzrdir.BzrDir.open(abspath)
719
transport = _mod_transport.get_transport(abspath)
720
controldir.ControlDirFormat.find_format(transport)
579
721
sub_tree = True
580
722
except errors.NotBranchError:
581
723
sub_tree = False
584
726
else:
585
727
sub_tree = False
586
728
587
if directory.raw_path == '':
588
# mutter("tree root doesn't need to be added")
589
sub_tree = False
590
elif versioned:
729
if this_ie is not None:
591
730
pass
592
# mutter("%r is already versioned", abspath)
593
731
elif sub_tree:
594
732
# XXX: This is wrong; people *might* reasonably be trying to
595
733
# add subtrees as subtrees. This should probably only be done
601
739
# 20070306
602
740
trace.mutter("%r is a nested bzr tree", abspath)
603
741
else:
604
_add_one(self, inv, parent_ie, directory, kind, action)
605
added.append(directory.raw_path)
742
this_ie = self._add_one_and_parent(parent_ie, directory, kind, inv_path)
606
743
607
744
if kind == 'directory' and not sub_tree:
608
if parent_ie is not None:
609
# must be present:
610
this_ie = parent_ie.children[directory.base_path]
611
else:
612
# without the parent ie, use the relatively slower inventory
613
# probing method
614
this_id = inv.path2id(
615
self._fix_case_of_inventory_path(directory.raw_path))
616
if this_id is None:
617
this_ie = None
618
else:
619
this_ie = inv[this_id]
620
# Same as in _add_one below, if the inventory doesn't
621
# think this is a directory, update the inventory
622
if this_ie.kind != 'directory':
623
this_ie = _mod_inventory.make_entry('directory',
624
this_ie.name, this_ie.parent_id, this_id)
625
del inv[this_id]
626
inv.add(this_ie)
745
if this_ie.kind != 'directory':
746
this_ie = self._convert_to_directory(this_ie, inv_path)
627
747
628
748
for subf in sorted(os.listdir(abspath)):
749
inv_f, _ = osutils.normalized_filename(subf)
629
750
# here we could use TreeDirectory rather than
630
751
# string concatenation.
631
subp = osutils.pathjoin(directory.raw_path, subf)
752
subp = osutils.pathjoin(directory, subf)
632
753
# TODO: is_control_filename is very slow. Make it faster.
633
754
# TreeDirectory.is_control_filename could also make this
634
755
# faster - its impossible for a non root dir to have a
635
756
# control file.
636
if self.is_control_filename(subp):
757
if self.tree.is_control_filename(subp):
637
758
trace.mutter("skip control directory %r", subp)
638
elif subf in this_ie.children:
759
continue
760
sub_invp = osutils.pathjoin(inv_path, inv_f)
761
entry = self._invdelta.get(sub_invp)
762
if entry is not None:
763
sub_ie = entry[3]
764
else:
765
sub_ie = this_ie.children.get(inv_f)
766
if sub_ie is not None:
639
767
# recurse into this already versioned subdir.
640
dirs_to_add.append((_FastPath(subp, subf), this_ie))
768
things_to_add.append((subp, sub_invp, sub_ie, this_ie))
641
769
else:
642
770
# user selection overrides ignoes
643
771
# ignore while selecting files - if we globbed in the
644
772
# outer loop we would ignore user files.
645
ignore_glob = self.is_ignored(subp)
773
ignore_glob = self.tree.is_ignored(subp)
646
774
if ignore_glob is not None:
647
# mutter("skip ignored sub-file %r", subp)
648
ignored.setdefault(ignore_glob, []).append(subp)
775
self.ignored.setdefault(ignore_glob, []).append(subp)
649
776
else:
650
#mutter("queue to add sub-file %r", subp)
651
dirs_to_add.append((_FastPath(subp, subf), this_ie))
652
653
if len(added) > 0:
654
if save:
655
self._write_inventory(inv)
656
else:
657
self.read_working_inventory()
658
return added, ignored
659
660
def update_basis_by_delta(self, new_revid, delta):
661
"""Update the parents of this tree after a commit.
662
663
This gives the tree one parent, with revision id new_revid. The
664
inventory delta is applied to the current basis tree to generate the
665
inventory for the parent new_revid, and all other parent trees are
666
discarded.
667
668
All the changes in the delta should be changes synchronising the basis
669
tree with some or all of the working tree, with a change to a directory
670
requiring that its contents have been recursively included. That is,
671
this is not a general purpose tree modification routine, but a helper
672
for commit which is not required to handle situations that do not arise
673
outside of commit.
674
675
See the inventory developers documentation for the theory behind
676
inventory deltas.
677
678
:param new_revid: The new revision id for the trees parent.
679
:param delta: An inventory delta (see apply_inventory_delta) describing
680
the changes from the current left most parent revision to new_revid.
681
"""
682
# if the tree is updated by a pull to the branch, as happens in
683
# WorkingTree2, when there was no separation between branch and tree,
684
# then just clear merges, efficiency is not a concern for now as this
685
# is legacy environments only, and they are slow regardless.
686
if self.last_revision() == new_revid:
687
self.set_parent_ids([new_revid])
688
return
689
# generic implementation based on Inventory manipulation. See
690
# WorkingTree classes for optimised versions for specific format trees.
691
basis = self.basis_tree()
692
basis.lock_read()
693
# TODO: Consider re-evaluating the need for this with CHKInventory
694
# we don't strictly need to mutate an inventory for this
695
# it only makes sense when apply_delta is cheaper than get_inventory()
696
inventory = _mod_inventory.mutable_inventory_from_tree(basis)
697
basis.unlock()
698
inventory.apply_delta(delta)
699
rev_tree = revisiontree.InventoryRevisionTree(self.branch.repository,
700
inventory, new_revid)
701
self.set_parent_trees([(new_revid, rev_tree)])
702
703
704
class MutableTreeHooks(hooks.Hooks):
705
"""A dictionary mapping a hook name to a list of callables for mutabletree
706
hooks.
707
"""
708
709
def __init__(self):
710
"""Create the default hooks.
711
712
"""
713
hooks.Hooks.__init__(self, "bzrlib.mutabletree", "MutableTree.hooks")
714
self.add_hook('start_commit',
715
"Called before a commit is performed on a tree. The start commit "
716
"hook is able to change the tree before the commit takes place. "
717
"start_commit is called with the bzrlib.mutabletree.MutableTree "
718
"that the commit is being performed on.", (1, 4))
719
self.add_hook('post_commit',
720
"Called after a commit is performed on a tree. The hook is "
721
"called with a bzrlib.mutabletree.PostCommitHookParams object. "
722
"The mutable tree the commit was performed on is available via "
723
"the mutable_tree attribute of that object.", (2, 0))
724
725
726
# install the default hooks into the MutableTree class.
727
MutableTree.hooks = MutableTreeHooks()
728
729
730
class PostCommitHookParams(object):
731
"""Parameters for the post_commit hook.
732
733
To access the parameters, use the following attributes:
734
735
* mutable_tree - the MutableTree object
736
"""
737
738
def __init__(self, mutable_tree):
739
"""Create the parameters for the post_commit hook."""
740
self.mutable_tree = mutable_tree
741
742
743
class _FastPath(object):
744
"""A path object with fast accessors for things like basename."""
745
746
__slots__ = ['raw_path', 'base_path']
747
748
def __init__(self, path, base_path=None):
749
"""Construct a FastPath from path."""
750
if base_path is None:
751
self.base_path = osutils.basename(path)
752
else:
753
self.base_path = base_path
754
self.raw_path = path
755
756
def __cmp__(self, other):
757
return cmp(self.raw_path, other.raw_path)
758
759
def __hash__(self):
760
return hash(self.raw_path)
761
762
763
def _add_one_and_parent(tree, inv, parent_ie, path, kind, action):
764
"""Add a new entry to the inventory and automatically add unversioned parents.
765
766
:param inv: Inventory which will receive the new entry.
767
:param parent_ie: Parent inventory entry if known, or None. If
768
None, the parent is looked up by name and used if present, otherwise it
769
is recursively added.
770
:param kind: Kind of new entry (file, directory, etc)
771
:param action: callback(inv, parent_ie, path, kind); return ignored.
772
:return: A list of paths which have been added.
773
"""
774
# Nothing to do if path is already versioned.
775
# This is safe from infinite recursion because the tree root is
776
# always versioned.
777
if parent_ie is not None:
778
# we have a parent ie already
779
added = []
780
else:
781
# slower but does not need parent_ie
782
if inv.has_filename(tree._fix_case_of_inventory_path(path.raw_path)):
783
return []
784
# its really not there : add the parent
785
# note that the dirname use leads to some extra str copying etc but as
786
# there are a limited number of dirs we can be nested under, it should
787
# generally find it very fast and not recurse after that.
788
added = _add_one_and_parent(tree, inv, None,
789
_FastPath(osutils.dirname(path.raw_path)), 'directory', action)
790
parent_id = inv.path2id(osutils.dirname(path.raw_path))
791
parent_ie = inv[parent_id]
792
_add_one(tree, inv, parent_ie, path, kind, action)
793
return added + [path.raw_path]
794
795
796
def _add_one(tree, inv, parent_ie, path, kind, file_id_callback):
797
"""Add a new entry to the inventory.
798
799
:param inv: Inventory which will receive the new entry.
800
:param parent_ie: Parent inventory entry.
801
:param kind: Kind of new entry (file, directory, etc)
802
:param file_id_callback: callback(inv, parent_ie, path, kind); return a
803
file_id or None to generate a new file id
804
:returns: None
805
"""
806
# if the parent exists, but isn't a directory, we have to do the
807
# kind change now -- really the inventory shouldn't pretend to know
808
# the kind of wt files, but it does.
809
if parent_ie.kind != 'directory':
810
# nb: this relies on someone else checking that the path we're using
811
# doesn't contain symlinks.
812
new_parent_ie = _mod_inventory.make_entry('directory', parent_ie.name,
813
parent_ie.parent_id, parent_ie.file_id)
814
del inv[parent_ie.file_id]
815
inv.add(new_parent_ie)
816
parent_ie = new_parent_ie
817
file_id = file_id_callback(inv, parent_ie, path, kind)
818
entry = inv.make_entry(kind, path.base_path, parent_ie.file_id,
819
file_id=file_id)
820
inv.add(entry)
777
things_to_add.append((subp, sub_invp, None, this_ie))
Loggerhead is a web-based interface for Breezy
Version: 2.0.1