Module:CommonFunctions

Documentation for this module may be created at Module:CommonFunctions/doc

local inspect = require('Module:Inspect').inspect

-- in Array
function inArray(key, array)
    if array[key] ~= nil then
        return true
    end
end

function inArrayStarts(key, array)
    for k, v in pairs(array) do
        if string.starts(k, key) then
            return true
        end
    end
end

function inArrayHas(key, array)
    for k, v in pairs(array) do
        if string.find(k, key) then
            return true
        end
    end
end

function inArrayHasValue(value, array)
    for k, v in pairs(array) do
        if string.find(v, value) then
            return true
        end
    end
end

function indexOf(value, array)
    for i, v in ipairs(array) do
        if v == value then
            return i
        end
    end
    return nil
end

-- String starts
function string.starts(String, Start)
    return string.sub(String, 1, string.len(Start)) == Start
end

function string.ends(str, ending)
    return ending == "" or str:sub(-#ending) == ending
end

-- Implement sorted loop through array.
function spairs(t)
    local keys = {}
    for k in pairs(t) do
        keys[#keys + 1] = k
    end
    table.sort(keys)
    local i = 0
    return function()
        i = i + 1
        if keys[i] then
            return keys[i], t[keys[i]]
        end
    end
end

-- Implement merging tables
function tableMerge(first_table, second_table)
    for k, v in spairs(second_table) do
        first_table[k] = v
    end
end

function indexTableMerge(first_table, second_table)
    for k, v in spairs(second_table) do
        table.insert(first_table, v)
    end
end

-- Implement rounding.
function round(num, numDecimalPlaces)
    if numDecimalPlaces == nil then
        numDecimalPlaces = 2
    end
    local mult = 10 ^ (numDecimalPlaces or 0)
    return math.floor(num * mult + 0.5) / mult
end

-- Implement string trim.
function trim(s)
    return (string.gsub(s, "^%s*(.-)%s*$", "%1"))
end

-- Implement splitting string to a table.
function split(s, delimiter, skip_empty)
    if not s then
        return {}
    end
    local i = 1
    if delimiter == nil then
        delimiter = ','
    end
    result = {};
    for match in (s .. delimiter):gmatch("(.-)" .. delimiter) do
        if (skip_empty == true and trim(match) ~= '') or skip_empty == nil then
            table.insert(result, i, trim(match));
            i = i + 1
        end
    end
    return result;
end

-- Title case
function titleCaseFunc(first, rest)
    return first:upper() .. rest:lower()
end

function titleCase(str)
    return string.gsub(str, "(%a)([%w_']*)", titleCaseFunc)
end

function table.containsKey(tbl, key)
    return tbl[key] ~= nil
end

function table.containsValue(tbl, val)
    local contains = false
    for k, v in pairs(tbl) do
        if (v == val) then
            contains = true
            break
        end
    end
    return contains
end

function table.matches(tbl, val)
    local matches = 0
    for k, v in pairs(tbl) do
        if (type(v) == 'table') then
            matches = matches + table.matches(v, val)
        else
            if (v == val) then
                matches = matches + 1
            end
        end
    end
    return matches
end

function dump(o)
    if type(o) == 'table' then
        local s = '{ <br>'
        for k, v in pairs(o) do
            if type(k) ~= 'number' then
                k = '"' .. k .. '"'
            end
            s = s .. '[' .. k .. '] = ' .. dump(v) .. ',<br>'
        end
        return s .. '}'
    else
        return tostring(o)
    end
end

function table.not_empty(tbl)
    return not next(tbl)
end

function math.round(num, decimals)
    decimals = math.pow(10, decimals or 0)
    num = num * decimals
    if num >= 0 then
        num = math.floor(num + 0.5)
    else
        num = math.ceil(num - 0.5)
    end
    return num / decimals
end

function formatnum(amount)
    local formatted = amount
    while true do
        formatted, k = string.gsub(formatted, "^(-?%d+)(%d%d%d)", '%1,%2')
        if (k == 0) then
            break
        end
    end
    return formatted
end

function table.deep_copy(original)
    local copy = {}
    for k, v in pairs(original) do
        if type(v) == "table" then
            copy[k] = table.deep_copy(v)
        else
            copy[k] = v
        end
    end
    return setmetatable(copy, getmetatable(original))
end

function dump(tbl)
    local ret = {}
    for k, v in pairs(tbl) do
        table.insert(ret, k .. ': ' .. inspect(v))
    end
    return frame:preprocess(table.concat(ret, "<br/>"))
end

function inspect_dump(frame, tbl)
    return frame:preprocess("<pre><nowiki>" .. inspect(tbl) .. "</nowiki></pre>")
end

function sortPassives(s)
    local passives = {}
    for passive in s:gmatch("_passive%d+") do
        table.insert(passives, passive)
    end
    if #passives == 0 then
        return s
    end
    table.sort(passives)
    local base = s:gsub("_passive%d+", "")
    return base .. table.concat(passives)
end

function link(page, text)
    return '[[' .. page .. '|' .. (text or page) .. ']]'
end

local function generateCombinations(passives, n, combo, combos)
    if n == 0 then
        table.insert(combos, combo)
    else
        for i = 1, #passives do
            local newCombo = {}
            for j = 1, #combo do
                table.insert(newCombo, combo[j])
            end
            table.insert(newCombo, passives[i])
            generateCombinations(passives, n - 1, newCombo, combos)
        end
    end
end

function formatDamage(number)
    local formattedDamage = number > 0 and (formatnum(math.round(number, 2)) .. '%') or '-%'
    return formattedDamage
end

function doVariables(frame, input)
    local s = ''
    for mode, mode_content in pairs(input) do
        for damage_name, damage_number in pairs(mode_content) do
            s = s .. '{{#vardefine:' .. damage_name .. '|' .. doRangeText(damage_number) .. '}}'
        end
    end
    return frame:preprocess(s)
end