90
79
>>> i.add(InventoryDirectory('123', 'src', ROOT_ID))
91
InventoryDirectory('123', 'src', parent_id='TREE_ROOT', revision=None)
80
InventoryDirectory('123', 'src', parent_id='TREE_ROOT')
92
81
>>> i.add(InventoryFile('2323', 'hello.c', parent_id='123'))
93
InventoryFile('2323', 'hello.c', parent_id='123', sha1=None, len=None)
94
>>> shouldbe = {0: '', 1: 'src', 2: 'src/hello.c'}
82
InventoryFile('2323', 'hello.c', parent_id='123')
83
>>> shouldbe = {0: 'src', 1: pathjoin('src','hello.c')}
95
84
>>> for ix, j in enumerate(i.iter_entries()):
96
85
... print (j[0] == shouldbe[ix], j[1])
98
(True, InventoryDirectory('TREE_ROOT', u'', parent_id=None, revision=None))
99
(True, InventoryDirectory('123', 'src', parent_id='TREE_ROOT', revision=None))
100
(True, InventoryFile('2323', 'hello.c', parent_id='123', sha1=None, len=None))
87
(True, InventoryDirectory('123', 'src', parent_id='TREE_ROOT'))
88
(True, InventoryFile('2323', 'hello.c', parent_id='123'))
89
>>> i.add(InventoryFile('2323', 'bye.c', '123'))
90
Traceback (most recent call last):
92
BzrError: inventory already contains entry with id {2323}
101
93
>>> i.add(InventoryFile('2324', 'bye.c', '123'))
102
InventoryFile('2324', 'bye.c', parent_id='123', sha1=None, len=None)
94
InventoryFile('2324', 'bye.c', parent_id='123')
103
95
>>> i.add(InventoryDirectory('2325', 'wibble', '123'))
104
InventoryDirectory('2325', 'wibble', parent_id='123', revision=None)
96
InventoryDirectory('2325', 'wibble', parent_id='123')
105
97
>>> i.path2id('src/wibble')
109
101
>>> i.add(InventoryFile('2326', 'wibble.c', '2325'))
110
InventoryFile('2326', 'wibble.c', parent_id='2325', sha1=None, len=None)
102
InventoryFile('2326', 'wibble.c', parent_id='2325')
112
InventoryFile('2326', 'wibble.c', parent_id='2325', sha1=None, len=None)
104
InventoryFile('2326', 'wibble.c', parent_id='2325')
113
105
>>> for path, entry in i.iter_entries():
107
... assert i.path2id(path)
142
142
return False, False
144
def diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
145
output_to, reverse=False):
146
"""Perform a diff from this to to_entry.
148
text_diff will be used for textual difference calculation.
149
This is a template method, override _diff in child classes.
151
self._read_tree_state(tree.id2path(self.file_id), tree)
153
# cannot diff from one kind to another - you must do a removal
154
# and an addif they do not match.
155
assert self.kind == to_entry.kind
156
to_entry._read_tree_state(to_tree.id2path(to_entry.file_id),
158
self._diff(text_diff, from_label, tree, to_label, to_entry, to_tree,
144
161
def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
145
162
output_to, reverse=False):
146
163
"""Perform a diff between two entries of the same kind."""
148
def parent_candidates(self, previous_inventories):
149
"""Find possible per-file graph parents.
151
This is currently defined by:
152
- Select the last changed revision in the parent inventory.
153
- Do deal with a short lived bug in bzr 0.8's development two entries
154
that have the same last changed but different 'x' bit settings are
165
def find_previous_heads(self, previous_inventories,
166
versioned_file_store,
169
"""Return the revisions and entries that directly preceed this.
171
Returned as a map from revision to inventory entry.
173
This is a map containing the file revisions in all parents
174
for which the file exists, and its revision is not a parent of
175
any other. If the file is new, the set will be empty.
177
:param versioned_file_store: A store where ancestry data on this
178
file id can be queried.
179
:param transaction: The transaction that queries to the versioned
180
file store should be completed under.
181
:param entry_vf: The entry versioned file, if its already available.
183
def get_ancestors(weave, entry):
184
return set(weave.get_ancestry(entry.revision))
157
185
# revision:ie mapping for each ie found in previous_inventories.
187
# revision:ie mapping with one revision for each head.
189
# revision: ancestor list for each head
159
191
# identify candidate head revision ids.
160
192
for inv in previous_inventories:
161
193
if self.file_id in inv:
162
194
ie = inv[self.file_id]
195
assert ie.file_id == self.file_id
163
196
if ie.revision in candidates:
164
197
# same revision value in two different inventories:
165
198
# correct possible inconsistencies:
171
204
ie.executable = False
172
205
except AttributeError:
207
# must now be the same.
208
assert candidates[ie.revision] == ie
175
210
# add this revision as a candidate.
176
211
candidates[ie.revision] = ie
179
@deprecated_method(deprecated_in((1, 6, 0)))
213
# common case optimisation
214
if len(candidates) == 1:
215
# if there is only one candidate revision found
216
# then we can opening the versioned file to access ancestry:
217
# there cannot be any ancestors to eliminate when there is
218
# only one revision available.
219
heads[ie.revision] = ie
222
# eliminate ancestors amongst the available candidates:
223
# heads are those that are not an ancestor of any other candidate
224
# - this provides convergence at a per-file level.
225
for ie in candidates.values():
226
# may be an ancestor of a known head:
227
already_present = 0 != len(
228
[head for head in heads
229
if ie.revision in head_ancestors[head]])
231
# an ancestor of an analyzed candidate.
233
# not an ancestor of a known head:
234
# load the versioned file for this file id if needed
236
entry_vf = versioned_file_store.get_weave_or_empty(
237
self.file_id, transaction)
238
ancestors = get_ancestors(entry_vf, ie)
239
# may knock something else out:
240
check_heads = list(heads.keys())
241
for head in check_heads:
242
if head in ancestors:
243
# this previously discovered 'head' is not
244
# really a head - its an ancestor of the newly
247
head_ancestors[ie.revision] = ancestors
248
heads[ie.revision] = ie
180
251
def get_tar_item(self, root, dp, now, tree):
181
252
"""Get a tarfile item and a file stream for its content."""
182
item = tarfile.TarInfo(osutils.pathjoin(root, dp).encode('utf8'))
253
item = tarfile.TarInfo(pathjoin(root, dp))
183
254
# TODO: would be cool to actually set it to the timestamp of the
184
255
# revision it was last changed
239
310
raise BzrError("don't know how to export {%s} of kind %r" %
240
311
(self.file_id, self.kind))
242
@deprecated_method(deprecated_in((1, 6, 0)))
243
313
def put_on_disk(self, dest, dp, tree):
244
314
"""Create a representation of self on disk in the prefix dest.
246
316
This is a template method - implement _put_on_disk in subclasses.
248
fullpath = osutils.pathjoin(dest, dp)
318
fullpath = pathjoin(dest, dp)
249
319
self._put_on_disk(fullpath, tree)
250
# mutter(" export {%s} kind %s to %s", self.file_id,
251
# self.kind, fullpath)
320
mutter(" export {%s} kind %s to %s", self.file_id,
253
323
def _put_on_disk(self, fullpath, tree):
254
324
"""Put this entry onto disk at fullpath, from tree tree."""
255
325
raise BzrError("don't know how to export {%s} of kind %r" % (self.file_id, self.kind))
257
327
def sorted_children(self):
258
return sorted(self.children.items())
328
l = self.children.items()
261
333
def versionable_kind(kind):
262
return (kind in ('file', 'directory', 'symlink', 'tree-reference'))
334
return kind in ('file', 'directory', 'symlink')
264
336
def check(self, checker, rev_id, inv, tree):
265
337
"""Check this inventory entry is intact.
333
403
return 'unchanged'
335
405
def __repr__(self):
336
return ("%s(%r, %r, parent_id=%r, revision=%r)"
406
return ("%s(%r, %r, parent_id=%r)"
337
407
% (self.__class__.__name__,
412
def snapshot(self, revision, path, previous_entries,
413
work_tree, weave_store, transaction):
414
"""Make a snapshot of this entry which may or may not have changed.
416
This means that all its fields are populated, that it has its
417
text stored in the text store or weave.
419
mutter('new parents of %s are %r', path, previous_entries)
420
self._read_tree_state(path, work_tree)
421
if len(previous_entries) == 1:
422
# cannot be unchanged unless there is only one parent file rev.
423
parent_ie = previous_entries.values()[0]
424
if self._unchanged(parent_ie):
425
mutter("found unchanged entry")
426
self.revision = parent_ie.revision
428
return self._snapshot_into_revision(revision, previous_entries,
429
work_tree, weave_store, transaction)
431
def _snapshot_into_revision(self, revision, previous_entries, work_tree,
432
weave_store, transaction):
433
"""Record this revision unconditionally into a store.
435
The entry's last-changed revision property (`revision`) is updated to
436
that of the new revision.
438
:param revision: id of the new revision that is being recorded.
440
:returns: String description of the commit (e.g. "merged", "modified"), etc.
442
mutter('new revision {%s} for {%s}', revision, self.file_id)
443
self.revision = revision
444
self._snapshot_text(previous_entries, work_tree, weave_store,
447
def _snapshot_text(self, file_parents, work_tree, weave_store, transaction):
448
"""Record the 'text' of this entry, whatever form that takes.
450
This default implementation simply adds an empty text.
452
mutter('storing file {%s} in revision {%s}',
453
self.file_id, self.revision)
454
self._add_text_to_weave([], file_parents.keys(), weave_store, transaction)
343
456
def __eq__(self, other):
344
457
if not isinstance(other, InventoryEntry):
397
507
class RootEntry(InventoryEntry):
399
__slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
400
'text_id', 'parent_id', 'children', 'executable',
401
'revision', 'symlink_target', 'reference_revision']
403
509
def _check(self, checker, rev_id, tree):
404
510
"""See InventoryEntry._check"""
406
512
def __init__(self, file_id):
407
513
self.file_id = file_id
408
514
self.children = {}
409
self.kind = 'directory'
515
self.kind = 'root_directory'
410
516
self.parent_id = None
413
symbol_versioning.warn('RootEntry is deprecated as of bzr 0.10.'
414
' Please use InventoryDirectory instead.',
415
DeprecationWarning, stacklevel=2)
417
519
def __eq__(self, other):
418
520
if not isinstance(other, RootEntry):
425
527
class InventoryDirectory(InventoryEntry):
426
528
"""A directory in an inventory."""
428
__slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
429
'text_id', 'parent_id', 'children', 'executable',
430
'revision', 'symlink_target', 'reference_revision']
432
530
def _check(self, checker, rev_id, tree):
433
531
"""See InventoryEntry._check"""
434
if self.text_sha1 is not None or self.text_size is not None or self.text_id is not None:
532
if self.text_sha1 != None or self.text_size != None or self.text_id != None:
435
533
raise BzrCheckError('directory {%s} has text in revision {%s}'
436
534
% (self.file_id, rev_id))
468
566
class InventoryFile(InventoryEntry):
469
567
"""A file in an inventory."""
471
__slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
472
'text_id', 'parent_id', 'children', 'executable',
473
'revision', 'symlink_target', 'reference_revision']
475
569
def _check(self, checker, tree_revision_id, tree):
476
570
"""See InventoryEntry._check"""
477
key = (self.file_id, self.revision)
478
if key in checker.checked_texts:
479
prev_sha = checker.checked_texts[key]
571
t = (self.file_id, self.revision)
572
if t in checker.checked_texts:
573
prev_sha = checker.checked_texts[t]
480
574
if prev_sha != self.text_sha1:
482
'mismatched sha1 on {%s} in {%s} (%s != %s) %r' %
483
(self.file_id, tree_revision_id, prev_sha, self.text_sha1,
575
raise BzrCheckError('mismatched sha1 on {%s} in {%s}' %
576
(self.file_id, tree_revision_id))
486
578
checker.repeated_text_cnt += 1
581
if self.file_id not in checker.checked_weaves:
582
mutter('check weave {%s}', self.file_id)
583
w = tree.get_weave(self.file_id)
584
# Not passing a progress bar, because it creates a new
585
# progress, which overwrites the current progress,
586
# and doesn't look nice
588
checker.checked_weaves[self.file_id] = True
590
w = tree.get_weave(self.file_id)
489
592
mutter('check version {%s} of {%s}', tree_revision_id, self.file_id)
490
593
checker.checked_text_cnt += 1
491
594
# We can't check the length, because Weave doesn't store that
492
595
# information, and the whole point of looking at the weave's
493
596
# sha1sum is that we don't have to extract the text.
494
if (self.text_sha1 != tree._repository.texts.get_sha1s([key])[key]):
495
raise BzrCheckError('text {%s} version {%s} wrong sha1' % key)
496
checker.checked_texts[key] = self.text_sha1
597
if self.text_sha1 != w.get_sha1(self.revision):
598
raise BzrCheckError('text {%s} version {%s} wrong sha1'
599
% (self.file_id, self.revision))
600
checker.checked_texts[t] = self.text_sha1
499
603
other = InventoryFile(self.file_id, self.name, self.parent_id)
513
619
def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
514
620
output_to, reverse=False):
515
621
"""See InventoryEntry._diff."""
516
from bzrlib.diff import DiffText
517
from_file_id = self.file_id
519
to_file_id = to_entry.file_id
523
to_file_id, from_file_id = from_file_id, to_file_id
524
tree, to_tree = to_tree, tree
525
from_label, to_label = to_label, from_label
526
differ = DiffText(tree, to_tree, output_to, 'utf-8', '', '',
528
return differ.diff_text(from_file_id, to_file_id, from_label, to_label)
623
from_text = tree.get_file(self.file_id).readlines()
625
to_text = to_tree.get_file(to_entry.file_id).readlines()
629
text_diff(from_label, from_text,
630
to_label, to_text, output_to)
632
text_diff(to_label, to_text,
633
from_label, from_text, output_to)
636
label_pair = (to_label, from_label)
638
label_pair = (from_label, to_label)
639
print >> output_to, "Binary files %s and %s differ" % label_pair
530
641
def has_text(self):
531
642
"""See InventoryEntry.has_text."""
553
664
def _put_on_disk(self, fullpath, tree):
554
665
"""See InventoryEntry._put_on_disk."""
555
osutils.pumpfile(tree.get_file(self.file_id), file(fullpath, 'wb'))
666
pumpfile(tree.get_file(self.file_id), file(fullpath, 'wb'))
556
667
if tree.is_executable(self.file_id):
557
668
os.chmod(fullpath, 0755)
559
670
def _read_tree_state(self, path, work_tree):
560
671
"""See InventoryEntry._read_tree_state."""
561
672
self.text_sha1 = work_tree.get_file_sha1(self.file_id, path=path)
562
# FIXME: 20050930 probe for the text size when getting sha1
563
# in _read_tree_state
564
673
self.executable = work_tree.is_executable(self.file_id, path=path)
567
return ("%s(%r, %r, parent_id=%r, sha1=%r, len=%s)"
568
% (self.__class__.__name__,
575
675
def _forget_tree_state(self):
576
676
self.text_sha1 = None
677
self.executable = None
679
def _snapshot_text(self, file_parents, work_tree, versionedfile_store, transaction):
680
"""See InventoryEntry._snapshot_text."""
681
mutter('storing text of file {%s} in revision {%s} into %r',
682
self.file_id, self.revision, versionedfile_store)
683
# special case to avoid diffing on renames or
685
if (len(file_parents) == 1
686
and self.text_sha1 == file_parents.values()[0].text_sha1
687
and self.text_size == file_parents.values()[0].text_size):
688
previous_ie = file_parents.values()[0]
689
versionedfile = versionedfile_store.get_weave(self.file_id, transaction)
690
versionedfile.clone_text(self.revision, previous_ie.revision, file_parents.keys())
692
new_lines = work_tree.get_file(self.file_id).readlines()
693
self._add_text_to_weave(new_lines, file_parents.keys(), versionedfile_store,
695
self.text_sha1 = sha_strings(new_lines)
696
self.text_size = sum(map(len, new_lines))
578
699
def _unchanged(self, previous_ie):
579
700
"""See InventoryEntry._unchanged."""
592
713
class InventoryLink(InventoryEntry):
593
714
"""A file in an inventory."""
595
__slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
596
'text_id', 'parent_id', 'children', 'executable',
597
'revision', 'symlink_target', 'reference_revision']
716
__slots__ = ['symlink_target']
599
718
def _check(self, checker, rev_id, tree):
600
719
"""See InventoryEntry._check"""
601
if self.text_sha1 is not None or self.text_size is not None or self.text_id is not None:
720
if self.text_sha1 != None or self.text_size != None or self.text_id != None:
602
721
raise BzrCheckError('symlink {%s} has text in revision {%s}'
603
722
% (self.file_id, rev_id))
604
if self.symlink_target is None:
723
if self.symlink_target == None:
605
724
raise BzrCheckError('symlink {%s} has no target in revision {%s}'
606
725
% (self.file_id, rev_id))
623
742
def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
624
743
output_to, reverse=False):
625
744
"""See InventoryEntry._diff."""
626
from bzrlib.diff import DiffSymlink
627
old_target = self.symlink_target
745
from_text = self.symlink_target
628
746
if to_entry is not None:
629
new_target = to_entry.symlink_target
638
new_target, old_target = old_target, new_target
639
differ = DiffSymlink(old_tree, new_tree, output_to)
640
return differ.diff_symlink(old_target, new_target)
747
to_text = to_entry.symlink_target
752
print >>output_to, '=== target changed %r => %r' % (from_text, to_text)
755
print >>output_to, '=== target was %r' % self.symlink_target
757
print >>output_to, '=== target is %r' % self.symlink_target
642
759
def __init__(self, file_id, name, parent_id):
643
760
super(InventoryLink, self).__init__(file_id, name, parent_id)
678
795
return compatible
681
class TreeReference(InventoryEntry):
683
kind = 'tree-reference'
685
def __init__(self, file_id, name, parent_id, revision=None,
686
reference_revision=None):
687
InventoryEntry.__init__(self, file_id, name, parent_id)
688
self.revision = revision
689
self.reference_revision = reference_revision
692
return TreeReference(self.file_id, self.name, self.parent_id,
693
self.revision, self.reference_revision)
695
def _read_tree_state(self, path, work_tree):
696
"""Populate fields in the inventory entry from the given tree.
698
self.reference_revision = work_tree.get_reference_revision(
701
def _forget_tree_state(self):
702
self.reference_revision = None
704
def _unchanged(self, previous_ie):
705
"""See InventoryEntry._unchanged."""
706
compatible = super(TreeReference, self)._unchanged(previous_ie)
707
if self.reference_revision != previous_ie.reference_revision:
712
798
class Inventory(object):
713
799
"""Inventory of versioned files in a tree.
760
843
The inventory is created with a default root directory, with
763
if root_id is not None:
764
self._set_root(InventoryDirectory(root_id, u'', None))
846
# We are letting Branch.create() create a unique inventory
847
# root id. Rather than generating a random one here.
849
# root_id = bzrlib.branch.gen_file_id('TREE_ROOT')
850
self.root = RootEntry(root_id)
768
851
self.revision_id = revision_id
771
return "<Inventory object at %x, contents=%r>" % (id(self), self._byid)
773
def apply_delta(self, delta):
774
"""Apply a delta to this inventory.
776
:param delta: A list of changes to apply. After all the changes are
777
applied the final inventory must be internally consistent, but it
778
is ok to supply changes which, if only half-applied would have an
779
invalid result - such as supplying two changes which rename two
780
files, 'A' and 'B' with each other : [('A', 'B', 'A-id', a_entry),
781
('B', 'A', 'B-id', b_entry)].
783
Each change is a tuple, of the form (old_path, new_path, file_id,
786
When new_path is None, the change indicates the removal of an entry
787
from the inventory and new_entry will be ignored (using None is
788
appropriate). If new_path is not None, then new_entry must be an
789
InventoryEntry instance, which will be incorporated into the
790
inventory (and replace any existing entry with the same file id).
792
When old_path is None, the change indicates the addition of
793
a new entry to the inventory.
795
When neither new_path nor old_path are None, the change is a
796
modification to an entry, such as a rename, reparent, kind change
799
The children attribute of new_entry is ignored. This is because
800
this method preserves children automatically across alterations to
801
the parent of the children, and cases where the parent id of a
802
child is changing require the child to be passed in as a separate
803
change regardless. E.g. in the recursive deletion of a directory -
804
the directory's children must be included in the delta, or the
805
final inventory will be invalid.
808
# Remove all affected items which were in the original inventory,
809
# starting with the longest paths, thus ensuring parents are examined
810
# after their children, which means that everything we examine has no
811
# modified children remaining by the time we examine it.
812
for old_path, file_id in sorted(((op, f) for op, np, f, e in delta
813
if op is not None), reverse=True):
814
if file_id not in self:
817
# Preserve unaltered children of file_id for later reinsertion.
818
file_id_children = getattr(self[file_id], 'children', {})
819
if len(file_id_children):
820
children[file_id] = file_id_children
821
# Remove file_id and the unaltered children. If file_id is not
822
# being deleted it will be reinserted back later.
823
self.remove_recursive_id(file_id)
824
# Insert all affected which should be in the new inventory, reattaching
825
# their children if they had any. This is done from shortest path to
826
# longest, ensuring that items which were modified and whose parents in
827
# the resulting inventory were also modified, are inserted after their
829
for new_path, new_entry in sorted((np, e) for op, np, f, e in
830
delta if np is not None):
831
if new_entry.kind == 'directory':
832
# Pop the child which to allow detection of children whose
833
# parents were deleted and which were not reattached to a new
835
new_entry.children = children.pop(new_entry.file_id, {})
838
# Get the parent id that was deleted
839
parent_id, children = children.popitem()
840
raise errors.InconsistentDelta("<deleted>", parent_id,
841
"The file id was deleted but its children were not deleted.")
843
def _set_root(self, ie):
845
852
self._byid = {self.root.file_id: self.root}
848
856
# TODO: jam 20051218 Should copy also copy the revision_id?
849
entries = self.iter_entries()
850
if self.root is None:
851
return Inventory(root_id=None)
852
other = Inventory(entries.next()[1].file_id)
853
other.root.revision = self.root.revision
857
other = Inventory(self.root.file_id)
854
858
# copy recursively so we know directories will be added before
855
859
# their children. There are more efficient ways than this...
856
for path, entry in entries:
860
for path, entry in self.iter_entries():
861
if entry == self.root:
857
863
other.add(entry.copy())
860
867
def __iter__(self):
861
868
return iter(self._byid)
863
871
def __len__(self):
864
872
"""Returns number of entries."""
865
873
return len(self._byid)
867
876
def iter_entries(self, from_dir=None):
868
877
"""Return (path, entry) pairs, in order by name."""
870
if self.root is None:
872
880
from_dir = self.root
874
881
elif isinstance(from_dir, basestring):
875
882
from_dir = self._byid[from_dir]
908
915
# if we finished all children, pop it off the stack
911
def iter_entries_by_dir(self, from_dir=None, specific_file_ids=None,
912
yield_parents=False):
913
"""Iterate over the entries in a directory first order.
915
This returns all entries for a directory before returning
916
the entries for children of a directory. This is not
917
lexicographically sorted order, and is a hybrid between
918
depth-first and breadth-first.
920
:param yield_parents: If True, yield the parents from the root leading
921
down to specific_file_ids that have been requested. This has no
922
impact if specific_file_ids is None.
923
:return: This yields (path, entry) pairs
925
if specific_file_ids and not isinstance(specific_file_ids, set):
926
specific_file_ids = set(specific_file_ids)
927
# TODO? Perhaps this should return the from_dir so that the root is
928
# yielded? or maybe an option?
930
if self.root is None:
932
# Optimize a common case
933
if (not yield_parents and specific_file_ids is not None and
934
len(specific_file_ids) == 1):
935
file_id = list(specific_file_ids)[0]
937
yield self.id2path(file_id), self[file_id]
940
if (specific_file_ids is None or yield_parents or
941
self.root.file_id in specific_file_ids):
943
elif isinstance(from_dir, basestring):
944
from_dir = self._byid[from_dir]
946
if specific_file_ids is not None:
947
# TODO: jam 20070302 This could really be done as a loop rather
948
# than a bunch of recursive calls.
951
def add_ancestors(file_id):
952
if file_id not in byid:
954
parent_id = byid[file_id].parent_id
955
if parent_id is None:
957
if parent_id not in parents:
958
parents.add(parent_id)
959
add_ancestors(parent_id)
960
for file_id in specific_file_ids:
961
add_ancestors(file_id)
965
stack = [(u'', from_dir)]
967
cur_relpath, cur_dir = stack.pop()
970
for child_name, child_ie in sorted(cur_dir.children.iteritems()):
972
child_relpath = cur_relpath + child_name
974
if (specific_file_ids is None or
975
child_ie.file_id in specific_file_ids or
976
(yield_parents and child_ie.file_id in parents)):
977
yield child_relpath, child_ie
979
if child_ie.kind == 'directory':
980
if parents is None or child_ie.file_id in parents:
981
child_dirs.append((child_relpath+'/', child_ie))
982
stack.extend(reversed(child_dirs))
984
def make_entry(self, kind, name, parent_id, file_id=None):
985
"""Simple thunk to bzrlib.inventory.make_entry."""
986
return make_entry(kind, name, parent_id, file_id)
988
918
def entries(self):
989
919
"""Return list of (path, ie) for all entries except the root.
1016
947
for name, child_ie in kids:
1017
child_path = osutils.pathjoin(parent_path, name)
948
child_path = pathjoin(parent_path, name)
1018
949
descend(child_ie, child_path)
1019
950
descend(self.root, u'')
1022
955
def __contains__(self, file_id):
1023
956
"""True if this entry contains a file with given id.
1025
958
>>> inv = Inventory()
1026
959
>>> inv.add(InventoryFile('123', 'foo.c', ROOT_ID))
1027
InventoryFile('123', 'foo.c', parent_id='TREE_ROOT', sha1=None, len=None)
960
InventoryFile('123', 'foo.c', parent_id='TREE_ROOT')
1028
961
>>> '123' in inv
1030
963
>>> '456' in inv
1033
return (file_id in self._byid)
966
return file_id in self._byid
1035
969
def __getitem__(self, file_id):
1036
970
"""Return the entry for given file_id.
1038
972
>>> inv = Inventory()
1039
973
>>> inv.add(InventoryFile('123123', 'hello.c', ROOT_ID))
1040
InventoryFile('123123', 'hello.c', parent_id='TREE_ROOT', sha1=None, len=None)
974
InventoryFile('123123', 'hello.c', parent_id='TREE_ROOT')
1041
975
>>> inv['123123'].name
1045
979
return self._byid[file_id]
1046
980
except KeyError:
1047
# really we're passing an inventory, not a tree...
1048
raise errors.NoSuchId(self, file_id)
982
raise BzrError("can't look up file_id None")
984
raise BzrError("file_id {%s} not in inventory" % file_id)
1050
987
def get_file_kind(self, file_id):
1051
988
return self._byid[file_id].kind
1072
1000
Returns the new entry object.
1074
1002
if entry.file_id in self._byid:
1075
raise errors.DuplicateFileId(entry.file_id,
1076
self._byid[entry.file_id])
1078
if entry.parent_id is None:
1082
parent = self._byid[entry.parent_id]
1084
raise BzrError("parent_id {%s} not in inventory" %
1087
if entry.name in parent.children:
1088
raise BzrError("%s is already versioned" %
1089
osutils.pathjoin(self.id2path(parent.file_id),
1090
entry.name).encode('utf-8'))
1091
parent.children[entry.name] = entry
1092
return self._add_child(entry)
1003
raise BzrError("inventory already contains entry with id {%s}" % entry.file_id)
1005
if entry.parent_id == ROOT_ID or entry.parent_id is None:
1006
entry.parent_id = self.root.file_id
1009
parent = self._byid[entry.parent_id]
1011
raise BzrError("parent_id {%s} not in inventory" % entry.parent_id)
1013
if parent.children.has_key(entry.name):
1014
raise BzrError("%s is already versioned" %
1015
pathjoin(self.id2path(parent.file_id), entry.name))
1017
self._byid[entry.file_id] = entry
1018
parent.children[entry.name] = entry
1094
1022
def add_path(self, relpath, kind, file_id=None, parent_id=None):
1095
1023
"""Add entry from a path.
1141
1074
>>> i1.add(InventoryFile('123', 'foo', ROOT_ID))
1142
InventoryFile('123', 'foo', parent_id='TREE_ROOT', sha1=None, len=None)
1075
InventoryFile('123', 'foo', parent_id='TREE_ROOT')
1145
1078
>>> i2.add(InventoryFile('123', 'foo', ROOT_ID))
1146
InventoryFile('123', 'foo', parent_id='TREE_ROOT', sha1=None, len=None)
1079
InventoryFile('123', 'foo', parent_id='TREE_ROOT')
1150
1083
if not isinstance(other, Inventory):
1151
1084
return NotImplemented
1086
if len(self._byid) != len(other._byid):
1087
# shortcut: obviously not the same
1153
1090
return self._byid == other._byid
1155
1093
def __ne__(self, other):
1156
1094
return not self.__eq__(other)
1158
1097
def __hash__(self):
1159
1098
raise ValueError('not hashable')
1161
1100
def _iter_file_id_parents(self, file_id):
1162
1101
"""Yield the parents of file_id up to the root."""
1163
while file_id is not None:
1102
while file_id != None:
1165
1104
ie = self._byid[file_id]
1166
1105
except KeyError:
1167
raise errors.NoSuchId(tree=None, file_id=file_id)
1106
raise BzrError("file_id {%s} not found in inventory" % file_id)
1169
1108
file_id = ie.parent_id
1228
1164
return parent.file_id
1230
1167
def has_filename(self, names):
1231
1168
return bool(self.path2id(names))
1233
1171
def has_id(self, file_id):
1234
return (file_id in self._byid)
1172
return self._byid.has_key(file_id)
1236
def remove_recursive_id(self, file_id):
1237
"""Remove file_id, and children, from the inventory.
1239
:param file_id: A file_id to remove.
1241
to_find_delete = [self._byid[file_id]]
1243
while to_find_delete:
1244
ie = to_find_delete.pop()
1245
to_delete.append(ie.file_id)
1246
if ie.kind == 'directory':
1247
to_find_delete.extend(ie.children.values())
1248
for file_id in reversed(to_delete):
1250
del self._byid[file_id]
1251
if ie.parent_id is not None:
1252
del self[ie.parent_id].children[ie.name]
1256
1175
def rename(self, file_id, new_parent_id, new_name):
1257
1176
"""Move a file within the inventory.
1259
1178
This can change either the name, or the parent, or both.
1261
This does not move the working file.
1263
new_name = ensure_normalized_name(new_name)
1180
This does not move the working file."""
1264
1181
if not is_valid_name(new_name):
1265
1182
raise BzrError("not an acceptable filename: %r" % new_name)
1304
1211
:param file_id: the file_id to use. if None, one will be created.
1306
1213
if file_id is None:
1307
file_id = generate_ids.gen_file_id(name)
1308
name = ensure_normalized_name(name)
1310
factory = entry_factory[kind]
1214
file_id = bzrlib.workingtree.gen_file_id(name)
1215
if kind == 'directory':
1216
return InventoryDirectory(file_id, name, parent_id)
1217
elif kind == 'file':
1218
return InventoryFile(file_id, name, parent_id)
1219
elif kind == 'symlink':
1220
return InventoryLink(file_id, name, parent_id)
1312
1222
raise BzrError("unknown kind %r" % kind)
1313
return factory(file_id, name, parent_id)
1316
def ensure_normalized_name(name):
1319
:raises InvalidNormalization: When name is not normalized, and cannot be
1320
accessed on this platform by the normalized path.
1321
:return: The NFC normalised version of name.
1323
#------- This has been copied to bzrlib.dirstate.DirState.add, please
1324
# keep them synchronised.
1325
# we dont import normalized_filename directly because we want to be
1326
# able to change the implementation at runtime for tests.
1327
norm_name, can_access = osutils.normalized_filename(name)
1328
if norm_name != name:
1332
# TODO: jam 20060701 This would probably be more useful
1333
# if the error was raised with the full path
1334
raise errors.InvalidNormalization(name)
1338
1226
_NAME_RE = None
1340
1228
def is_valid_name(name):
1341
1229
global _NAME_RE
1342
if _NAME_RE is None:
1230
if _NAME_RE == None:
1343
1231
_NAME_RE = re.compile(r'^[^/\\]+$')
1345
1233
return bool(_NAME_RE.match(name))
added
removed
bzrlib/inventory.py
