Module:languages

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

-- Module:languages
local languages_data = require("Module:languages/data")
local utilities = require("Module:utilities")

local languages = {}
local language_cache = {}

local function split_raw_name(raw)
    if not raw then return nil, nil end

    if type(raw) == "table" then
        if raw.name then
            return raw.name, raw.abbr
        else
            raw = raw[1]
        end
    end

    if type(raw) ~= "string" then
        raw = tostring(raw)
    end

    local parts = utilities.split_string(raw, ":")
    local name = parts[1] and utilities.trim_string(parts[1]) or nil
    local abbr = parts[2] and utilities.trim_string(parts[2]) or nil

    if name == "" then name = nil end
    if abbr == "" then abbr = nil end

    return name, abbr
end

function languages.parse(lang_param)
    if not lang_param or lang_param == "" then
        return nil, nil
    end

    local parts = utilities.split_string(lang_param, ":")
    local code = parts[1] and utilities.trim_string(parts[1]) or nil
    local display_override = parts[2] and utilities.trim_string(parts[2]) or nil
    if display_override == "" then display_override = nil end

    return code, display_override
end

function languages.get_name_and_display(lang_param)
    local code, display_override = languages.parse(lang_param)
    if not code then return nil end

    local data = languages_data[code]
    local raw = data and data[1] or code
    local canonical, abbr = split_raw_name(raw)

    canonical = canonical or code

    local display_for_link = display_override or abbr or canonical
    local plain_display = display_override or canonical

    return {
        code = code,
        canonical = canonical,
        abbr = abbr,
        display_override = display_override,
        display = display_for_link,
        plain = plain_display,
    }
end

function languages.get_canonical_name(lang_code)
    if not lang_code or lang_code == "" then return lang_code end
    local data = languages_data[lang_code]
    local raw = data and data[1] or lang_code
    local canonical, _ = split_raw_name(raw)
    return canonical or lang_code
end

function languages.get_ancestor_code(lang_code)
    local data = languages_data[lang_code]
    return data and data[2] or nil
end

function languages.get_all_ancestors(lang_code)
    if language_cache[lang_code] then return language_cache[lang_code] end
    local ancestors = {}
    local current = lang_code
    while current do
        current = languages.get_ancestor_code(current)
        if current then table.insert(ancestors, current) end
    end
    language_cache[lang_code] = ancestors
    return ancestors
end

function languages.is_descendant_of(child_code, ancestor_code)
    local ancestors = languages.get_all_ancestors(child_code)
    for _, a in ipairs(ancestors) do
        if a == ancestor_code then return true end
    end
    return false
end

function languages.is_proto(lang_code)
    if not lang_code then return false end
    lang_code = tostring(lang_code)
    return lang_code:sub(-4) == "-pro" or lang_code:sub(-4) == "-pre"
end

return languages