From 1bfd4abb966c7d76b28376660833fb931bdb6804 Mon Sep 17 00:00:00 2001 From: Jon Michael Aanes Date: Sat, 10 Jun 2017 23:17:30 +0200 Subject: [PATCH] Added `is_uniform` predicate to `analyse_structure.lua`. --- analyze_structure.lua | 21 ++++++ test/test_analyze_structure.lua | 110 ++++++++++++++++++++++---------- 2 files changed, 97 insertions(+), 34 deletions(-) diff --git a/analyze_structure.lua b/analyze_structure.lua index 2aef1e2..4172e4e 100644 --- a/analyze_structure.lua +++ b/analyze_structure.lua @@ -158,6 +158,26 @@ local function is_tabular (t) end end + return children_keys +end + +local function has_uniform_structure (t) + -- TODO: This can probably be more relaxed. Maybe combine string, number and boolean? + + assert(type(t) == 'table') + + -- Find the key and value types. + local first_key = next(t) + if first_key == nil then return true end + local key_type, value_type = type(first_key), type(t[first_key]) + + -- Ensure every other key value pair is the same. + for key, value in pairs(t) do + if type(key) ~= key_type or type(value) ~= value_type then + return false + end + end + return true end @@ -175,6 +195,7 @@ local function get_table_info (t) info.has_map = info.map_elems > 0 info.is_set = is_set(t) and info.nr_elems >= MINIMUM_NUMBER_OF_SET_ELEMENTS info.is_tabular = is_tabular(t) + info.is_uniform = has_uniform_structure(t) -- Determine type of table if not info.has_seq and not info.has_map then info.type = TABLE_TYPE.EMPTY diff --git a/test/test_analyze_structure.lua b/test/test_analyze_structure.lua index edba5c7..7e027a2 100644 --- a/test/test_analyze_structure.lua +++ b/test/test_analyze_structure.lua @@ -12,117 +12,117 @@ SUITE:addTest('Empty Table', function () local input = {} -- Empty! local table_info = analyze_structure(input)[input] - assert(table_info.type == TABLE_TYPE.EMPTY, 'Returned bad type: '..table_info.type) - assert(table_info.has_seq == false) - assert(table_info.has_map == false) + assert_equal(table_info.type, TABLE_TYPE.EMPTY, 'Returned bad type: '..table_info.type) + assert_equal(table_info.has_seq, false) + assert_equal(table_info.has_map, false) end) SUITE:addTest('Sequence', function () local input = { 1, 2, 3 } local table_info = analyze_structure(input)[input] - assert(table_info.type == TABLE_TYPE.SEQUENCE, 'Returned bad type: '..table_info.type) - assert(table_info.has_seq == true) - assert(table_info.has_map == false) + assert_equal(table_info.type, TABLE_TYPE.SEQUENCE, 'Returned bad type: '..table_info.type) + assert_equal(table_info.has_seq, true) + assert_equal(table_info.has_map, false) end) SUITE:addTest('Sequence with holes', function () local input = { 1, nil, 3 } local table_info = analyze_structure(input)[input] - assert(table_info.type == TABLE_TYPE.SEQUENCE, 'Returned bad type: '..table_info.type) - assert(table_info.has_seq == true) - assert(table_info.has_map == false) - assert(table_info.has_holes == true) + assert_equal(table_info.type, TABLE_TYPE.SEQUENCE, 'Returned bad type: '..table_info.type) + assert_equal(table_info.has_seq, true) + assert_equal(table_info.has_map, false) + assert_equal(table_info.has_holes, true) end) SUITE:addTest('Sequence with hole on start', function () local input = { nil, 2, 3 } local table_info = analyze_structure(input)[input] - assert(table_info.type == TABLE_TYPE.SEQUENCE, 'Returned bad type: '..table_info.type) - assert(table_info.has_seq == true) - assert(table_info.has_map == false) - assert(table_info.has_holes == true) + assert_equal(table_info.type, TABLE_TYPE.SEQUENCE, 'Returned bad type: '..table_info.type) + assert_equal(table_info.has_seq, true) + assert_equal(table_info.has_map, false) + assert_equal(table_info.has_holes, true) end) SUITE:addTest('Pure Map', function () local input = { a = 1, [true] = 2, c = 3 } local table_info = analyze_structure(input)[input] - assert(table_info.type == TABLE_TYPE.PURE_MAP, 'Returned bad type: '..table_info.type) - assert(table_info.has_seq == false) - assert(table_info.has_map == true) + assert_equal(table_info.type, TABLE_TYPE.PURE_MAP, 'Returned bad type: '..table_info.type) + assert_equal(table_info.has_seq, false) + assert_equal(table_info.has_map, true) end) SUITE:addTest('Boolean set', function () local input = { [true] = true, [false] = false } local table_info = analyze_structure(input)[input] - assert(table_info.type == TABLE_TYPE.SET, 'Returned bad type: '..table_info.type) - assert(table_info.has_seq == false) - assert(table_info.has_map == true) + assert_equal(table_info.type, TABLE_TYPE.SET, 'Returned bad type: '..table_info.type) + assert_equal(table_info.has_seq, false) + assert_equal(table_info.has_map, true) end) SUITE:addTest('A Mixed table', function () local input = { 300, [300] = 1 } local table_info = analyze_structure(input)[input] - assert(table_info.has_seq == true) - assert(table_info.has_map == true) - assert(table_info.type == TABLE_TYPE.MIXED, 'Returned bad type: '..table_info.type) + assert_equal(table_info.has_seq, true) + assert_equal(table_info.has_map, true) + assert_equal(table_info.type, TABLE_TYPE.MIXED, 'Returned bad type: '..table_info.type) end) SUITE:addTest('String Map', function () local input = { a = 1, b = 2, c = 3 } local table_info = analyze_structure(input)[input] - assert(table_info.type == TABLE_TYPE.STRING_MAP, 'Returned bad type: '..table_info.type) - assert(table_info.has_seq == false) - assert(table_info.has_map == true) + assert_equal(table_info.type, TABLE_TYPE.STRING_MAP, 'Returned bad type: '..table_info.type) + assert_equal(table_info.has_seq, false) + assert_equal(table_info.has_map, true) end) SUITE:addTest('Set', function () local input = { a = true, b = true, c = true } local table_info = analyze_structure(input)[input] - assert(table_info.type == TABLE_TYPE.SET, 'Returned bad type: '..table_info.type) - assert(table_info.is_set == true) + assert_equal(table_info.type, TABLE_TYPE.SET, 'Returned bad type: '..table_info.type) + assert_equal(table_info.is_set, true) end) SUITE:addTest('Tabular of sequences', function () local input = { a = {1, 2, 3}, b = {4, 5, 6}, c = {7, 8, 9} } local table_info = analyze_structure(input)[input] - assert(table_info.is_tabular == true) + assert_equal(table_info.is_tabular, {true, true, true}) end) SUITE:addTest('Tabular of maps', function () local input = { a = {a = 1, b = 2}, b = {a = 3, b = 4}, c = {a = 2, b = 7} } local table_info = analyze_structure(input)[input] - assert(table_info.is_tabular == true) + assert_equal(table_info.is_tabular, {a = true, b = true}) end) SUITE:addTest('Not Tabular, due to no-sub-tables', function () local input = { a = 1, b = {4}, c = 7 } local table_info = analyze_structure(input)[input] - assert(table_info.is_tabular == false) + assert_equal(table_info.is_tabular, false) end) SUITE:addTest('Not Tabular, due to not being identical sub-tables', function () local input = { a = { a = 1 }, b = { b = 2 }, c = { c = 3 } } local table_info = analyze_structure(input)[input] - assert(table_info.is_tabular == false) + assert_equal(table_info.is_tabular, false) end) SUITE:addTest('Not Tabular, due to varying lengths', function () local input = { { 1 }, { 2, 3 }, { 4, 5, 6 } } local table_info = analyze_structure(input)[input] - assert(table_info.is_tabular == false) + assert_equal(table_info.is_tabular, false) end) -------------------------------------------------------------------------------- @@ -132,7 +132,7 @@ SUITE:addTest('goto is special', function () local input = { ['goto'] = 'hi' } local table_info = analyze_structure(input)[input] - assert(table_info.type == TABLE_TYPE.PURE_MAP, 'Returned bad type: '..table_info.type) + assert_equal(table_info.type, TABLE_TYPE.PURE_MAP, 'Returned bad type: '..table_info.type) end) -------------------------------------------------------------------------------- @@ -189,6 +189,48 @@ SUITE:addTest('Can count elements, even though metatable.__index throws errors', assert_equal(info[input].seq_elems, 2) end) +-------------------------------------------------------------------------------- +-- Uniform structure + +SUITE:addTest('Can detect uniform structure', function () + local input = { a = 'b', b = 'a' } + local info = analyze_structure(input) + + assert_equal(info[input].is_uniform, true) +end) + +SUITE:addTest('Can detect uniform structure with different key value types', function () + local input = { a = 1, b = 4 } + local info = analyze_structure(input) + + assert_equal(info[input].is_uniform, true) +end) + +SUITE:addTest('Can detect basic non-uniform structure', function () + local input = { a = 'b', b = 5 } + local info = analyze_structure(input) + + assert_equal(info[input].is_uniform, false) +end) + +SUITE:addTest('Can detect pseudo-uniform structure with nested tables', function () + -- It's pseudo-uniform because of the child having uniform structure with + -- equal number of elements. + local input = { a = { d = 7 }, b = { p = 3 } } + local info = analyze_structure(input) + + assert_equal(info[input].is_uniform, true) +end) + +SUITE:addTest('Can detect non-uniform structure with nested tables', function () + local input = { a = { 'a', 'b', 'c' }, b = { p = 3, 'hi' } } + local info = analyze_structure(input) + + assert_equal(info[input].is_uniform, false) +end) + +-- TODO: Add predicate to check for pseudo-uniformness. + -------------------------------------------------------------------------------- -- API stuff