From 2c07a30b5e98d018573271c6ebb6813617c0dc5b Mon Sep 17 00:00:00 2001 From: castlele Date: Tue, 7 Jan 2025 10:32:11 +0300 Subject: [PATCH] [feat]: create new concatenation method for tables --- build.lua | 8 + ...18-0.rockspec => cluautils-1.18-1.rockspec | 4 +- run_tests.sh | 2 +- src/table_utils/table_utils.lua | 14 + src/tests.lua | 35 ++- tests/table_utils_tests.lua | 250 +++++++++++------- 6 files changed, 212 insertions(+), 101 deletions(-) rename cluautils-1.18-0.rockspec => cluautils-1.18-1.rockspec (97%) diff --git a/build.lua b/build.lua index 7d1df59..01534a2 100644 --- a/build.lua +++ b/build.lua @@ -5,10 +5,18 @@ local function runTestsCommand(cmd) return string.format(runner, cmd) end +---@return string +local function getCurrentFileName() + local filePath = vim.fn.expand("%") + local pathComponents = vim.fn.split(filePath, "/") + return pathComponents[#pathComponents] +end + ---@diagnostic disable-next-line conf = { install = "sudo luarocks make", remove = "sudo luarocks remove cluautils", + currentTest = runTestsCommand(getCurrentFileName()), allTest = runTestsCommand("*"), threadTest = [[ bear -- make build diff --git a/cluautils-1.18-0.rockspec b/cluautils-1.18-1.rockspec similarity index 97% rename from cluautils-1.18-0.rockspec rename to cluautils-1.18-1.rockspec index 7d19328..591fc15 100644 --- a/cluautils-1.18-0.rockspec +++ b/cluautils-1.18-1.rockspec @@ -1,8 +1,8 @@ package = "cluautils" -version = "1.18-0" +version = "1.18-1" source = { url = "git://github.com/castlele/cluautils.git", - tag = "1.18.0" + tag = "1.18.1" } description = { homepage = "*** please enter a project homepage ***", diff --git a/run_tests.sh b/run_tests.sh index b91d33b..3acc26d 100755 --- a/run_tests.sh +++ b/run_tests.sh @@ -4,7 +4,7 @@ tests_dir=./tests FILTER=$1 IS_ANY_ERROR=0 -for test_file in $tests_dir/${FILTER}.lua; do +for test_file in $tests_dir/${FILTER}; do lua $test_file if [[ $? -ne 0 ]]; then diff --git a/src/table_utils/table_utils.lua b/src/table_utils/table_utils.lua index da87ba4..c27e0d2 100644 --- a/src/table_utils/table_utils.lua +++ b/src/table_utils/table_utils.lua @@ -57,6 +57,7 @@ function M.is_equal(self, other_table) return true end +---@deprecated Use table.concat() instead ---@param self table ---@param other_table table ---@param element_condition? fun(any):boolean @@ -84,6 +85,19 @@ function M.concat_tables(self, other_table, element_condition) return final_result end +---@param lhs table +---@param rhs table +---@return table +function M.concat(lhs, rhs) + local result = lhs + + for k, v in pairs(rhs) do + result[k] = v + end + + return result +end + ---@generic T ---@param self table ---@param callback fun(element: T):boolean diff --git a/src/tests.lua b/src/tests.lua index d37067d..9bb038b 100644 --- a/src/tests.lua +++ b/src/tests.lua @@ -12,12 +12,11 @@ local colorTable = { } local currentResults = {} - ---@param color ColorTable ---@param str string ---@return string local function colorString(color, str) - return string.format( + return string.format( "%s[%sm%s%s[%sm", string.char(27), color, @@ -34,7 +33,6 @@ local function wrapWith(str, symbol) return symbol .. str .. symbol end - tests.describe = function(label, func) print(colorString(colorTable.YELLOW, "Test cases: " .. wrapWith(label, "'"))) func() @@ -44,7 +42,12 @@ tests.describe = function(label, func) for _, value in pairs(currentResults) do if not value then isAnyFailed = true - print(colorString(colorTable.RED, "Test cases failed: " .. wrapWith(label, "'"))) + print( + colorString( + colorTable.RED, + "Test cases failed: " .. wrapWith(label, "'") + ) + ) end end @@ -52,21 +55,36 @@ tests.describe = function(label, func) os.exit(-1) end - print(colorString(colorTable.YELLOW, "Test cases succeeded: " .. wrapWith(label, "'"))) + print( + colorString( + colorTable.YELLOW, + "Test cases succeeded: " .. wrapWith(label, "'") + ) + ) end tests.it = function(name, func) - local isSuccess = xpcall(func, function (msg) + local isSuccess = xpcall(func, function(msg) if msg then print(msg) end end) if isSuccess then - print(colorString(colorTable.GREEN, "Test " .. wrapWith(name, "'") .. " passed")) + print( + colorString( + colorTable.GREEN, + "Test " .. wrapWith(name, "'") .. " passed" + ) + ) currentResults[name] = true else - print(colorString(colorTable.RED, "Test " .. wrapWith(name, "'") .. " failed")) + print( + colorString( + colorTable.RED, + "Test " .. wrapWith(name, "'") .. " failed" + ) + ) currentResults[name] = false end end @@ -77,5 +95,4 @@ tests.expect = function(condition, message) end end - return tests diff --git a/tests/table_utils_tests.lua b/tests/table_utils_tests.lua index f178a7a..46136b3 100644 --- a/tests/table_utils_tests.lua +++ b/tests/table_utils_tests.lua @@ -6,223 +6,239 @@ TableUtilsTestCase = CTestCase ---@MARK - contains method tests function TableUtilsTestCase:test_table_contains_empty() - local t = {} - local value = "hello" + local t = {} + local value = "hello" - local result = tableutils.contains(t, value) + local result = tableutils.contains(t, value) - return result == false + return result == false end function TableUtilsTestCase:test_table_contains_string() - local t = {"hello", "world"} - local value = "hello" + local t = { "hello", "world" } + local value = "hello" - local result = tableutils.contains(t, value) + local result = tableutils.contains(t, value) - return result + return result end function TableUtilsTestCase:test_table_contains_integer() - local t = {1, 2, 3, 4, 5} - local value = 5 + local t = { 1, 2, 3, 4, 5 } + local value = 5 - local result = tableutils.contains(t, value) + local result = tableutils.contains(t, value) - return result + return result end function TableUtilsTestCase:test_table_does_not_contain_string() - local t = {"hello", "world"} - local value = "castlelecs" + local t = { "hello", "world" } + local value = "castlelecs" - local result = tableutils.contains(t, value) + local result = tableutils.contains(t, value) - return result == false + return result == false end function TableUtilsTestCase:test_table_does_not_contain_integer() - local t = {1, 2, 3, 4, 5} - local value = 0 + local t = { 1, 2, 3, 4, 5 } + local value = 0 - local result = tableutils.contains(t, value) + local result = tableutils.contains(t, value) - return result == false + return result == false end ---@MARK - is_empty method tests function TableUtilsTestCase:test_table_is_empty_true() - local t = {} + local t = {} - local result = tableutils.is_empty(t) + local result = tableutils.is_empty(t) - return result + return result end function TableUtilsTestCase:test_table_is_empty_false() - local t = {1, 2, 3} + local t = { 1, 2, 3 } - local result = tableutils.is_empty(t) + local result = tableutils.is_empty(t) - return result == false + return result == false end ---@MARK - get_index method tests function TableUtilsTestCase:test_table_index_of_non_existing_value() - local t = {1, 2, 3, 4, 5} + local t = { 1, 2, 3, 4, 5 } - local result = tableutils.get_index(t, 6) + local result = tableutils.get_index(t, 6) - return result == nil + return result == nil end function TableUtilsTestCase:test_table_index_of_existing_value() - local t = {1, 2, 3, 4, 5} + local t = { 1, 2, 3, 4, 5 } - local result = tableutils.get_index(t, 5) + local result = tableutils.get_index(t, 5) - return result == #t + return result == #t end ---@MARK - is_equal method tests function TableUtilsTestCase:test_equatability_of_empty_tables() - local t1 = {} - local t2 = {} + local t1 = {} + local t2 = {} - local result = tableutils.is_equal(t1, t2) + local result = tableutils.is_equal(t1, t2) - return result == true + return result == true end function TableUtilsTestCase:test_equatability_of_different_tables() - local t1 = {1, 2, 3} - local t2 = {3, 2, 1} + local t1 = { 1, 2, 3 } + local t2 = { 3, 2, 1 } - local result = tableutils.is_equal(t1, t2) + local result = tableutils.is_equal(t1, t2) - return result == false + return result == false end function TableUtilsTestCase:test_equatability_of_equal_tables() - local t1 = {1, 2, 3} - local t2 = {1, 2, 3} + local t1 = { 1, 2, 3 } + local t2 = { 1, 2, 3 } - local result = tableutils.is_equal(t1, t2) + local result = tableutils.is_equal(t1, t2) - return result == true + return result == true end ---@MARK - concat_tables method tests function TableUtilsTestCase:test_concat_tables_empty_tables() - local t1 = {} - local t2 = {} + local t1 = {} + local t2 = {} - local result = tableutils.concat_tables(t1, t2) + local result = tableutils.concat_tables(t1, t2) - return tableutils.is_equal(result, {}) + return tableutils.is_equal(result, {}) end function TableUtilsTestCase:test_concat_tables_empty_and_none_empty() - local t1 = {} - local t2 = {1, 2, 3} + local t1 = {} + local t2 = { 1, 2, 3 } - local result = tableutils.concat_tables(t1, t2) + local result = tableutils.concat_tables(t1, t2) - return tableutils.is_equal(result, {1, 2, 3}) + return tableutils.is_equal(result, { 1, 2, 3 }) end function TableUtilsTestCase:test_concat_tables_none_empty_and_empty() - local t1 = {1, 2, 3} - local t2 = {} + local t1 = { 1, 2, 3 } + local t2 = {} - local result = tableutils.concat_tables(t1, t2) + local result = tableutils.concat_tables(t1, t2) - return tableutils.is_equal(result, {1, 2, 3}) + return tableutils.is_equal(result, { 1, 2, 3 }) end function TableUtilsTestCase:test_concat_tables_none_empty_tables() - local t1 = {1, 2, 3} - local t2 = {4, 5, 6} + local t1 = { 1, 2, 3 } + local t2 = { 4, 5, 6 } - local result = tableutils.concat_tables(t1, t2) + local result = tableutils.concat_tables(t1, t2) - return tableutils.is_equal(result, {1, 2, 3, 4, 5, 6}) + return tableutils.is_equal(result, { 1, 2, 3, 4, 5, 6 }) end function TableUtilsTestCase:test_concat_tables_with_condition() - local t1 = {1, 2, 3} - local t2 = {4, 5, 6} - local even_num_filter = function (num) - return num % 2 == 0 - end + local t1 = { 1, 2, 3 } + local t2 = { 4, 5, 6 } + local even_num_filter = function(num) + return num % 2 == 0 + end - local result = tableutils.concat_tables(t1, t2, even_num_filter) + local result = tableutils.concat_tables(t1, t2, even_num_filter) - return tableutils.is_equal(result, {2, 4, 6}) + return tableutils.is_equal(result, { 2, 4, 6 }) end ---@MARK - map tests function TableUtilsTestCase:test_map_empty_table() - local testable_table = {} + local testable_table = {} - local result_table = tableutils.map(testable_table, function (value) return value end) + local result_table = tableutils.map(testable_table, function(value) + return value + end) - return tableutils.is_equal(result_table, {}) + return tableutils.is_equal(result_table, {}) end function TableUtilsTestCase:test_map_with_empty_callback() - local testable_table = {1, 2, 3, 4} + local testable_table = { 1, 2, 3, 4 } - local result_table = tableutils.map(testable_table, function (value) return value end) + local result_table = tableutils.map(testable_table, function(value) + return value + end) - return tableutils.is_equal(result_table, testable_table) + return tableutils.is_equal(result_table, testable_table) end function TableUtilsTestCase:test_map_elements_doubled() - local testable_table = {1, 2, 3, 4} + local testable_table = { 1, 2, 3, 4 } - local result_table = tableutils.map(testable_table, function (value) return value * 2 end) + local result_table = tableutils.map(testable_table, function(value) + return value * 2 + end) - return tableutils.is_equal(result_table, {2, 4, 6, 8}) + return tableutils.is_equal(result_table, { 2, 4, 6, 8 }) end function TableUtilsTestCase:test_map_by_key_value_pairs() local testable_table = { greeting = "hello", name = "world" } - local result = tableutils.mapkv(testable_table, function (key, value) return key .. value end) + local result = tableutils.mapkv(testable_table, function(key, value) + return key .. value + end) - return #result == 2 and tableutils.contains(result, "greetinghello") and tableutils.contains(result, "nameworld") + return #result == 2 + and tableutils.contains(result, "greetinghello") + and tableutils.contains(result, "nameworld") end ---@MARK - filter tests - function TableUtilsTestCase:test_filter_empty_table() - local testable_table = {} +function TableUtilsTestCase:test_filter_empty_table() + local testable_table = {} - local filtered_table = tableutils.filter(testable_table, function (_) return true end) + local filtered_table = tableutils.filter(testable_table, function(_) + return true + end) - return tableutils.is_equal(filtered_table, {}) + return tableutils.is_equal(filtered_table, {}) end function TableUtilsTestCase:test_filter_table_with_no_callback() - local testable_table = {1, 2, 3, 4} + local testable_table = { 1, 2, 3, 4 } - local filtered_table = tableutils.filter(testable_table, function (_) return true end) + local filtered_table = tableutils.filter(testable_table, function(_) + return true + end) - return tableutils.is_equal(filtered_table, testable_table) + return tableutils.is_equal(filtered_table, testable_table) end function TableUtilsTestCase:test_filter_table_for_even_numbers() - local testable_table = {1, 2, 3, 4} + local testable_table = { 1, 2, 3, 4 } - local filtered_table = tableutils.filter(testable_table, function (el) return el % 2 == 0 end) + local filtered_table = tableutils.filter(testable_table, function(el) + return el % 2 == 0 + end) - return tableutils.is_equal(filtered_table, {2, 4}) + return tableutils.is_equal(filtered_table, { 2, 4 }) end function TableUtilsTestCase:test_allocation_with_default_value() @@ -234,5 +250,61 @@ function TableUtilsTestCase:test_allocation_with_default_value() return #testable_table == size end - TableUtilsTestCase:run_tests() + +local t = require("src.tests") + +t.describe("Table utils tests", function() + t.it("empty table concatenation", function() + local result = tableutils.concat({}, {}) + + t.expect(tableutils.is_empty(result)) + end) + + t.it("dicts concatenation", function() + local lhs = { + greeting = "Hello", + } + local rhs = { + name = "World", + } + + local result = tableutils.concat(lhs, rhs) + + t.expect(result.greeting == lhs.greeting) + t.expect(result.name == rhs.name) + end) + + t.it("lists concatenation", function() + local lhs = { + "Hello", + } + local rhs = { + "Yoo", + "World", + } + + local result = tableutils.concat(lhs, rhs) + + t.expect(result[1] == lhs[1]) + t.expect(result[2] == rhs[2]) + end) + + t.it("concatenation list with dict", function() + local lhs = { + "Hello", + "World", + } + local rhs = { + greeting = "Hello", + name = "World", + } + + local result = tableutils.concat(lhs, rhs) + + t.expect(result[1] == lhs[1]) + t.expect(result[2] == lhs[2]) + t.expect(result.greeting == rhs.greeting) + t.expect(result.name == rhs.name) + end) +end)