Rev 2629: Change bzrlib.index.Index keys to be 1-tuples, not strings. in http://people.ubuntu.com/~robertc/baz2.0/index
Robert Collins
robertc at robertcollins.net
Fri Jul 27 06:46:51 BST 2007
At http://people.ubuntu.com/~robertc/baz2.0/index
------------------------------------------------------------
revno: 2629
revision-id: robertc at robertcollins.net-20070727054646-muk3ote4u3l91dea
parent: robertc at robertcollins.net-20070726234827-6kstsjyi2p5kvtfk
committer: Robert Collins <robertc at robertcollins.net>
branch nick: index
timestamp: Fri 2007-07-27 15:46:46 +1000
message:
Change bzrlib.index.Index keys to be 1-tuples, not strings.
modified:
bzrlib/index.py index.py-20070712131115-lolkarso50vjr64s-1
bzrlib/knit.py knit.py-20051212171256-f056ac8f0fbe1bd9
bzrlib/tests/test_index.py test_index.py-20070712131115-lolkarso50vjr64s-2
bzrlib/tests/test_knit.py test_knit.py-20051212171302-95d4c00dd5f11f2b
=== modified file 'bzrlib/index.py'
--- a/bzrlib/index.py 2007-07-18 06:15:59 +0000
+++ b/bzrlib/index.py 2007-07-27 05:46:46 +0000
@@ -63,18 +63,30 @@
"""
self.reference_lists = reference_lists
self._nodes = {}
+ self._key_length = 1
+
+ def _check_key(self, key):
+ """Raise BadIndexKey if key is not a valid key for this index."""
+ if type(key) != tuple:
+ raise errors.BadIndexKey(key)
+ if self._key_length != len(key):
+ raise errors.BadIndexKey(key)
+ key = key[0]
+ if not key or _whitespace_re.search(key) is not None:
+ raise errors.BadIndexKey(key)
def add_node(self, key, value, references=()):
"""Add a node to the index.
- :param key: The key. keys must be whitespace-free utf8.
+ :param key: The key. keys are non-empty tuples containing
+ as many whitespace-free utf8 bytestrings as the key length
+ defined for this index.
:param references: An iterable of iterables of keys. Each is a
reference to another key.
:param value: The value to associate with the key. It may be any
bytes as long as it does not contain \0 or \n.
"""
- if not key or _whitespace_re.search(key) is not None:
- raise errors.BadIndexKey(key)
+ self._check_key(key)
if _newline_null_re.search(value) is not None:
raise errors.BadIndexValue(value)
if len(references) != self.reference_lists:
@@ -82,8 +94,7 @@
node_refs = []
for reference_list in references:
for reference in reference_list:
- if _whitespace_re.search(reference) is not None:
- raise errors.BadIndexKey(reference)
+ self._check_key(reference)
if reference not in self._nodes:
self._nodes[reference] = ('a', (), '')
node_refs.append(tuple(reference_list))
@@ -125,7 +136,10 @@
# date - saves reaccumulating on the second pass
key_offset_info.append((key, non_ref_bytes, total_references))
# key is literal, value is literal, there are 3 null's, 1 NL
- non_ref_bytes += len(key) + len(value) + 3 + 1
+ # key is variable length tuple,
+ non_ref_bytes += sum(len(element) for element in key)
+ # value is literal bytes, there are 3 null's, 1 NL.
+ non_ref_bytes += len(value) + 3 + 1
# one byte for absent if set.
if absent:
non_ref_bytes += 1
@@ -159,14 +173,15 @@
for reference in ref_list:
ref_addresses.append(format_string % key_addresses[reference])
flattened_references.append('\r'.join(ref_addresses))
- lines.append("%s\0%s\0%s\0%s\n" % (key, absent,
+ string_key = key[0]
+ lines.append("%s\0%s\0%s\0%s\n" % (string_key, absent,
'\t'.join(flattened_references), value))
lines.append('\n')
result = StringIO(''.join(lines))
- if expected_bytes and len(result.getvalue()) != expected_bytes:
- raise errors.BzrError('Failed index creation. Internal error:'
- ' mismatched output length and expected length: %d %d' %
- (len(result.getvalue()), expected_bytes))
+ #if expected_bytes and len(result.getvalue()) != expected_bytes:
+ # raise errors.BzrError('Failed index creation. Internal error:'
+ # ' mismatched output length and expected length: %d %d' %
+ # (len(result.getvalue()), expected_bytes))
return StringIO(''.join(lines))
@@ -218,6 +233,8 @@
trailers += 1
continue
key, absent, references, value = line.split('\0')
+ # keys are tuples
+ key = (key, )
value = value[:-1] # remove the newline
ref_lists = []
for ref_string in references.split('\t'):
=== modified file 'bzrlib/knit.py'
--- a/bzrlib/knit.py 2007-07-25 00:52:21 +0000
+++ b/bzrlib/knit.py 2007-07-27 05:46:46 +0000
@@ -1376,21 +1376,24 @@
raise KnitCorrupt(self, "Cannot do delta compression without "
"parent tracking.")
- def _get_entries(self, version_ids, check_present=False):
- """Get the entries for version_ids."""
- version_ids = set(version_ids)
+ def _get_entries(self, keys, check_present=False):
+ """Get the entries for keys.
+
+ :param keys: An iterable of index keys, - 1-tuples.
+ """
+ keys = set(keys)
found_keys = set()
if self._parents:
- for node in self._graph_index.iter_entries(version_ids):
+ for node in self._graph_index.iter_entries(keys):
yield node
found_keys.add(node[0])
else:
# adapt parentless index to the rest of the code.
- for node in self._graph_index.iter_entries(version_ids):
+ for node in self._graph_index.iter_entries(keys):
yield node[0], node[1], ()
found_keys.add(node[0])
if check_present:
- missing_keys = version_ids.difference(found_keys)
+ missing_keys = keys.difference(found_keys)
if missing_keys:
raise RevisionNotPresent(missing_keys.pop(), self)
@@ -1400,11 +1403,12 @@
def _parentless_ancestry(self, versions):
"""Honour the get_ancestry API for parentless knit indices."""
- present_keys = self._present_keys(versions)
- missing = set(versions).difference(present_keys)
+ wanted_keys = self._version_ids_to_keys(versions)
+ present_keys = self._present_keys(wanted_keys)
+ missing = set(wanted_keys).difference(present_keys)
if missing:
raise RevisionNotPresent(missing.pop(), self)
- return list(present_keys)
+ return list(self._keys_to_version_ids(present_keys))
def get_ancestry(self, versions, topo_sorted=True):
"""See VersionedFile.get_ancestry."""
@@ -1415,7 +1419,7 @@
# get a graph of all the mentioned versions:
graph = {}
ghosts = set()
- versions = set(versions)
+ versions = self._version_ids_to_keys(versions)
pending = set(versions)
while pending:
# get all pending nodes
@@ -1435,9 +1439,11 @@
pending.difference_update(graph)
if versions.difference(graph):
raise RevisionNotPresent(versions.difference(graph).pop(), self)
- if not topo_sorted:
- return graph.keys()
- return topo_sort(graph.items())
+ if topo_sorted:
+ result_keys = topo_sort(graph.items())
+ else:
+ result_keys = graph.iterkeys()
+ return [key[0] for key in result_keys]
def get_ancestry_with_ghosts(self, versions):
"""See VersionedFile.get_ancestry."""
@@ -1447,7 +1453,7 @@
# it should be altered to be a index core feature?
# get a graph of all the mentioned versions:
graph = {}
- versions = set(versions)
+ versions = self._version_ids_to_keys(versions)
pending = set(versions)
while pending:
# get all pending nodes
@@ -1467,14 +1473,17 @@
graph[missing_version] = []
# dont examine known nodes
pending.difference_update(graph)
- return topo_sort(graph.items())
+ result_keys = topo_sort(graph.items())
+ return [key[0] for key in result_keys]
def get_graph(self):
"""Return a list of the node:parents lists from this knit index."""
if not self._parents:
return [(key, ()) for key in self.get_versions()]
- return [(key, refs[0]) for (key, value, refs) in
- self._graph_index.iter_all_entries()]
+ result = []
+ for key, value, refs in self._graph_index.iter_all_entries():
+ result.append((key[0], tuple([ref[0] for ref in refs[0]])))
+ return result
def iter_parents(self, version_ids):
"""Iterate through the parents for many version ids.
@@ -1486,7 +1495,7 @@
the underlying implementation.
"""
if self._parents:
- all_nodes = set(self._get_entries(version_ids))
+ all_nodes = set(self._get_entries(self._version_ids_to_keys(version_ids)))
all_parents = set()
present_parents = set()
for node in all_nodes:
@@ -1499,11 +1508,11 @@
parents = []
for parent in node[2][0]:
if parent in present_parents:
- parents.append(parent)
- yield node[0], tuple(parents)
+ parents.append(parent[0])
+ yield node[0][0], tuple(parents)
else:
- for node in self._get_entries(version_ids):
- yield node[0], ()
+ for node in self._get_entries(self._version_ids_to_keys(version_ids)):
+ yield node[0][0], ()
def num_versions(self):
return len(list(self._graph_index.iter_all_entries()))
@@ -1512,11 +1521,14 @@
def get_versions(self):
"""Get all the versions in the file. not topologically sorted."""
- return [node[0] for node in self._graph_index.iter_all_entries()]
+ return [node[0][0] for node in self._graph_index.iter_all_entries()]
def has_version(self, version_id):
"""True if the version is in the index."""
- return len(self._present_keys([version_id])) == 1
+ return len(self._present_keys(self._version_ids_to_keys([version_id]))) == 1
+
+ def _keys_to_version_ids(self, keys):
+ return tuple(key[0] for key in keys)
def get_position(self, version_id):
"""Return data position and size of specified version."""
@@ -1537,7 +1549,7 @@
return 'fulltext'
def _get_node(self, version_id):
- return list(self._get_entries([version_id]))[0]
+ return list(self._get_entries(self._version_ids_to_keys([version_id])))[0]
def get_options(self, version_id):
"""Return a string represention options.
@@ -1563,16 +1575,17 @@
def get_parents_with_ghosts(self, version_id):
"""Return parents of specified version with ghosts."""
- nodes = list(self._get_entries([version_id], check_present=True))
+ nodes = list(self._get_entries(self._version_ids_to_keys([version_id]),
+ check_present=True))
if not self._parents:
return ()
- return nodes[0][2][0]
+ return self._keys_to_version_ids(nodes[0][2][0])
def check_versions_present(self, version_ids):
"""Check that all specified versions are present."""
- version_ids = set(version_ids)
- present = self._present_keys(version_ids)
- missing = version_ids.difference(present)
+ keys = self._version_ids_to_keys(version_ids)
+ present = self._present_keys(keys)
+ missing = keys.difference(present)
if missing:
raise RevisionNotPresent(missing.pop(), self)
@@ -1599,6 +1612,9 @@
keys = {}
for (version_id, options, pos, size, parents) in versions:
+ # index keys are tuples:
+ key = (version_id, )
+ parents = tuple((parent, ) for parent in parents)
if 'no-eol' in options:
value = 'N'
else:
@@ -1610,17 +1626,17 @@
if self._parents:
if self._deltas:
if 'line-delta' in options:
- node_refs = (tuple(parents), (parents[0],))
+ node_refs = (parents, (parents[0],))
else:
- node_refs = (tuple(parents), ())
+ node_refs = (parents, ())
else:
- node_refs = (tuple(parents), )
+ node_refs = (parents, )
else:
if parents:
raise KnitCorrupt(self, "attempt to add node with parents "
"in parentless index.")
node_refs = ()
- keys[version_id] = (value, node_refs)
+ keys[key] = (value, node_refs)
present_nodes = self._get_entries(keys)
for (key, value, node_refs) in present_nodes:
if (value, node_refs) != keys[key]:
@@ -1636,6 +1652,9 @@
result.append((key, value))
self._add_callback(result)
+ def _version_ids_to_keys(self, version_ids):
+ return set((version_id, ) for version_id in version_ids)
+
class _KnitData(_KnitComponentFile):
"""Contents of the knit data file"""
=== modified file 'bzrlib/tests/test_index.py'
--- a/bzrlib/tests/test_index.py 2007-07-18 04:46:24 +0000
+++ b/bzrlib/tests/test_index.py 2007-07-27 05:46:46 +0000
@@ -43,7 +43,7 @@
def test_build_index_one_node_no_refs(self):
builder = GraphIndexBuilder()
- builder.add_node('akey', 'data')
+ builder.add_node(('akey', ), 'data')
stream = builder.finish()
contents = stream.read()
self.assertEqual("Bazaar Graph Index 1\nnode_ref_lists=0\n"
@@ -51,7 +51,7 @@
def test_build_index_one_node_no_refs_accepts_empty_reflist(self):
builder = GraphIndexBuilder()
- builder.add_node('akey', 'data', ())
+ builder.add_node(('akey', ), 'data', ())
stream = builder.finish()
contents = stream.read()
self.assertEqual("Bazaar Graph Index 1\nnode_ref_lists=0\n"
@@ -59,7 +59,7 @@
def test_add_node_empty_value(self):
builder = GraphIndexBuilder()
- builder.add_node('akey', '')
+ builder.add_node(('akey', ), '')
stream = builder.finish()
contents = stream.read()
self.assertEqual("Bazaar Graph Index 1\nnode_ref_lists=0\n"
@@ -71,9 +71,9 @@
# use three to have a good chance of glitching dictionary hash
# lookups etc. Insert in randomish order that is not correct
# and not the reverse of the correct order.
- builder.add_node('2002', 'data')
- builder.add_node('2000', 'data')
- builder.add_node('2001', 'data')
+ builder.add_node(('2002', ), 'data')
+ builder.add_node(('2000', ), 'data')
+ builder.add_node(('2001', ), 'data')
stream = builder.finish()
contents = stream.read()
self.assertEqual("Bazaar Graph Index 1\nnode_ref_lists=0\n"
@@ -84,7 +84,7 @@
def test_build_index_reference_lists_are_included_one(self):
builder = GraphIndexBuilder(reference_lists=1)
- builder.add_node('key', 'data', ([], ))
+ builder.add_node(('key', ), 'data', ([], ))
stream = builder.finish()
contents = stream.read()
self.assertEqual("Bazaar Graph Index 1\nnode_ref_lists=1\n"
@@ -93,7 +93,7 @@
def test_build_index_reference_lists_are_included_two(self):
builder = GraphIndexBuilder(reference_lists=2)
- builder.add_node('key', 'data', ([], []))
+ builder.add_node(('key', ), 'data', ([], []))
stream = builder.finish()
contents = stream.read()
self.assertEqual("Bazaar Graph Index 1\nnode_ref_lists=2\n"
@@ -102,8 +102,8 @@
def test_node_references_are_byte_offsets(self):
builder = GraphIndexBuilder(reference_lists=1)
- builder.add_node('reference', 'data', ([], ))
- builder.add_node('key', 'data', (['reference'], ))
+ builder.add_node(('reference', ), 'data', ([], ))
+ builder.add_node(('key', ), 'data', ([('reference', )], ))
stream = builder.finish()
contents = stream.read()
self.assertEqual("Bazaar Graph Index 1\nnode_ref_lists=1\n"
@@ -113,9 +113,9 @@
def test_node_references_are_cr_delimited(self):
builder = GraphIndexBuilder(reference_lists=1)
- builder.add_node('reference', 'data', ([], ))
- builder.add_node('reference2', 'data', ([], ))
- builder.add_node('key', 'data', (['reference', 'reference2'], ))
+ builder.add_node(('reference', ), 'data', ([], ))
+ builder.add_node(('reference2', ), 'data', ([], ))
+ builder.add_node(('key', ), 'data', ([('reference', ), ('reference2', )], ))
stream = builder.finish()
contents = stream.read()
self.assertEqual("Bazaar Graph Index 1\nnode_ref_lists=1\n"
@@ -126,8 +126,8 @@
def test_multiple_reference_lists_are_tab_delimited(self):
builder = GraphIndexBuilder(reference_lists=2)
- builder.add_node('keference', 'data', ([], []))
- builder.add_node('rey', 'data', (['keference'], ['keference']))
+ builder.add_node(('keference', ), 'data', ([], []))
+ builder.add_node(('rey', ), 'data', ([('keference', )], [('keference', )]))
stream = builder.finish()
contents = stream.read()
self.assertEqual("Bazaar Graph Index 1\nnode_ref_lists=2\n"
@@ -137,7 +137,7 @@
def test_add_node_referencing_missing_key_makes_absent(self):
builder = GraphIndexBuilder(reference_lists=1)
- builder.add_node('rey', 'data', (['beference', 'aeference2'], ))
+ builder.add_node(('rey', ), 'data', ([('beference', ), ('aeference2', )], ))
stream = builder.finish()
contents = stream.read()
self.assertEqual("Bazaar Graph Index 1\nnode_ref_lists=1\n"
@@ -149,8 +149,8 @@
def test_node_references_three_digits(self):
# test the node digit expands as needed.
builder = GraphIndexBuilder(reference_lists=1)
- references = map(str, reversed(range(9)))
- builder.add_node('2-key', '', (references, ))
+ references = [(str(val), ) for val in reversed(range(9))]
+ builder.add_node(('2-key', ), '', (references, ))
stream = builder.finish()
contents = stream.read()
self.assertEqual("Bazaar Graph Index 1\nnode_ref_lists=1\n"
@@ -170,7 +170,7 @@
# the offsets after an absent record should be correct when there are
# >1 reference lists.
builder = GraphIndexBuilder(reference_lists=2)
- builder.add_node('parent', '', (['aail', 'zther'], []))
+ builder.add_node(('parent', ), '', ([('aail', ), ('zther', )], []))
stream = builder.finish()
contents = stream.read()
self.assertEqual("Bazaar Graph Index 1\nnode_ref_lists=2\n"
@@ -183,60 +183,77 @@
builder = GraphIndexBuilder()
for bad_char in '\t\n\x0b\x0c\r\x00 ':
self.assertRaises(errors.BadIndexKey, builder.add_node,
- 'a%skey' % bad_char, 'data')
- self.assertRaises(errors.BadIndexKey, builder.add_node,
- '', 'data')
+ ('a%skey' % bad_char, ), 'data')
+ self.assertRaises(errors.BadIndexKey, builder.add_node,
+ ('', ), 'data')
+ self.assertRaises(errors.BadIndexKey, builder.add_node,
+ 'not-a-tuple', 'data')
+ # not enough length
+ self.assertRaises(errors.BadIndexKey, builder.add_node,
+ (), 'data')
+ # too long
+ self.assertRaises(errors.BadIndexKey, builder.add_node,
+ ('primary', 'secondary'), 'data')
def test_add_node_bad_data(self):
builder = GraphIndexBuilder()
- self.assertRaises(errors.BadIndexValue, builder.add_node, 'akey',
+ self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
'data\naa')
- self.assertRaises(errors.BadIndexValue, builder.add_node, 'akey',
+ self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
'data\x00aa')
def test_add_node_bad_mismatched_ref_lists_length(self):
builder = GraphIndexBuilder()
- self.assertRaises(errors.BadIndexValue, builder.add_node, 'akey',
+ self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
'data aa', ([], ))
builder = GraphIndexBuilder(reference_lists=1)
- self.assertRaises(errors.BadIndexValue, builder.add_node, 'akey',
+ self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
'data aa')
- self.assertRaises(errors.BadIndexValue, builder.add_node, 'akey',
+ self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
'data aa', (), )
- self.assertRaises(errors.BadIndexValue, builder.add_node, 'akey',
+ self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
'data aa', ([], []))
builder = GraphIndexBuilder(reference_lists=2)
- self.assertRaises(errors.BadIndexValue, builder.add_node, 'akey',
+ self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
'data aa')
- self.assertRaises(errors.BadIndexValue, builder.add_node, 'akey',
+ self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
'data aa', ([], ))
- self.assertRaises(errors.BadIndexValue, builder.add_node, 'akey',
+ self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
'data aa', ([], [], []))
def test_add_node_bad_key_in_reference_lists(self):
# first list, first key - trivial
builder = GraphIndexBuilder(reference_lists=1)
- self.assertRaises(errors.BadIndexKey, builder.add_node, 'akey',
- 'data aa', (['a key'], ))
+ self.assertRaises(errors.BadIndexKey, builder.add_node, ('akey', ),
+ 'data aa', ([('a key', )], ))
+ # references keys must be tuples too
+ self.assertRaises(errors.BadIndexKey, builder.add_node, ('akey', ),
+ 'data aa', (['not-a-tuple'], ))
+ # not enough length
+ self.assertRaises(errors.BadIndexKey, builder.add_node, ('akey', ),
+ 'data aa', ([()], ))
+ # too long
+ self.assertRaises(errors.BadIndexKey, builder.add_node, ('akey', ),
+ 'data aa', ([('primary', 'secondary')], ))
# need to check more than the first key in the list
- self.assertRaises(errors.BadIndexKey, builder.add_node, 'akey',
- 'data aa', (['agoodkey', 'this is a bad key'], ))
+ self.assertRaises(errors.BadIndexKey, builder.add_node, ('akey', ),
+ 'data aa', ([('agoodkey', ), ('that is a bad key', )], ))
# and if there is more than one list it should be getting checked
# too
builder = GraphIndexBuilder(reference_lists=2)
- self.assertRaises(errors.BadIndexKey, builder.add_node, 'akey',
+ self.assertRaises(errors.BadIndexKey, builder.add_node, ('akey', ),
'data aa', ([], ['a bad key']))
def test_add_duplicate_key(self):
builder = GraphIndexBuilder()
- builder.add_node('key', 'data')
- self.assertRaises(errors.BadIndexDuplicateKey, builder.add_node, 'key',
+ builder.add_node(('key', ), 'data')
+ self.assertRaises(errors.BadIndexDuplicateKey, builder.add_node, ('key', ),
'data')
def test_add_key_after_referencing_key(self):
builder = GraphIndexBuilder(reference_lists=1)
- builder.add_node('key', 'data', (['reference'], ))
- builder.add_node('reference', 'data', ([],))
+ builder.add_node(('key', ), 'data', ([('reference', )], ))
+ builder.add_node(('reference', ), 'data', ([],))
class TestGraphIndex(TestCaseWithMemoryTransport):
@@ -260,34 +277,34 @@
self.assertEqual([], list(index.iter_all_entries()))
def test_iter_all_entries_simple(self):
- index = self.make_index(nodes=[('name', 'data', ())])
- self.assertEqual([('name', 'data')],
+ index = self.make_index(nodes=[(('name', ), 'data', ())])
+ self.assertEqual([(('name', ), 'data')],
list(index.iter_all_entries()))
def test_iter_all_entries_references_resolved(self):
index = self.make_index(1, nodes=[
- ('name', 'data', (['ref'], )),
- ('ref', 'refdata', ([], ))])
- self.assertEqual(set([('name', 'data', (('ref',),)),
- ('ref', 'refdata', ((), ))]),
+ (('name', ), 'data', ([('ref', )], )),
+ (('ref', ), 'refdata', ([], ))])
+ self.assertEqual(set([(('name', ), 'data', ((('ref',),),)),
+ (('ref', ), 'refdata', ((), ))]),
set(index.iter_all_entries()))
def test_iteration_absent_skipped(self):
index = self.make_index(1, nodes=[
- ('name', 'data', (['ref'], ))])
- self.assertEqual(set([('name', 'data', (('ref',),))]),
+ (('name', ), 'data', ([('ref', )], ))])
+ self.assertEqual(set([(('name', ), 'data', ((('ref',),),))]),
set(index.iter_all_entries()))
- self.assertEqual(set([('name', 'data', (('ref',),))]),
- set(index.iter_entries(['name'])))
- self.assertEqual([], list(index.iter_entries(['ref'])))
+ self.assertEqual(set([(('name', ), 'data', ((('ref',),),))]),
+ set(index.iter_entries([('name', )])))
+ self.assertEqual([], list(index.iter_entries([('ref', )])))
def test_iter_all_keys(self):
index = self.make_index(1, nodes=[
- ('name', 'data', (['ref'], )),
- ('ref', 'refdata', ([], ))])
- self.assertEqual(set([('name', 'data', (('ref',),)),
- ('ref', 'refdata', ((), ))]),
- set(index.iter_entries(['name', 'ref'])))
+ (('name', ), 'data', ([('ref', )], )),
+ (('ref', ), 'refdata', ([], ))])
+ self.assertEqual(set([(('name', ), 'data', ((('ref',),),)),
+ (('ref', ), 'refdata', ((), ))]),
+ set(index.iter_entries([('name', ), ('ref', )])))
def test_iter_nothing_empty(self):
index = self.make_index()
@@ -295,7 +312,7 @@
def test_iter_missing_entry_empty(self):
index = self.make_index()
- self.assertEqual([], list(index.iter_entries(['a'])))
+ self.assertEqual([], list(index.iter_entries([('a', )])))
def test_validate_bad_index_errors(self):
trans = self.get_transport()
@@ -321,7 +338,7 @@
self.assertRaises(errors.BadIndexData, index.validate)
def test_validate_missing_end_line_nonempty(self):
- index = self.make_index(2, [('key', '', ([], []))])
+ index = self.make_index(2, [(('key', ), '', ([], []))])
trans = self.get_transport()
content = trans.get_bytes('index')
# truncate the last byte
@@ -333,7 +350,7 @@
index.validate()
def test_validate_no_refs_content(self):
- index = self.make_index(nodes=[('key', 'value', ())])
+ index = self.make_index(nodes=[(('key', ), 'value', ())])
index.validate()
@@ -355,9 +372,9 @@
def test_add_index(self):
index = CombinedGraphIndex([])
- index1 = self.make_index('name', 0, nodes=[('key', '', ())])
+ index1 = self.make_index('name', 0, nodes=[(('key', ), '', ())])
index.insert_index(0, index1)
- self.assertEqual([('key', '')], list(index.iter_all_entries()))
+ self.assertEqual([(('key', ), '')], list(index.iter_all_entries()))
def test_iter_all_entries_empty(self):
index = CombinedGraphIndex([])
@@ -369,31 +386,31 @@
self.assertEqual([], list(index.iter_all_entries()))
def test_iter_all_entries_simple(self):
- index1 = self.make_index('name', nodes=[('name', 'data', ())])
+ index1 = self.make_index('name', nodes=[(('name', ), 'data', ())])
index = CombinedGraphIndex([index1])
- self.assertEqual([('name', 'data')],
+ self.assertEqual([(('name', ), 'data')],
list(index.iter_all_entries()))
def test_iter_all_entries_two_indices(self):
- index1 = self.make_index('name1', nodes=[('name', 'data', ())])
- index2 = self.make_index('name2', nodes=[('2', '', ())])
+ index1 = self.make_index('name1', nodes=[(('name', ), 'data', ())])
+ index2 = self.make_index('name2', nodes=[(('2', ), '', ())])
index = CombinedGraphIndex([index1, index2])
- self.assertEqual([('name', 'data'),
- ('2', '')],
+ self.assertEqual([(('name', ), 'data'),
+ (('2', ), '')],
list(index.iter_all_entries()))
def test_iter_entries_two_indices_dup_key(self):
- index1 = self.make_index('name1', nodes=[('name', 'data', ())])
- index2 = self.make_index('name2', nodes=[('name', 'data', ())])
+ index1 = self.make_index('name1', nodes=[(('name', ), 'data', ())])
+ index2 = self.make_index('name2', nodes=[(('name', ), 'data', ())])
index = CombinedGraphIndex([index1, index2])
- self.assertEqual([('name', 'data')],
- list(index.iter_entries(['name'])))
+ self.assertEqual([(('name', ), 'data')],
+ list(index.iter_entries([('name', )])))
def test_iter_all_entries_two_indices_dup_key(self):
- index1 = self.make_index('name1', nodes=[('name', 'data', ())])
- index2 = self.make_index('name2', nodes=[('name', 'data', ())])
+ index1 = self.make_index('name1', nodes=[(('name', ), 'data', ())])
+ index2 = self.make_index('name2', nodes=[(('name', ), 'data', ())])
index = CombinedGraphIndex([index1, index2])
- self.assertEqual([('name', 'data')],
+ self.assertEqual([(('name', ), 'data')],
list(index.iter_all_entries()))
def test_iter_nothing_empty(self):
@@ -407,50 +424,50 @@
def test_iter_all_keys(self):
index1 = self.make_index('1', 1, nodes=[
- ('name', 'data', (['ref'], ))])
+ (('name', ), 'data', ([('ref', )], ))])
index2 = self.make_index('2', 1, nodes=[
- ('ref', 'refdata', ((), ))])
+ (('ref', ), 'refdata', ((), ))])
index = CombinedGraphIndex([index1, index2])
- self.assertEqual(set([('name', 'data', (('ref', ), )),
- ('ref', 'refdata', ((), ))]),
- set(index.iter_entries(['name', 'ref'])))
+ self.assertEqual(set([(('name', ), 'data', ((('ref', ), ), )),
+ (('ref', ), 'refdata', ((), ))]),
+ set(index.iter_entries([('name', ), ('ref', )])))
def test_iter_all_keys_dup_entry(self):
index1 = self.make_index('1', 1, nodes=[
- ('name', 'data', (['ref'], )),
- ('ref', 'refdata', ([], ))])
+ (('name', ), 'data', ([('ref', )], )),
+ (('ref', ), 'refdata', ([], ))])
index2 = self.make_index('2', 1, nodes=[
- ('ref', 'refdata', ([], ))])
+ (('ref', ), 'refdata', ([], ))])
index = CombinedGraphIndex([index1, index2])
- self.assertEqual(set([('name', 'data', (('ref',),)),
- ('ref', 'refdata', ((), ))]),
- set(index.iter_entries(['name', 'ref'])))
+ self.assertEqual(set([(('name', ), 'data', ((('ref',),),)),
+ (('ref', ), 'refdata', ((), ))]),
+ set(index.iter_entries([('name', ), ('ref', )])))
def test_iter_missing_entry_empty(self):
index = CombinedGraphIndex([])
- self.assertEqual([], list(index.iter_entries(['a'])))
+ self.assertEqual([], list(index.iter_entries([('a', )])))
def test_iter_missing_entry_one_index(self):
index1 = self.make_index('1')
index = CombinedGraphIndex([index1])
- self.assertEqual([], list(index.iter_entries(['a'])))
+ self.assertEqual([], list(index.iter_entries([('a', )])))
def test_iter_missing_entry_two_index(self):
index1 = self.make_index('1')
index2 = self.make_index('2')
index = CombinedGraphIndex([index1, index2])
- self.assertEqual([], list(index.iter_entries(['a'])))
+ self.assertEqual([], list(index.iter_entries([('a', )])))
def test_iter_entry_present_one_index_only(self):
- index1 = self.make_index('1', nodes=[('key', '', ())])
+ index1 = self.make_index('1', nodes=[(('key', ), '', ())])
index2 = self.make_index('2', nodes=[])
index = CombinedGraphIndex([index1, index2])
- self.assertEqual([('key', '')],
- list(index.iter_entries(['key'])))
+ self.assertEqual([(('key', ), '')],
+ list(index.iter_entries([('key', )])))
# and in the other direction
index = CombinedGraphIndex([index2, index1])
- self.assertEqual([('key', '')],
- list(index.iter_entries(['key'])))
+ self.assertEqual([(('key', ), '')],
+ list(index.iter_entries([('key', )])))
def test_validate_bad_child_index_errors(self):
trans = self.get_transport()
@@ -473,22 +490,22 @@
def test_add_nodes_no_refs(self):
index = self.make_index(0)
- index.add_nodes([('name', 'data')])
- index.add_nodes([('name2', ''), ('name3', '')])
+ index.add_nodes([(('name', ), 'data')])
+ index.add_nodes([(('name2', ), ''), (('name3', ), '')])
self.assertEqual(set([
- ('name', 'data'),
- ('name2', ''),
- ('name3', ''),
+ (('name', ), 'data'),
+ (('name2', ), ''),
+ (('name3', ), ''),
]), set(index.iter_all_entries()))
def test_add_nodes(self):
index = self.make_index(1)
- index.add_nodes([('name', 'data', ([],))])
- index.add_nodes([('name2', '', ([],)), ('name3', '', (['r'],))])
+ index.add_nodes([(('name', ), 'data', ([],))])
+ index.add_nodes([(('name2', ), '', ([],)), (('name3', ), '', ([('r', )],))])
self.assertEqual(set([
- ('name', 'data', ((),)),
- ('name2', '', ((),)),
- ('name3', '', (('r',),)),
+ (('name', ), 'data', ((),)),
+ (('name2', ), '', ((),)),
+ (('name3', ), '', ((('r', ), ), )),
]), set(index.iter_all_entries()))
def test_iter_all_entries_empty(self):
@@ -496,34 +513,34 @@
self.assertEqual([], list(index.iter_all_entries()))
def test_iter_all_entries_simple(self):
- index = self.make_index(nodes=[('name', 'data')])
- self.assertEqual([('name', 'data')],
+ index = self.make_index(nodes=[(('name', ), 'data')])
+ self.assertEqual([(('name', ), 'data')],
list(index.iter_all_entries()))
def test_iter_all_entries_references(self):
index = self.make_index(1, nodes=[
- ('name', 'data', (['ref'], )),
- ('ref', 'refdata', ([], ))])
- self.assertEqual(set([('name', 'data', (('ref',),)),
- ('ref', 'refdata', ((), ))]),
+ (('name', ), 'data', ([('ref', )], )),
+ (('ref', ), 'refdata', ([], ))])
+ self.assertEqual(set([(('name', ), 'data', ((('ref', ),),)),
+ (('ref', ), 'refdata', ((), ))]),
set(index.iter_all_entries()))
def test_iteration_absent_skipped(self):
index = self.make_index(1, nodes=[
- ('name', 'data', (['ref'], ))])
- self.assertEqual(set([('name', 'data', (('ref',),))]),
+ (('name', ), 'data', ([('ref', )], ))])
+ self.assertEqual(set([(('name', ), 'data', ((('ref',),),))]),
set(index.iter_all_entries()))
- self.assertEqual(set([('name', 'data', (('ref',),))]),
- set(index.iter_entries(['name'])))
- self.assertEqual([], list(index.iter_entries(['ref'])))
+ self.assertEqual(set([(('name', ), 'data', ((('ref',),),))]),
+ set(index.iter_entries([('name', )])))
+ self.assertEqual([], list(index.iter_entries([('ref', )])))
def test_iter_all_keys(self):
index = self.make_index(1, nodes=[
- ('name', 'data', (['ref'], )),
- ('ref', 'refdata', ([], ))])
- self.assertEqual(set([('name', 'data', (('ref',),)),
- ('ref', 'refdata', ((), ))]),
- set(index.iter_entries(['name', 'ref'])))
+ (('name', ), 'data', ([('ref', )], )),
+ (('ref', ), 'refdata', ([], ))])
+ self.assertEqual(set([(('name', ), 'data', ((('ref',),),)),
+ (('ref', ), 'refdata', ((), ))]),
+ set(index.iter_entries([('name', ), ('ref', )])))
def test_iter_nothing_empty(self):
index = self.make_index()
@@ -538,7 +555,7 @@
index.validate()
def test_validate_no_refs_content(self):
- index = self.make_index(nodes=[('key', 'value')])
+ index = self.make_index(nodes=[(('key', ), 'value')])
index.validate()
=== modified file 'bzrlib/tests/test_knit.py'
--- a/bzrlib/tests/test_knit.py 2007-07-25 00:52:21 +0000
+++ b/bzrlib/tests/test_knit.py 2007-07-27 05:46:46 +0000
@@ -1017,8 +1017,8 @@
self.assertEqualDiff(''.join(k.get_lines('text-1a')), TEXT_1A)
# check the index had the right data added.
self.assertEqual(set([
- ('text-1', ' 0 127', ((), ())),
- ('text-1a', ' 127 140', (('text-1',), ('text-1',))),
+ (('text-1', ), ' 0 127', ((), ())),
+ (('text-1a', ), ' 127 140', ((('text-1', ),), (('text-1', ),))),
]), set(index.iter_all_entries()))
# we should not have a .kndx file
self.assertFalse(get_transport('.').has('test.kndx'))
@@ -1621,19 +1621,21 @@
"""
# build a complex graph across several indices.
if deltas:
+ # delta compression inn the index
index1 = self.make_g_index('1', 2, [
- ('tip', 'N0 100', (['parent'], [], )),
- ('tail', '', ([], []))])
+ (('tip', ), 'N0 100', ([('parent', )], [], )),
+ (('tail', ), '', ([], []))])
index2 = self.make_g_index('2', 2, [
- ('parent', ' 100 78', (['tail', 'ghost'], ['tail'])),
- ('separate', '', ([], []))])
+ (('parent', ), ' 100 78', ([('tail', ), ('ghost', )], [('tail', )])),
+ (('separate', ), '', ([], []))])
else:
+ # just blob location and graph in the index.
index1 = self.make_g_index('1', 1, [
- ('tip', 'N0 100', (['parent'], )),
- ('tail', '', ([], ))])
+ (('tip', ), 'N0 100', ([('parent', )], )),
+ (('tail', ), '', ([], ))])
index2 = self.make_g_index('2', 1, [
- ('parent', ' 100 78', (['tail', 'ghost'], )),
- ('separate', '', ([], ))])
+ (('parent', ), ' 100 78', ([('tail', ), ('ghost', )], )),
+ (('separate', ), '', ([], ))])
combined_index = CombinedGraphIndex([index1, index2])
if catch_adds:
self.combined_index = combined_index
@@ -1777,7 +1779,7 @@
def test_add_version_smoke(self):
index = self.two_graph_index(catch_adds=True)
index.add_version('new', 'fulltext,no-eol', 50, 60, ['separate'])
- self.assertEqual([[('new', 'N50 60', (('separate',),))]],
+ self.assertEqual([[(('new', ), 'N50 60', ((('separate',),),))]],
self.caught_entries)
def test_add_version_delta_not_delta_index(self):
@@ -1819,8 +1821,8 @@
('new', 'fulltext,no-eol', 50, 60, ['separate']),
('new2', 'fulltext', 0, 6, ['new']),
])
- self.assertEqual([('new', 'N50 60', (('separate',),)),
- ('new2', ' 0 6', (('new',),))],
+ self.assertEqual([(('new', ), 'N50 60', ((('separate',),),)),
+ (('new2', ), ' 0 6', ((('new',),),))],
sorted(self.caught_entries[0]))
self.assertEqual(1, len(self.caught_entries))
@@ -1830,8 +1832,8 @@
('new', 'fulltext,no-eol', 50, 60, ['separate']),
('new2', 'line-delta', 0, 6, ['new']),
])
- self.assertEqual([('new', 'N50 60', (('separate',), ())),
- ('new2', ' 0 6', (('new',), ('new',), ))],
+ self.assertEqual([(('new', ), 'N50 60', ((('separate',),), ())),
+ (('new2', ), ' 0 6', ((('new',),), (('new',),), ))],
sorted(self.caught_entries[0]))
self.assertEqual(1, len(self.caught_entries))
@@ -1875,12 +1877,12 @@
def test_iter_parents(self):
index1 = self.make_g_index('1', 1, [
# no parents
- ('r0', 'N0 100', ([], )),
+ (('r0', ), 'N0 100', ([], )),
# 1 parent
- ('r1', '', (['r0'], ))])
+ (('r1', ), '', ([('r0', )], ))])
index2 = self.make_g_index('2', 1, [
# 2 parents
- ('r2', 'N0 100', (['r1', 'r0'], )),
+ (('r2', ), 'N0 100', ([('r1', ), ('r0', )], )),
])
combined_index = CombinedGraphIndex([index1, index2])
index = KnitGraphIndex(combined_index)
@@ -1931,11 +1933,11 @@
"""
# put several versions in the index.
index1 = self.make_g_index('1', 0, [
- ('tip', 'N0 100'),
- ('tail', '')])
+ (('tip', ), 'N0 100'),
+ (('tail', ), '')])
index2 = self.make_g_index('2', 0, [
- ('parent', ' 100 78'),
- ('separate', '')])
+ (('parent', ), ' 100 78'),
+ (('separate', ), '')])
combined_index = CombinedGraphIndex([index1, index2])
if catch_adds:
self.combined_index = combined_index
@@ -2046,7 +2048,7 @@
def test_add_version_smoke(self):
index = self.two_graph_index(catch_adds=True)
index.add_version('new', 'fulltext,no-eol', 50, 60, [])
- self.assertEqual([[('new', 'N50 60')]],
+ self.assertEqual([[(('new', ), 'N50 60')]],
self.caught_entries)
def test_add_version_delta_not_delta_index(self):
@@ -2088,7 +2090,7 @@
('new', 'fulltext,no-eol', 50, 60, []),
('new2', 'fulltext', 0, 6, []),
])
- self.assertEqual([('new', 'N50 60'), ('new2', ' 0 6')],
+ self.assertEqual([(('new', ), 'N50 60'), (('new2', ), ' 0 6')],
sorted(self.caught_entries[0]))
self.assertEqual(1, len(self.caught_entries))
More information about the bazaar-commits
mailing list