80
78
>>> i.add(InventoryDirectory('123', 'src', ROOT_ID))
81
InventoryDirectory('123', 'src', parent_id='TREE_ROOT', revision=None)
79
InventoryDirectory('123', 'src', parent_id='TREE_ROOT')
82
80
>>> i.add(InventoryFile('2323', 'hello.c', parent_id='123'))
83
InventoryFile('2323', 'hello.c', parent_id='123', sha1=None, len=None)
81
InventoryFile('2323', 'hello.c', parent_id='123')
84
82
>>> shouldbe = {0: 'src', 1: pathjoin('src','hello.c')}
85
83
>>> for ix, j in enumerate(i.iter_entries()):
86
84
... print (j[0] == shouldbe[ix], j[1])
88
(True, InventoryDirectory('123', 'src', parent_id='TREE_ROOT', revision=None))
89
(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'))
90
88
>>> i.add(InventoryFile('2323', 'bye.c', '123'))
91
89
Traceback (most recent call last):
93
91
BzrError: inventory already contains entry with id {2323}
94
92
>>> i.add(InventoryFile('2324', 'bye.c', '123'))
95
InventoryFile('2324', 'bye.c', parent_id='123', sha1=None, len=None)
93
InventoryFile('2324', 'bye.c', parent_id='123')
96
94
>>> i.add(InventoryDirectory('2325', 'wibble', '123'))
97
InventoryDirectory('2325', 'wibble', parent_id='123', revision=None)
95
InventoryDirectory('2325', 'wibble', parent_id='123')
98
96
>>> i.path2id('src/wibble')
102
100
>>> i.add(InventoryFile('2326', 'wibble.c', '2325'))
103
InventoryFile('2326', 'wibble.c', parent_id='2325', sha1=None, len=None)
101
InventoryFile('2326', 'wibble.c', parent_id='2325')
105
InventoryFile('2326', 'wibble.c', parent_id='2325', sha1=None, len=None)
103
InventoryFile('2326', 'wibble.c', parent_id='2325')
106
104
>>> for path, entry in i.iter_entries():
108
106
... assert i.path2id(path)
115
113
>>> i.id2path('2326')
116
114
'src/wibble/wibble.c'
119
# Constants returned by describe_change()
121
# TODO: These should probably move to some kind of FileChangeDescription
122
# class; that's like what's inside a TreeDelta but we want to be able to
123
# generate them just for one file at a time.
125
MODIFIED_AND_RENAMED = 'modified and renamed'
117
__slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
118
'text_id', 'parent_id', 'children', 'executable',
121
def _add_text_to_weave(self, new_lines, parents, weave_store, transaction):
122
weave_store.add_text(self.file_id, self.revision, new_lines, parents,
129
125
def detect_changes(self, old_entry):
130
126
"""Return a (text_modified, meta_modified) from this to old_entry.
155
151
output_to, reverse=False):
156
152
"""Perform a diff between two entries of the same kind."""
158
def find_previous_heads(self, previous_inventories,
159
versioned_file_store,
162
"""Return the revisions and entries that directly precede this.
154
def find_previous_heads(self, previous_inventories, entry_weave):
155
"""Return the revisions and entries that directly preceed this.
164
157
Returned as a map from revision to inventory entry.
166
159
This is a map containing the file revisions in all parents
167
160
for which the file exists, and its revision is not a parent of
168
161
any other. If the file is new, the set will be empty.
170
:param versioned_file_store: A store where ancestry data on this
171
file id can be queried.
172
:param transaction: The transaction that queries to the versioned
173
file store should be completed under.
174
:param entry_vf: The entry versioned file, if its already available.
176
163
def get_ancestors(weave, entry):
177
return set(weave.get_ancestry(entry.revision))
178
# revision:ie mapping for each ie found in previous_inventories.
180
# revision:ie mapping with one revision for each head.
164
return set(map(weave.idx_to_name,
165
weave.inclusions([weave.lookup(entry.revision)])))
182
# revision: ancestor list for each head
183
167
head_ancestors = {}
184
# identify candidate head revision ids.
185
168
for inv in previous_inventories:
186
169
if self.file_id in inv:
187
170
ie = inv[self.file_id]
188
171
assert ie.file_id == self.file_id
189
if ie.revision in candidates:
190
# same revision value in two different inventories:
191
# correct possible inconsistencies:
192
# * there was a bug in revision updates with 'x' bit
172
if ie.revision in heads:
173
# fixup logic, there was a bug in revision updates.
174
# with x bit support.
195
if candidates[ie.revision].executable != ie.executable:
196
candidates[ie.revision].executable = False
176
if heads[ie.revision].executable != ie.executable:
177
heads[ie.revision].executable = False
197
178
ie.executable = False
198
179
except AttributeError:
200
# must now be the same.
201
assert candidates[ie.revision] == ie
181
assert heads[ie.revision] == ie
203
# add this revision as a candidate.
204
candidates[ie.revision] = ie
206
# common case optimisation
207
if len(candidates) == 1:
208
# if there is only one candidate revision found
209
# then we can opening the versioned file to access ancestry:
210
# there cannot be any ancestors to eliminate when there is
211
# only one revision available.
212
heads[ie.revision] = ie
215
# eliminate ancestors amongst the available candidates:
216
# heads are those that are not an ancestor of any other candidate
217
# - this provides convergence at a per-file level.
218
for ie in candidates.values():
219
# may be an ancestor of a known head:
220
already_present = 0 != len(
221
[head for head in heads
222
if ie.revision in head_ancestors[head]])
224
# an ancestor of an analyzed candidate.
226
# not an ancestor of a known head:
227
# load the versioned file for this file id if needed
229
entry_vf = versioned_file_store.get_weave_or_empty(
230
self.file_id, transaction)
231
ancestors = get_ancestors(entry_vf, ie)
232
# may knock something else out:
233
check_heads = list(heads.keys())
234
for head in check_heads:
235
if head in ancestors:
236
# this previously discovered 'head' is not
237
# really a head - its an ancestor of the newly
240
head_ancestors[ie.revision] = ancestors
241
heads[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
244
203
def get_tar_item(self, root, dp, now, tree):
330
291
This is a template method, override _check for kind specific
333
:param checker: Check object providing context for the checks;
334
can be used to find out what parts of the repository have already
336
:param rev_id: Revision id from which this InventoryEntry was loaded.
337
Not necessarily the last-changed revision for this file.
338
:param inv: Inventory from which the entry was loaded.
339
:param tree: RevisionTree for this entry.
341
if self.parent_id is not None:
294
if self.parent_id != None:
342
295
if not inv.has_id(self.parent_id):
343
296
raise BzrCheckError('missing parent {%s} in inventory for revision {%s}'
344
297
% (self.parent_id, rev_id))
349
302
raise BzrCheckError('unknown entry kind %r in revision {%s}' %
350
303
(self.kind, rev_id))
353
307
"""Clone this inventory entry."""
354
308
raise NotImplementedError
357
def describe_change(old_entry, new_entry):
358
"""Describe the change between old_entry and this.
360
This smells of being an InterInventoryEntry situation, but as its
361
the first one, we're making it a static method for now.
363
An entry with a different parent, or different name is considered
364
to be renamed. Reparenting is an internal detail.
365
Note that renaming the parent does not trigger a rename for the
368
# TODO: Perhaps return an object rather than just a string
369
if old_entry is new_entry:
370
# also the case of both being None
372
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:
374
elif new_entry is None:
376
text_modified, meta_modified = new_entry.detect_changes(old_entry)
377
if text_modified or meta_modified:
381
# TODO 20060511 (mbp, rbc) factor out 'detect_rename' here.
382
if old_entry.parent_id != new_entry.parent_id:
384
elif old_entry.name != new_entry.name:
388
if renamed and not modified:
389
return InventoryEntry.RENAMED
390
if modified and not renamed:
392
if modified and renamed:
393
return InventoryEntry.MODIFIED_AND_RENAMED
316
return 'modified/renamed/reparented'
396
318
def __repr__(self):
397
return ("%s(%r, %r, parent_id=%r, revision=%r)"
319
return ("%s(%r, %r, parent_id=%r)"
398
320
% (self.__class__.__name__,
404
325
def snapshot(self, revision, path, previous_entries,
405
work_tree, commit_builder):
326
work_tree, weave_store, transaction):
406
327
"""Make a snapshot of this entry which may or may not have changed.
408
329
This means that all its fields are populated, that it has its
419
338
mutter("found unchanged entry")
420
339
self.revision = parent_ie.revision
421
340
return "unchanged"
422
return self._snapshot_into_revision(revision, previous_entries,
423
work_tree, commit_builder)
425
def _snapshot_into_revision(self, revision, previous_entries, work_tree,
427
"""Record this revision unconditionally into a store.
429
The entry's last-changed revision property (`revision`) is updated to
430
that of the new revision.
432
:param revision: id of the new revision that is being recorded.
434
:returns: String description of the commit (e.g. "merged", "modified"), etc.
436
mutter('new revision {%s} for {%s}', revision, self.file_id)
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)
437
348
self.revision = revision
438
self._snapshot_text(previous_entries, work_tree, commit_builder)
349
change = self._get_snapshot_change(previous_entries)
350
self._snapshot_text(previous_entries, work_tree, weave_store,
440
def _snapshot_text(self, file_parents, work_tree, commit_builder):
354
def _snapshot_text(self, file_parents, work_tree, weave_store, transaction):
441
355
"""Record the 'text' of this entry, whatever form that takes.
443
357
This default implementation simply adds an empty text.
445
raise NotImplementedError(self._snapshot_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)
447
363
def __eq__(self, other):
448
364
if not isinstance(other, InventoryEntry):
523
434
class InventoryDirectory(InventoryEntry):
524
435
"""A directory in an inventory."""
526
__slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
527
'text_id', 'parent_id', 'children', 'executable',
528
'revision', 'symlink_target']
530
437
def _check(self, checker, rev_id, tree):
531
438
"""See InventoryEntry._check"""
532
if self.text_sha1 is not None or self.text_size is not None or self.text_id is not None:
439
if self.text_sha1 != None or self.text_size != None or self.text_id != None:
533
440
raise BzrCheckError('directory {%s} has text in revision {%s}'
534
441
% (self.file_id, rev_id))
562
469
"""See InventoryEntry._put_on_disk."""
563
470
os.mkdir(fullpath)
565
def _snapshot_text(self, file_parents, work_tree, commit_builder):
566
"""See InventoryEntry._snapshot_text."""
567
commit_builder.modified_directory(self.file_id, file_parents)
570
473
class InventoryFile(InventoryEntry):
571
474
"""A file in an inventory."""
573
__slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
574
'text_id', 'parent_id', 'children', 'executable',
575
'revision', 'symlink_target']
577
def _check(self, checker, tree_revision_id, tree):
476
def _check(self, checker, rev_id, tree):
578
477
"""See InventoryEntry._check"""
579
t = (self.file_id, self.revision)
478
revision = self.revision
479
t = (self.file_id, revision)
580
480
if t in checker.checked_texts:
581
prev_sha = checker.checked_texts[t]
481
prev_sha = checker.checked_texts[t]
582
482
if prev_sha != self.text_sha1:
583
483
raise BzrCheckError('mismatched sha1 on {%s} in {%s}' %
584
(self.file_id, tree_revision_id))
484
(self.file_id, rev_id))
586
486
checker.repeated_text_cnt += 1
596
496
checker.checked_weaves[self.file_id] = True
598
w = tree.get_weave(self.file_id)
498
w = tree.get_weave_prelude(self.file_id)
600
mutter('check version {%s} of {%s}', tree_revision_id, self.file_id)
601
checker.checked_text_cnt += 1
500
mutter('check version {%s} of {%s}', rev_id, self.file_id)
501
checker.checked_text_cnt += 1
602
502
# We can't check the length, because Weave doesn't store that
603
503
# information, and the whole point of looking at the weave's
604
504
# sha1sum is that we don't have to extract the text.
627
527
def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
628
528
output_to, reverse=False):
629
529
"""See InventoryEntry._diff."""
631
from_text = tree.get_file(self.file_id).readlines()
633
to_text = to_tree.get_file(to_entry.file_id).readlines()
637
text_diff(from_label, from_text,
638
to_label, to_text, output_to)
640
text_diff(to_label, to_text,
641
from_label, from_text, output_to)
644
label_pair = (to_label, from_label)
646
label_pair = (from_label, to_label)
647
print >> output_to, "Binary files %s and %s differ" % label_pair
530
from_text = tree.get_file(self.file_id).readlines()
532
to_text = to_tree.get_file(to_entry.file_id).readlines()
536
text_diff(from_label, from_text,
537
to_label, to_text, output_to)
539
text_diff(to_label, to_text,
540
from_label, from_text, output_to)
649
542
def has_text(self):
650
543
"""See InventoryEntry.has_text."""
678
571
def _read_tree_state(self, path, work_tree):
679
572
"""See InventoryEntry._read_tree_state."""
680
self.text_sha1 = work_tree.get_file_sha1(self.file_id, path=path)
681
# FIXME: 20050930 probe for the text size when getting sha1
682
# in _read_tree_state
683
self.executable = work_tree.is_executable(self.file_id, path=path)
686
return ("%s(%r, %r, parent_id=%r, sha1=%r, len=%s)"
687
% (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)
694
576
def _forget_tree_state(self):
695
577
self.text_sha1 = None
578
self.executable = None
697
def _snapshot_text(self, file_parents, work_tree, commit_builder):
580
def _snapshot_text(self, file_parents, work_tree, weave_store, transaction):
698
581
"""See InventoryEntry._snapshot_text."""
699
def get_content_byte_lines():
700
return work_tree.get_file(self.file_id).readlines()
701
self.text_sha1, self.text_size = commit_builder.modified_file_text(
702
self.file_id, file_parents, get_content_byte_lines, self.text_sha1, self.text_size)
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))
704
601
def _unchanged(self, previous_ie):
705
602
"""See InventoryEntry._unchanged."""
718
615
class InventoryLink(InventoryEntry):
719
616
"""A file in an inventory."""
721
__slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
722
'text_id', 'parent_id', 'children', 'executable',
723
'revision', 'symlink_target']
618
__slots__ = ['symlink_target']
725
620
def _check(self, checker, rev_id, tree):
726
621
"""See InventoryEntry._check"""
727
if self.text_sha1 is not None or self.text_size is not None or self.text_id is not None:
622
if self.text_sha1 != None or self.text_size != None or self.text_id != None:
728
623
raise BzrCheckError('symlink {%s} has text in revision {%s}'
729
624
% (self.file_id, rev_id))
730
if self.symlink_target is None:
625
if self.symlink_target == None:
731
626
raise BzrCheckError('symlink {%s} has no target in revision {%s}'
732
627
% (self.file_id, rev_id))
840
730
May also look up by name:
842
732
>>> [x[0] for x in inv.iter_entries()]
844
734
>>> inv = Inventory('TREE_ROOT-12345678-12345678')
845
735
>>> inv.add(InventoryFile('123-123', 'hello.c', ROOT_ID))
846
InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT-12345678-12345678', sha1=None, len=None)
736
InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT-12345678-12345678')
848
def __init__(self, root_id=ROOT_ID, revision_id=None):
738
def __init__(self, root_id=ROOT_ID):
849
739
"""Create or read an inventory.
851
741
If a working directory is specified, the inventory is read
876
763
other.add(entry.copy())
879
767
def __iter__(self):
880
768
return iter(self._byid)
882
771
def __len__(self):
883
772
"""Returns number of entries."""
884
773
return len(self._byid)
886
776
def iter_entries(self, from_dir=None):
887
777
"""Return (path, entry) pairs, in order by name."""
891
elif isinstance(from_dir, basestring):
892
from_dir = self._byid[from_dir]
894
# unrolling the recursive called changed the time from
895
# 440ms/663ms (inline/total) to 116ms/116ms
896
children = from_dir.children.items()
898
children = collections.deque(children)
899
stack = [(u'', children)]
901
from_dir_relpath, children = stack[-1]
904
name, ie = children.popleft()
906
# we know that from_dir_relpath never ends in a slash
907
# and 'f' doesn't begin with one, we can do a string op, rather
908
# than the checks of pathjoin(), though this means that all paths
910
path = from_dir_relpath + '/' + name
914
if ie.kind != 'directory':
917
# But do this child first
918
new_children = ie.children.items()
920
new_children = collections.deque(new_children)
921
stack.append((path, new_children))
922
# Break out of inner loop, so that we start outer loop with child
925
# if we finished all children, pop it off the stack
928
def iter_entries_by_dir(self, from_dir=None):
929
"""Iterate over the entries in a directory first order.
931
This returns all entries for a directory before returning
932
the entries for children of a directory. This is not
933
lexicographically sorted order, and is a hybrid between
934
depth-first and breadth-first.
936
:return: This yields (path, entry) pairs
938
# TODO? Perhaps this should return the from_dir so that the root is
939
# yielded? or maybe an option?
943
elif isinstance(from_dir, basestring):
944
from_dir = self._byid[from_dir]
946
stack = [(u'', from_dir)]
948
cur_relpath, cur_dir = stack.pop()
951
for child_name, child_ie in sorted(cur_dir.children.iteritems()):
953
child_relpath = cur_relpath + child_name
955
yield child_relpath, child_ie
957
if child_ie.kind == 'directory':
958
child_dirs.append((child_relpath+'/', child_ie))
959
stack.extend(reversed(child_dirs))
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
961
793
def entries(self):
962
794
"""Return list of (path, ie) for all entries except the root.
1006
841
return file_id in self._byid
1008
844
def __getitem__(self, file_id):
1009
845
"""Return the entry for given file_id.
1011
847
>>> inv = Inventory()
1012
848
>>> inv.add(InventoryFile('123123', 'hello.c', ROOT_ID))
1013
InventoryFile('123123', 'hello.c', parent_id='TREE_ROOT', sha1=None, len=None)
849
InventoryFile('123123', 'hello.c', parent_id='TREE_ROOT')
1014
850
>>> inv['123123'].name
1018
854
return self._byid[file_id]
1019
855
except KeyError:
1021
857
raise BzrError("can't look up file_id None")
1023
859
raise BzrError("file_id {%s} not in inventory" % file_id)
1025
862
def get_file_kind(self, file_id):
1026
863
return self._byid[file_id].kind
1028
865
def get_child(self, parent_id, filename):
1029
866
return self[parent_id].children.get(filename)
1031
869
def add(self, entry):
1032
870
"""Add entry to inventory.
1055
893
parent.children[entry.name] = entry
1058
def add_path(self, relpath, kind, file_id=None, parent_id=None):
897
def add_path(self, relpath, kind, file_id=None):
1059
898
"""Add entry from a path.
1061
900
The immediate parent must already be versioned.
1063
902
Returns the new entry object."""
903
from bzrlib.workingtree import gen_file_id
1065
parts = osutils.splitpath(relpath)
905
parts = bzrlib.osutils.splitpath(relpath)
908
file_id = gen_file_id(relpath)
1067
910
if len(parts) == 0:
1069
file_id = bzrlib.workingtree.gen_root_id()
1070
911
self.root = RootEntry(file_id)
1071
912
self._byid = {self.root.file_id: self.root}
1074
915
parent_path = parts[:-1]
1075
916
parent_id = self.path2id(parent_path)
1076
if parent_id is None:
917
if parent_id == None:
1077
918
raise NotVersionedError(path=parent_path)
1078
ie = make_entry(kind, parts[-1], parent_id, file_id)
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)
1079
927
return self.add(ie)
1081
930
def __delitem__(self, file_id):
1082
931
"""Remove entry by id.
1084
933
>>> inv = Inventory()
1085
934
>>> inv.add(InventoryFile('123', 'foo.c', ROOT_ID))
1086
InventoryFile('123', 'foo.c', parent_id='TREE_ROOT', sha1=None, len=None)
935
InventoryFile('123', 'foo.c', parent_id='TREE_ROOT')
1087
936
>>> '123' in inv
1089
938
>>> del inv['123']
1109
959
>>> i1.add(InventoryFile('123', 'foo', ROOT_ID))
1110
InventoryFile('123', 'foo', parent_id='TREE_ROOT', sha1=None, len=None)
960
InventoryFile('123', 'foo', parent_id='TREE_ROOT')
1113
963
>>> i2.add(InventoryFile('123', 'foo', ROOT_ID))
1114
InventoryFile('123', 'foo', parent_id='TREE_ROOT', sha1=None, len=None)
964
InventoryFile('123', 'foo', parent_id='TREE_ROOT')
1118
968
if not isinstance(other, Inventory):
1119
969
return NotImplemented
971
if len(self._byid) != len(other._byid):
972
# shortcut: obviously not the same
1121
975
return self._byid == other._byid
1123
978
def __ne__(self, other):
1124
979
return not self.__eq__(other)
1126
982
def __hash__(self):
1127
983
raise ValueError('not hashable')
1129
def _iter_file_id_parents(self, file_id):
1130
"""Yield the parents of file_id up to the root."""
1131
while file_id is not None:
1133
ie = self._byid[file_id]
1135
raise BzrError("file_id {%s} not found in inventory" % file_id)
1137
file_id = ie.parent_id
1139
986
def get_idpath(self, file_id):
1140
987
"""Return a list of file_ids for the path to an entry.
1228
1088
file_ie.parent_id = new_parent_id
1231
def make_entry(kind, name, parent_id, file_id=None):
1232
"""Create an inventory entry.
1234
:param kind: the type of inventory entry to create.
1235
:param name: the basename of the entry.
1236
:param parent_id: the parent_id of the entry.
1237
:param file_id: the file_id to use. if None, one will be created.
1240
file_id = bzrlib.workingtree.gen_file_id(name)
1242
norm_name, can_access = osutils.normalized_filename(name)
1243
if norm_name != name:
1247
# TODO: jam 20060701 This would probably be more useful
1248
# if the error was raised with the full path
1249
raise errors.InvalidNormalization(name)
1251
if kind == 'directory':
1252
return InventoryDirectory(file_id, name, parent_id)
1253
elif kind == 'file':
1254
return InventoryFile(file_id, name, parent_id)
1255
elif kind == 'symlink':
1256
return InventoryLink(file_id, name, parent_id)
1258
raise BzrError("unknown kind %r" % kind)
1261
1093
_NAME_RE = None
1263
1095
def is_valid_name(name):
1264
1096
global _NAME_RE
1265
if _NAME_RE is None:
1097
if _NAME_RE == None:
1266
1098
_NAME_RE = re.compile(r'^[^/\\]+$')
1268
1100
return bool(_NAME_RE.match(name))
added
removed
bzrlib/inventory.py
