codanna 0.9.19

Code Intelligence for Large Language Models
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

--- Utility helper module
--- @module utils.helper

local M = {}

--- Check if a value is nil or empty
--- @param value any The value to check
--- @return boolean
function M.isEmpty(value)
    if value == nil then
        return true
    end
    if type(value) == "string" and value == "" then
        return true
    end
    if type(value) == "table" and next(value) == nil then
        return true
    end
    return false
end

--- Deep copy a table
--- @param original table The table to copy
--- @param seen table|nil Optional memoization table to handle cycles
--- @return table
function M.deepCopy(original, seen)
    if type(original) ~= "table" then
        return original
    end

    -- Initialize seen table for cycle detection
    seen = seen or {}
    
    -- Return memoized copy if we've already seen this table
    if seen[original] then
        return seen[original]
    end

    local copy = {}
    -- Memoize before recursing to handle self-references
    seen[original] = copy
    
    for key, value in pairs(original) do
        copy[M.deepCopy(key, seen)] = M.deepCopy(value, seen)
    end
    return setmetatable(copy, getmetatable(original))
end

--- Merge two tables
--- @param base table The base table
--- @param override table The override table
--- @return table
function M.merge(base, override)
    local result = M.deepCopy(base)
    for key, value in pairs(override) do
        if type(value) == "table" and type(result[key]) == "table" then
            result[key] = M.merge(result[key], value)
        else
            result[key] = value
        end
    end
    return result
end

--- String trim
--- @param s string The string to trim
--- @return string
function M.trim(s)
    return s:match("^%s*(.-)%s*$")
end

--- Split string by delimiter
--- @param s string The string to split
--- @param delimiter string The delimiter
--- @return table
function M.split(s, delimiter)
    -- Guard against nil or empty delimiter
    if not delimiter or delimiter == "" then
        return {s}
    end
    
    -- Escape pattern-magic characters in delimiter
    -- Escapes: . * + ? ^ $ ( ) [ ] % -
    local escaped_delimiter = delimiter:gsub("([%.%*%+%?%^%$%(%)%[%]%%%-])", "%%%1")
    
    local result = {}
    for match in (s .. delimiter):gmatch("(.-)" .. escaped_delimiter) do
        table.insert(result, match)
    end
    return result
end

return M