91
80
InventoryDirectory('123', 'src', parent_id='TREE_ROOT', revision=None)
92
81
>>> i.add(InventoryFile('2323', 'hello.c', parent_id='123'))
93
82
InventoryFile('2323', 'hello.c', parent_id='123', sha1=None, len=None)
94
>>> shouldbe = {0: '', 1: 'src', 2: 'src/hello.c'}
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
87
(True, InventoryDirectory('123', 'src', parent_id='TREE_ROOT', revision=None))
100
88
(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}
101
93
>>> i.add(InventoryFile('2324', 'bye.c', '123'))
102
94
InventoryFile('2324', 'bye.c', parent_id='123', sha1=None, len=None)
103
95
>>> i.add(InventoryDirectory('2325', 'wibble', '123'))
142
134
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,
144
153
def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
145
154
output_to, reverse=False):
146
155
"""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
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.
175
def get_ancestors(weave, entry):
176
return set(weave.get_ancestry(entry.revision))
157
177
# 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
159
183
# identify candidate head revision ids.
160
184
for inv in previous_inventories:
161
185
if self.file_id in inv:
162
186
ie = inv[self.file_id]
187
assert ie.file_id == self.file_id
163
188
if ie.revision in candidates:
164
189
# same revision value in two different inventories:
165
190
# correct possible inconsistencies:
171
196
ie.executable = False
172
197
except AttributeError:
199
# must now be the same.
200
assert candidates[ie.revision] == ie
175
202
# add this revision as a candidate.
176
203
candidates[ie.revision] = ie
179
@deprecated_method(deprecated_in((1, 6, 0)))
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
180
243
def get_tar_item(self, root, dp, now, tree):
181
244
"""Get a tarfile item and a file stream for its content."""
182
item = tarfile.TarInfo(osutils.pathjoin(root, dp).encode('utf8'))
245
item = tarfile.TarInfo(pathjoin(root, dp))
183
246
# TODO: would be cool to actually set it to the timestamp of the
184
247
# revision it was last changed
239
302
raise BzrError("don't know how to export {%s} of kind %r" %
240
303
(self.file_id, self.kind))
242
@deprecated_method(deprecated_in((1, 6, 0)))
243
305
def put_on_disk(self, dest, dp, tree):
244
306
"""Create a representation of self on disk in the prefix dest.
246
308
This is a template method - implement _put_on_disk in subclasses.
248
fullpath = osutils.pathjoin(dest, dp)
310
fullpath = pathjoin(dest, dp)
249
311
self._put_on_disk(fullpath, tree)
250
# mutter(" export {%s} kind %s to %s", self.file_id,
251
# self.kind, fullpath)
312
mutter(" export {%s} kind %s to %s", self.file_id,
253
315
def _put_on_disk(self, fullpath, tree):
254
316
"""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)
343
446
def __eq__(self, other):
344
447
if not isinstance(other, InventoryEntry):
345
448
return NotImplemented
464
561
"""See InventoryEntry._put_on_disk."""
465
562
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)
468
569
class InventoryFile(InventoryEntry):
469
570
"""A file in an inventory."""
471
572
__slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
472
'text_id', 'parent_id', 'children', 'executable',
473
'revision', 'symlink_target', 'reference_revision']
573
'text_id', 'parent_id', 'children', 'executable',
574
'revision', 'symlink_target']
475
576
def _check(self, checker, tree_revision_id, tree):
476
577
"""See InventoryEntry._check"""
477
key = (self.file_id, self.revision)
478
if key in checker.checked_texts:
479
prev_sha = checker.checked_texts[key]
578
t = (self.file_id, self.revision)
579
if t in checker.checked_texts:
580
prev_sha = checker.checked_texts[t]
480
581
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,
582
raise BzrCheckError('mismatched sha1 on {%s} in {%s}' %
583
(self.file_id, tree_revision_id))
486
585
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)
489
599
mutter('check version {%s} of {%s}', tree_revision_id, self.file_id)
490
600
checker.checked_text_cnt += 1
491
601
# We can't check the length, because Weave doesn't store that
492
602
# information, and the whole point of looking at the weave's
493
603
# 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
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
499
610
other = InventoryFile(self.file_id, self.name, self.parent_id)
513
626
def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
514
627
output_to, reverse=False):
515
628
"""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)
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
530
648
def has_text(self):
531
649
"""See InventoryEntry.has_text."""
623
749
def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
624
750
output_to, reverse=False):
625
751
"""See InventoryEntry._diff."""
626
from bzrlib.diff import DiffSymlink
627
old_target = self.symlink_target
752
from_text = self.symlink_target
628
753
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)
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
642
766
def __init__(self, file_id, name, parent_id):
643
767
super(InventoryLink, self).__init__(file_id, name, parent_id)
677
801
compatible = False
678
802
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:
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)
712
810
class Inventory(object):
760
855
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))
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
768
865
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
866
self._byid = {self.root.file_id: self.root}
848
869
# 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
870
other = Inventory(self.root.file_id)
854
871
# copy recursively so we know directories will be added before
855
872
# their children. There are more efficient ways than this...
856
for path, entry in entries:
873
for path, entry in self.iter_entries():
874
if entry == self.root:
857
876
other.add(entry.copy())
917
933
lexicographically sorted order, and is a hybrid between
918
934
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
936
: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
938
# TODO? Perhaps this should return the from_dir so that the root is
928
939
# yielded? or maybe an option?
929
940
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]
939
942
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)
965
946
stack = [(u'', from_dir)]
972
953
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
955
yield child_relpath, child_ie
979
957
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))
958
child_dirs.append((child_relpath+'/', child_ie))
982
959
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
961
def entries(self):
989
962
"""Return list of (path, ie) for all entries except the root.
1072
1037
Returns the new entry object.
1074
1039
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)
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
1094
1058
def add_path(self, relpath, kind, file_id=None, parent_id=None):
1095
1059
"""Add entry from a path.
1231
1196
return bool(self.path2id(names))
1233
1198
def has_id(self, 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]
1199
return self._byid.has_key(file_id)
1256
1201
def rename(self, file_id, new_parent_id, new_name):
1257
1202
"""Move a file within the inventory.
1259
1204
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)
1206
This does not move the working file."""
1264
1207
if not is_valid_name(new_name):
1265
1208
raise BzrError("not an acceptable filename: %r" % new_name)
1304
1237
:param file_id: the file_id to use. if None, one will be created.
1306
1239
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]
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)
1312
1248
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
1252
_NAME_RE = None
added
removed
bzrlib/inventory.py
