90
78
>>> i.add(InventoryDirectory('123', 'src', ROOT_ID))
91
InventoryDirectory('123', 'src', parent_id='TREE_ROOT', revision=None)
79
InventoryDirectory('123', 'src', parent_id='TREE_ROOT')
92
80
>>> 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'}
81
InventoryFile('2323', 'hello.c', parent_id='123')
82
>>> shouldbe = {0: 'src', 1: pathjoin('src','hello.c')}
95
83
>>> for ix, j in enumerate(i.iter_entries()):
96
84
... 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))
86
(True, InventoryDirectory('123', 'src', parent_id='TREE_ROOT'))
87
(True, InventoryFile('2323', 'hello.c', parent_id='123'))
88
>>> i.add(InventoryFile('2323', 'bye.c', '123'))
89
Traceback (most recent call last):
91
BzrError: inventory already contains entry with id {2323}
101
92
>>> i.add(InventoryFile('2324', 'bye.c', '123'))
102
InventoryFile('2324', 'bye.c', parent_id='123', sha1=None, len=None)
93
InventoryFile('2324', 'bye.c', parent_id='123')
103
94
>>> i.add(InventoryDirectory('2325', 'wibble', '123'))
104
InventoryDirectory('2325', 'wibble', parent_id='123', revision=None)
95
InventoryDirectory('2325', 'wibble', parent_id='123')
105
96
>>> i.path2id('src/wibble')
109
100
>>> i.add(InventoryFile('2326', 'wibble.c', '2325'))
110
InventoryFile('2326', 'wibble.c', parent_id='2325', sha1=None, len=None)
101
InventoryFile('2326', 'wibble.c', parent_id='2325')
112
InventoryFile('2326', 'wibble.c', parent_id='2325', sha1=None, len=None)
103
InventoryFile('2326', 'wibble.c', parent_id='2325')
113
104
>>> for path, entry in i.iter_entries():
106
... assert i.path2id(path)
142
131
return False, False
133
def diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
134
output_to, reverse=False):
135
"""Perform a diff from this to to_entry.
137
text_diff will be used for textual difference calculation.
138
This is a template method, override _diff in child classes.
140
self._read_tree_state(tree.id2path(self.file_id), tree)
142
# cannot diff from one kind to another - you must do a removal
143
# and an addif they do not match.
144
assert self.kind == to_entry.kind
145
to_entry._read_tree_state(to_tree.id2path(to_entry.file_id),
147
self._diff(text_diff, from_label, tree, to_label, to_entry, to_tree,
144
150
def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
145
151
output_to, reverse=False):
146
152
"""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
154
def find_previous_heads(self, previous_inventories, entry_weave):
155
"""Return the revisions and entries that directly preceed this.
157
Returned as a map from revision to inventory entry.
159
This is a map containing the file revisions in all parents
160
for which the file exists, and its revision is not a parent of
161
any other. If the file is new, the set will be empty.
157
# revision:ie mapping for each ie found in previous_inventories.
159
# identify candidate head revision ids.
163
def get_ancestors(weave, entry):
164
return set(map(weave.idx_to_name,
165
weave.inclusions([weave.lookup(entry.revision)])))
160
168
for inv in previous_inventories:
161
169
if self.file_id in inv:
162
170
ie = inv[self.file_id]
163
if ie.revision in candidates:
164
# same revision value in two different inventories:
165
# correct possible inconsistencies:
166
# * there was a bug in revision updates with 'x' bit
171
assert ie.file_id == self.file_id
172
if ie.revision in heads:
173
# fixup logic, there was a bug in revision updates.
174
# with x bit support.
169
if candidates[ie.revision].executable != ie.executable:
170
candidates[ie.revision].executable = False
176
if heads[ie.revision].executable != ie.executable:
177
heads[ie.revision].executable = False
171
178
ie.executable = False
172
179
except AttributeError:
181
assert heads[ie.revision] == ie
175
# add this revision as a candidate.
176
candidates[ie.revision] = ie
183
# may want to add it.
184
# may already be covered:
185
already_present = 0 != len(
186
[head for head in heads
187
if ie.revision in head_ancestors[head]])
189
# an ancestor of a known head.
192
ancestors = get_ancestors(entry_weave, ie)
193
# may knock something else out:
194
check_heads = list(heads.keys())
195
for head in check_heads:
196
if head in ancestors:
197
# this head is not really a head
199
head_ancestors[ie.revision] = ancestors
200
heads[ie.revision] = ie
179
@deprecated_method(deprecated_in((1, 6, 0)))
180
203
def get_tar_item(self, root, dp, now, tree):
181
204
"""Get a tarfile item and a file stream for its content."""
182
item = tarfile.TarInfo(osutils.pathjoin(root, dp).encode('utf8'))
205
item = tarfile.TarInfo(pathjoin(root, dp))
183
206
# TODO: would be cool to actually set it to the timestamp of the
184
207
# revision it was last changed
239
262
raise BzrError("don't know how to export {%s} of kind %r" %
240
263
(self.file_id, self.kind))
242
@deprecated_method(deprecated_in((1, 6, 0)))
243
265
def put_on_disk(self, dest, dp, tree):
244
266
"""Create a representation of self on disk in the prefix dest.
246
268
This is a template method - implement _put_on_disk in subclasses.
248
fullpath = osutils.pathjoin(dest, dp)
270
fullpath = pathjoin(dest, dp)
249
271
self._put_on_disk(fullpath, tree)
250
# mutter(" export {%s} kind %s to %s", self.file_id,
251
# self.kind, fullpath)
272
mutter(" export {%s} kind %s to %s", self.file_id,
253
275
def _put_on_disk(self, fullpath, tree):
254
276
"""Put this entry onto disk at fullpath, from tree tree."""
255
277
raise BzrError("don't know how to export {%s} of kind %r" % (self.file_id, self.kind))
257
279
def sorted_children(self):
258
return sorted(self.children.items())
280
l = self.children.items()
261
285
def versionable_kind(kind):
262
return (kind in ('file', 'directory', 'symlink', 'tree-reference'))
286
return kind in ('file', 'directory', 'symlink')
264
288
def check(self, checker, rev_id, inv, tree):
265
289
"""Check this inventory entry is intact.
267
291
This is a template method, override _check for kind specific
270
:param checker: Check object providing context for the checks;
271
can be used to find out what parts of the repository have already
273
:param rev_id: Revision id from which this InventoryEntry was loaded.
274
Not necessarily the last-changed revision for this file.
275
:param inv: Inventory from which the entry was loaded.
276
:param tree: RevisionTree for this entry.
278
if self.parent_id is not None:
294
if self.parent_id != None:
279
295
if not inv.has_id(self.parent_id):
280
296
raise BzrCheckError('missing parent {%s} in inventory for revision {%s}'
281
297
% (self.parent_id, rev_id))
286
302
raise BzrCheckError('unknown entry kind %r in revision {%s}' %
287
303
(self.kind, rev_id))
290
307
"""Clone this inventory entry."""
291
308
raise NotImplementedError
294
def describe_change(old_entry, new_entry):
295
"""Describe the change between old_entry and this.
297
This smells of being an InterInventoryEntry situation, but as its
298
the first one, we're making it a static method for now.
300
An entry with a different parent, or different name is considered
301
to be renamed. Reparenting is an internal detail.
302
Note that renaming the parent does not trigger a rename for the
305
# TODO: Perhaps return an object rather than just a string
306
if old_entry is new_entry:
307
# also the case of both being None
309
elif old_entry is None:
310
def _get_snapshot_change(self, previous_entries):
311
if len(previous_entries) > 1:
313
elif len(previous_entries) == 0:
311
elif new_entry is None:
313
if old_entry.kind != new_entry.kind:
315
text_modified, meta_modified = new_entry.detect_changes(old_entry)
316
if text_modified or meta_modified:
320
# TODO 20060511 (mbp, rbc) factor out 'detect_rename' here.
321
if old_entry.parent_id != new_entry.parent_id:
323
elif old_entry.name != new_entry.name:
327
if renamed and not modified:
328
return InventoryEntry.RENAMED
329
if modified and not renamed:
331
if modified and renamed:
332
return InventoryEntry.MODIFIED_AND_RENAMED
316
return 'modified/renamed/reparented'
335
318
def __repr__(self):
336
return ("%s(%r, %r, parent_id=%r, revision=%r)"
319
return ("%s(%r, %r, parent_id=%r)"
337
320
% (self.__class__.__name__,
325
def snapshot(self, revision, path, previous_entries,
326
work_tree, weave_store, transaction):
327
"""Make a snapshot of this entry which may or may not have changed.
329
This means that all its fields are populated, that it has its
330
text stored in the text store or weave.
332
mutter('new parents of %s are %r', path, previous_entries)
333
self._read_tree_state(path, work_tree)
334
if len(previous_entries) == 1:
335
# cannot be unchanged unless there is only one parent file rev.
336
parent_ie = previous_entries.values()[0]
337
if self._unchanged(parent_ie):
338
mutter("found unchanged entry")
339
self.revision = parent_ie.revision
341
return self.snapshot_revision(revision, previous_entries,
342
work_tree, weave_store, transaction)
344
def snapshot_revision(self, revision, previous_entries, work_tree,
345
weave_store, transaction):
346
"""Record this revision unconditionally."""
347
mutter('new revision for {%s}', self.file_id)
348
self.revision = revision
349
change = self._get_snapshot_change(previous_entries)
350
self._snapshot_text(previous_entries, work_tree, weave_store,
354
def _snapshot_text(self, file_parents, work_tree, weave_store, transaction):
355
"""Record the 'text' of this entry, whatever form that takes.
357
This default implementation simply adds an empty text.
359
mutter('storing file {%s} in revision {%s}',
360
self.file_id, self.revision)
361
self._add_text_to_weave([], file_parents, weave_store, transaction)
343
363
def __eq__(self, other):
344
364
if not isinstance(other, InventoryEntry):
468
473
class InventoryFile(InventoryEntry):
469
474
"""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
def _check(self, checker, tree_revision_id, tree):
476
def _check(self, checker, rev_id, tree):
476
477
"""See InventoryEntry._check"""
477
key = (self.file_id, self.revision)
478
if key in checker.checked_texts:
479
prev_sha = checker.checked_texts[key]
478
revision = self.revision
479
t = (self.file_id, revision)
480
if t in checker.checked_texts:
481
prev_sha = checker.checked_texts[t]
480
482
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,
483
raise BzrCheckError('mismatched sha1 on {%s} in {%s}' %
484
(self.file_id, rev_id))
486
486
checker.repeated_text_cnt += 1
489
mutter('check version {%s} of {%s}', tree_revision_id, self.file_id)
490
checker.checked_text_cnt += 1
489
if self.file_id not in checker.checked_weaves:
490
mutter('check weave {%s}', self.file_id)
491
w = tree.get_weave(self.file_id)
492
# Not passing a progress bar, because it creates a new
493
# progress, which overwrites the current progress,
494
# and doesn't look nice
496
checker.checked_weaves[self.file_id] = True
498
w = tree.get_weave_prelude(self.file_id)
500
mutter('check version {%s} of {%s}', rev_id, self.file_id)
501
checker.checked_text_cnt += 1
491
502
# We can't check the length, because Weave doesn't store that
492
503
# information, and the whole point of looking at the weave's
493
504
# 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
505
if self.text_sha1 != w.get_sha1(self.revision):
506
raise BzrCheckError('text {%s} version {%s} wrong sha1'
507
% (self.file_id, self.revision))
508
checker.checked_texts[t] = self.text_sha1
499
511
other = InventoryFile(self.file_id, self.name, self.parent_id)
553
565
def _put_on_disk(self, fullpath, tree):
554
566
"""See InventoryEntry._put_on_disk."""
555
osutils.pumpfile(tree.get_file(self.file_id), file(fullpath, 'wb'))
567
pumpfile(tree.get_file(self.file_id), file(fullpath, 'wb'))
556
568
if tree.is_executable(self.file_id):
557
569
os.chmod(fullpath, 0755)
559
571
def _read_tree_state(self, path, work_tree):
560
572
"""See InventoryEntry._read_tree_state."""
561
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
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__,
573
self.text_sha1 = work_tree.get_file_sha1(self.file_id)
574
self.executable = work_tree.is_executable(self.file_id)
575
576
def _forget_tree_state(self):
576
577
self.text_sha1 = None
578
self.executable = None
580
def _snapshot_text(self, file_parents, work_tree, weave_store, transaction):
581
"""See InventoryEntry._snapshot_text."""
582
mutter('storing file {%s} in revision {%s}',
583
self.file_id, self.revision)
584
# special case to avoid diffing on renames or
586
if (len(file_parents) == 1
587
and self.text_sha1 == file_parents.values()[0].text_sha1
588
and self.text_size == file_parents.values()[0].text_size):
589
previous_ie = file_parents.values()[0]
590
weave_store.add_identical_text(
591
self.file_id, previous_ie.revision,
592
self.revision, file_parents, transaction)
594
new_lines = work_tree.get_file(self.file_id).readlines()
595
self._add_text_to_weave(new_lines, file_parents, weave_store,
597
self.text_sha1 = sha_strings(new_lines)
598
self.text_size = sum(map(len, new_lines))
578
601
def _unchanged(self, previous_ie):
579
602
"""See InventoryEntry._unchanged."""
760
745
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))
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):
748
# We are letting Branch.create() create a unique inventory
749
# root id. Rather than generating a random one here.
751
# root_id = bzrlib.branch.gen_file_id('TREE_ROOT')
752
self.root = RootEntry(root_id)
845
753
self._byid = {self.root.file_id: self.root}
848
# 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
757
other = Inventory(self.root.file_id)
854
758
# copy recursively so we know directories will be added before
855
759
# their children. There are more efficient ways than this...
856
for path, entry in entries:
760
for path, entry in self.iter_entries():
761
if entry == self.root:
857
763
other.add(entry.copy())
860
767
def __iter__(self):
861
768
return iter(self._byid)
863
771
def __len__(self):
864
772
"""Returns number of entries."""
865
773
return len(self._byid)
867
776
def iter_entries(self, from_dir=None):
868
777
"""Return (path, entry) pairs, in order by name."""
870
if self.root is None:
874
elif isinstance(from_dir, basestring):
875
from_dir = self._byid[from_dir]
877
# unrolling the recursive called changed the time from
878
# 440ms/663ms (inline/total) to 116ms/116ms
879
children = from_dir.children.items()
881
children = collections.deque(children)
882
stack = [(u'', children)]
884
from_dir_relpath, children = stack[-1]
887
name, ie = children.popleft()
889
# we know that from_dir_relpath never ends in a slash
890
# and 'f' doesn't begin with one, we can do a string op, rather
891
# than the checks of pathjoin(), though this means that all paths
893
path = from_dir_relpath + '/' + name
897
if ie.kind != 'directory':
900
# But do this child first
901
new_children = ie.children.items()
903
new_children = collections.deque(new_children)
904
stack.append((path, new_children))
905
# Break out of inner loop, so that we start outer loop with child
908
# 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)
781
elif isinstance(from_dir, basestring):
782
from_dir = self._byid[from_dir]
784
kids = from_dir.children.items()
786
for name, ie in kids:
788
if ie.kind == 'directory':
789
for cn, cie in self.iter_entries(from_dir=ie.file_id):
790
yield pathjoin(name, cn), cie
988
793
def entries(self):
989
794
"""Return list of (path, ie) for all entries except the root.
1072
875
Returns the new entry object.
1074
877
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)
1094
def add_path(self, relpath, kind, file_id=None, parent_id=None):
878
raise BzrError("inventory already contains entry with id {%s}" % entry.file_id)
880
if entry.parent_id == ROOT_ID or entry.parent_id is None:
881
entry.parent_id = self.root.file_id
884
parent = self._byid[entry.parent_id]
886
raise BzrError("parent_id {%s} not in inventory" % entry.parent_id)
888
if parent.children.has_key(entry.name):
889
raise BzrError("%s is already versioned" %
890
pathjoin(self.id2path(parent.file_id), entry.name))
892
self._byid[entry.file_id] = entry
893
parent.children[entry.name] = entry
897
def add_path(self, relpath, kind, file_id=None):
1095
898
"""Add entry from a path.
1097
900
The immediate parent must already be versioned.
1099
902
Returns the new entry object."""
903
from bzrlib.workingtree import gen_file_id
1101
parts = osutils.splitpath(relpath)
905
parts = bzrlib.osutils.splitpath(relpath)
908
file_id = gen_file_id(relpath)
1103
910
if len(parts) == 0:
1105
file_id = generate_ids.gen_root_id()
1106
self.root = InventoryDirectory(file_id, '', None)
911
self.root = RootEntry(file_id)
1107
912
self._byid = {self.root.file_id: self.root}
1110
915
parent_path = parts[:-1]
1111
916
parent_id = self.path2id(parent_path)
1112
if parent_id is None:
1113
raise errors.NotVersionedError(path=parent_path)
1114
ie = make_entry(kind, parts[-1], parent_id, file_id)
917
if parent_id == None:
918
raise NotVersionedError(path=parent_path)
919
if kind == 'directory':
920
ie = InventoryDirectory(file_id, parts[-1], parent_id)
922
ie = InventoryFile(file_id, parts[-1], parent_id)
923
elif kind == 'symlink':
924
ie = InventoryLink(file_id, parts[-1], parent_id)
926
raise BzrError("unknown kind %r" % kind)
1115
927
return self.add(ie)
1117
930
def __delitem__(self, file_id):
1118
931
"""Remove entry by id.
1120
933
>>> inv = Inventory()
1121
934
>>> inv.add(InventoryFile('123', 'foo.c', ROOT_ID))
1122
InventoryFile('123', 'foo.c', parent_id='TREE_ROOT', sha1=None, len=None)
935
InventoryFile('123', 'foo.c', parent_id='TREE_ROOT')
1123
936
>>> '123' in inv
1125
938
>>> del inv['123']
1284
1087
file_ie.name = new_name
1285
1088
file_ie.parent_id = new_parent_id
1287
def is_root(self, file_id):
1288
return self.root is not None and file_id == self.root.file_id
1292
'directory': InventoryDirectory,
1293
'file': InventoryFile,
1294
'symlink': InventoryLink,
1295
'tree-reference': TreeReference
1298
def make_entry(kind, name, parent_id, file_id=None):
1299
"""Create an inventory entry.
1301
:param kind: the type of inventory entry to create.
1302
:param name: the basename of the entry.
1303
:param parent_id: the parent_id of the entry.
1304
:param file_id: the file_id to use. if None, one will be created.
1307
file_id = generate_ids.gen_file_id(name)
1308
name = ensure_normalized_name(name)
1310
factory = entry_factory[kind]
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)
1338
1093
_NAME_RE = None
1340
1095
def is_valid_name(name):
1341
1096
global _NAME_RE
1342
if _NAME_RE is None:
1097
if _NAME_RE == None:
1343
1098
_NAME_RE = re.compile(r'^[^/\\]+$')
1345
1100
return bool(_NAME_RE.match(name))
added
removed
bzrlib/inventory.py
