80
91
InventoryDirectory('123', 'src', parent_id='TREE_ROOT', revision=None)
81
92
>>> i.add(InventoryFile('2323', 'hello.c', parent_id='123'))
82
93
InventoryFile('2323', 'hello.c', parent_id='123', sha1=None, len=None)
83
>>> shouldbe = {0: 'src', 1: pathjoin('src','hello.c')}
94
>>> shouldbe = {0: '', 1: 'src', 2: 'src/hello.c'}
84
95
>>> for ix, j in enumerate(i.iter_entries()):
85
96
... print (j[0] == shouldbe[ix], j[1])
98
(True, InventoryDirectory('TREE_ROOT', u'', parent_id=None, revision=None))
87
99
(True, InventoryDirectory('123', 'src', parent_id='TREE_ROOT', revision=None))
88
100
(True, InventoryFile('2323', 'hello.c', parent_id='123', sha1=None, len=None))
89
>>> i.add(InventoryFile('2323', 'bye.c', '123'))
90
Traceback (most recent call last):
92
BzrError: inventory already contains entry with id {2323}
93
101
>>> i.add(InventoryFile('2324', 'bye.c', '123'))
94
102
InventoryFile('2324', 'bye.c', parent_id='123', sha1=None, len=None)
95
103
>>> i.add(InventoryDirectory('2325', 'wibble', '123'))
134
142
return False, False
136
def diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
137
output_to, reverse=False):
138
"""Perform a diff from this to to_entry.
140
text_diff will be used for textual difference calculation.
141
This is a template method, override _diff in child classes.
143
self._read_tree_state(tree.id2path(self.file_id), tree)
145
# cannot diff from one kind to another - you must do a removal
146
# and an addif they do not match.
147
assert self.kind == to_entry.kind
148
to_entry._read_tree_state(to_tree.id2path(to_entry.file_id),
150
self._diff(text_diff, from_label, tree, to_label, to_entry, to_tree,
153
144
def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
154
145
output_to, reverse=False):
155
146
"""Perform a diff between two entries of the same kind."""
157
def find_previous_heads(self, previous_inventories,
158
versioned_file_store,
161
"""Return the revisions and entries that directly precede this.
163
Returned as a map from revision to inventory entry.
165
This is a map containing the file revisions in all parents
166
for which the file exists, and its revision is not a parent of
167
any other. If the file is new, the set will be empty.
169
:param versioned_file_store: A store where ancestry data on this
170
file id can be queried.
171
:param transaction: The transaction that queries to the versioned
172
file store should be completed under.
173
:param entry_vf: The entry versioned file, if its already available.
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
175
def get_ancestors(weave, entry):
176
return set(weave.get_ancestry(entry.revision))
177
157
# revision:ie mapping for each ie found in previous_inventories.
179
# revision:ie mapping with one revision for each head.
181
# revision: ancestor list for each head
183
159
# identify candidate head revision ids.
184
160
for inv in previous_inventories:
185
161
if self.file_id in inv:
186
162
ie = inv[self.file_id]
187
assert ie.file_id == self.file_id
188
163
if ie.revision in candidates:
189
164
# same revision value in two different inventories:
190
165
# correct possible inconsistencies:
196
171
ie.executable = False
197
172
except AttributeError:
199
# must now be the same.
200
assert candidates[ie.revision] == ie
202
175
# add this revision as a candidate.
203
176
candidates[ie.revision] = ie
205
# common case optimisation
206
if len(candidates) == 1:
207
# if there is only one candidate revision found
208
# then we can opening the versioned file to access ancestry:
209
# there cannot be any ancestors to eliminate when there is
210
# only one revision available.
211
heads[ie.revision] = ie
214
# eliminate ancestors amongst the available candidates:
215
# heads are those that are not an ancestor of any other candidate
216
# - this provides convergence at a per-file level.
217
for ie in candidates.values():
218
# may be an ancestor of a known head:
219
already_present = 0 != len(
220
[head for head in heads
221
if ie.revision in head_ancestors[head]])
223
# an ancestor of an analyzed candidate.
225
# not an ancestor of a known head:
226
# load the versioned file for this file id if needed
228
entry_vf = versioned_file_store.get_weave_or_empty(
229
self.file_id, transaction)
230
ancestors = get_ancestors(entry_vf, ie)
231
# may knock something else out:
232
check_heads = list(heads.keys())
233
for head in check_heads:
234
if head in ancestors:
235
# this previously discovered 'head' is not
236
# really a head - its an ancestor of the newly
239
head_ancestors[ie.revision] = ancestors
240
heads[ie.revision] = ie
179
@deprecated_method(deprecated_in((1, 6, 0)))
243
180
def get_tar_item(self, root, dp, now, tree):
244
181
"""Get a tarfile item and a file stream for its content."""
245
item = tarfile.TarInfo(pathjoin(root, dp))
182
item = tarfile.TarInfo(osutils.pathjoin(root, dp).encode('utf8'))
246
183
# TODO: would be cool to actually set it to the timestamp of the
247
184
# revision it was last changed
302
239
raise BzrError("don't know how to export {%s} of kind %r" %
303
240
(self.file_id, self.kind))
242
@deprecated_method(deprecated_in((1, 6, 0)))
305
243
def put_on_disk(self, dest, dp, tree):
306
244
"""Create a representation of self on disk in the prefix dest.
308
246
This is a template method - implement _put_on_disk in subclasses.
310
fullpath = pathjoin(dest, dp)
248
fullpath = osutils.pathjoin(dest, dp)
311
249
self._put_on_disk(fullpath, tree)
312
mutter(" export {%s} kind %s to %s", self.file_id,
250
# mutter(" export {%s} kind %s to %s", self.file_id,
251
# self.kind, fullpath)
315
253
def _put_on_disk(self, fullpath, tree):
316
254
"""Put this entry onto disk at fullpath, from tree tree."""
403
def snapshot(self, revision, path, previous_entries,
404
work_tree, commit_builder):
405
"""Make a snapshot of this entry which may or may not have changed.
407
This means that all its fields are populated, that it has its
408
text stored in the text store or weave.
410
mutter('new parents of %s are %r', path, previous_entries)
411
self._read_tree_state(path, work_tree)
412
# TODO: Where should we determine whether to reuse a
413
# previous revision id or create a new revision? 20060606
414
if len(previous_entries) == 1:
415
# cannot be unchanged unless there is only one parent file rev.
416
parent_ie = previous_entries.values()[0]
417
if self._unchanged(parent_ie):
418
mutter("found unchanged entry")
419
self.revision = parent_ie.revision
421
return self._snapshot_into_revision(revision, previous_entries,
422
work_tree, commit_builder)
424
def _snapshot_into_revision(self, revision, previous_entries, work_tree,
426
"""Record this revision unconditionally into a store.
428
The entry's last-changed revision property (`revision`) is updated to
429
that of the new revision.
431
:param revision: id of the new revision that is being recorded.
433
:returns: String description of the commit (e.g. "merged", "modified"), etc.
435
mutter('new revision {%s} for {%s}', revision, self.file_id)
436
self.revision = revision
437
self._snapshot_text(previous_entries, work_tree, commit_builder)
439
def _snapshot_text(self, file_parents, work_tree, commit_builder):
440
"""Record the 'text' of this entry, whatever form that takes.
442
This default implementation simply adds an empty text.
444
raise NotImplementedError(self._snapshot_text)
446
343
def __eq__(self, other):
447
344
if not isinstance(other, InventoryEntry):
448
345
return NotImplemented
561
464
"""See InventoryEntry._put_on_disk."""
562
465
os.mkdir(fullpath)
564
def _snapshot_text(self, file_parents, work_tree, commit_builder):
565
"""See InventoryEntry._snapshot_text."""
566
commit_builder.modified_directory(self.file_id, file_parents)
569
468
class InventoryFile(InventoryEntry):
570
469
"""A file in an inventory."""
572
471
__slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
573
'text_id', 'parent_id', 'children', 'executable',
574
'revision', 'symlink_target']
472
'text_id', 'parent_id', 'children', 'executable',
473
'revision', 'symlink_target', 'reference_revision']
576
475
def _check(self, checker, tree_revision_id, tree):
577
476
"""See InventoryEntry._check"""
578
t = (self.file_id, self.revision)
579
if t in checker.checked_texts:
580
prev_sha = checker.checked_texts[t]
477
key = (self.file_id, self.revision)
478
if key in checker.checked_texts:
479
prev_sha = checker.checked_texts[key]
581
480
if prev_sha != self.text_sha1:
582
raise BzrCheckError('mismatched sha1 on {%s} in {%s}' %
583
(self.file_id, tree_revision_id))
482
'mismatched sha1 on {%s} in {%s} (%s != %s) %r' %
483
(self.file_id, tree_revision_id, prev_sha, self.text_sha1,
585
486
checker.repeated_text_cnt += 1
588
if self.file_id not in checker.checked_weaves:
589
mutter('check weave {%s}', self.file_id)
590
w = tree.get_weave(self.file_id)
591
# Not passing a progress bar, because it creates a new
592
# progress, which overwrites the current progress,
593
# and doesn't look nice
595
checker.checked_weaves[self.file_id] = True
597
w = tree.get_weave(self.file_id)
599
489
mutter('check version {%s} of {%s}', tree_revision_id, self.file_id)
600
490
checker.checked_text_cnt += 1
601
491
# We can't check the length, because Weave doesn't store that
602
492
# information, and the whole point of looking at the weave's
603
493
# sha1sum is that we don't have to extract the text.
604
if self.text_sha1 != w.get_sha1(self.revision):
605
raise BzrCheckError('text {%s} version {%s} wrong sha1'
606
% (self.file_id, self.revision))
607
checker.checked_texts[t] = self.text_sha1
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
610
499
other = InventoryFile(self.file_id, self.name, self.parent_id)
626
513
def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
627
514
output_to, reverse=False):
628
515
"""See InventoryEntry._diff."""
630
from_text = tree.get_file(self.file_id).readlines()
632
to_text = to_tree.get_file(to_entry.file_id).readlines()
636
text_diff(from_label, from_text,
637
to_label, to_text, output_to)
639
text_diff(to_label, to_text,
640
from_label, from_text, output_to)
643
label_pair = (to_label, from_label)
645
label_pair = (from_label, to_label)
646
print >> output_to, "Binary files %s and %s differ" % label_pair
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)
648
530
def has_text(self):
649
531
"""See InventoryEntry.has_text."""
749
623
def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
750
624
output_to, reverse=False):
751
625
"""See InventoryEntry._diff."""
752
from_text = self.symlink_target
626
from bzrlib.diff import DiffSymlink
627
old_target = self.symlink_target
753
628
if to_entry is not None:
754
to_text = to_entry.symlink_target
759
print >>output_to, '=== target changed %r => %r' % (from_text, to_text)
762
print >>output_to, '=== target was %r' % self.symlink_target
764
print >>output_to, '=== target is %r' % self.symlink_target
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)
766
642
def __init__(self, file_id, name, parent_id):
767
643
super(InventoryLink, self).__init__(file_id, name, parent_id)
801
677
compatible = False
802
678
return compatible
804
def _snapshot_text(self, file_parents, work_tree, commit_builder):
805
"""See InventoryEntry._snapshot_text."""
806
commit_builder.modified_link(
807
self.file_id, file_parents, self.symlink_target)
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:
810
712
class Inventory(object):
855
760
The inventory is created with a default root directory, with
858
# We are letting Branch.create() create a unique inventory
859
# root id. Rather than generating a random one here.
861
# root_id = bzrlib.branch.gen_file_id('TREE_ROOT')
862
self.root = RootEntry(root_id)
863
# FIXME: this isn't ever used, changing it to self.revision may break
864
# things. TODO make everything use self.revision_id
763
if root_id is not None:
764
self._set_root(InventoryDirectory(root_id, u'', None))
865
768
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):
866
845
self._byid = {self.root.file_id: self.root}
869
848
# TODO: jam 20051218 Should copy also copy the revision_id?
870
other = Inventory(self.root.file_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
871
854
# copy recursively so we know directories will be added before
872
855
# their children. There are more efficient ways than this...
873
for path, entry in self.iter_entries():
874
if entry == self.root:
856
for path, entry in entries:
876
857
other.add(entry.copy())
933
917
lexicographically sorted order, and is a hybrid between
934
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.
936
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)
938
927
# TODO? Perhaps this should return the from_dir so that the root is
939
928
# yielded? or maybe an option?
940
929
if from_dir is None:
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]
942
939
from_dir = self.root
940
if (specific_file_ids is None or yield_parents or
941
self.root.file_id in specific_file_ids):
943
943
elif isinstance(from_dir, basestring):
944
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)
946
965
stack = [(u'', from_dir)]
953
972
child_relpath = cur_relpath + child_name
955
yield child_relpath, child_ie
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
957
979
if child_ie.kind == 'directory':
958
child_dirs.append((child_relpath+'/', child_ie))
980
if parents is None or child_ie.file_id in parents:
981
child_dirs.append((child_relpath+'/', child_ie))
959
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)
961
988
def entries(self):
962
989
"""Return list of (path, ie) for all entries except the root.
1037
1072
Returns the new entry object.
1039
1074
if entry.file_id in self._byid:
1040
raise BzrError("inventory already contains entry with id {%s}" % entry.file_id)
1042
if entry.parent_id == ROOT_ID or entry.parent_id is None:
1043
entry.parent_id = self.root.file_id
1046
parent = self._byid[entry.parent_id]
1048
raise BzrError("parent_id {%s} not in inventory" % entry.parent_id)
1050
if entry.name in parent.children:
1051
raise BzrError("%s is already versioned" %
1052
pathjoin(self.id2path(parent.file_id), entry.name))
1054
self._byid[entry.file_id] = entry
1055
parent.children[entry.name] = entry
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)
1058
1094
def add_path(self, relpath, kind, file_id=None, parent_id=None):
1059
1095
"""Add entry from a path.
1196
1231
return bool(self.path2id(names))
1198
1233
def has_id(self, file_id):
1199
return self._byid.has_key(file_id)
1234
return (file_id in self._byid)
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]
1201
1256
def rename(self, file_id, new_parent_id, new_name):
1202
1257
"""Move a file within the inventory.
1204
1259
This can change either the name, or the parent, or both.
1206
This does not move the working file."""
1261
This does not move the working file.
1263
new_name = ensure_normalized_name(new_name)
1207
1264
if not is_valid_name(new_name):
1208
1265
raise BzrError("not an acceptable filename: %r" % new_name)
1237
1304
:param file_id: the file_id to use. if None, one will be created.
1239
1306
if file_id is None:
1240
file_id = bzrlib.workingtree.gen_file_id(name)
1241
if kind == 'directory':
1242
return InventoryDirectory(file_id, name, parent_id)
1243
elif kind == 'file':
1244
return InventoryFile(file_id, name, parent_id)
1245
elif kind == 'symlink':
1246
return InventoryLink(file_id, name, parent_id)
1307
file_id = generate_ids.gen_file_id(name)
1308
name = ensure_normalized_name(name)
1310
factory = entry_factory[kind]
1248
1312
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)
1252
1338
_NAME_RE = None
added
removed
bzrlib/inventory.py
