Moduuli:fi-aantaminen

Tämän moduulin ohjeistuksen voi tehdä sivulle Moduuli:fi-aantaminen/ohje

local export = {}

local luokitus = require("Moduuli:luokittelu")
local mallinetyokalut = require("Moduuli:Mallinetyokalut")
local tavutus = require("Moduuli:tavutus/fi")
local paino = require("Moduuli:tavutus/fi/paino")
local ipa = require('Moduuli:translitterointi/fi/IPA-foneeminen')


local function get_category_text(len1, len2)
    local text = {
        [1] = "yksi",
        [2] = "kaksi",
        [3] = "kolmi",
        [4] = "neli",
        [5] = "viisi",
        [6] = "kuusi",
        [7] = "seitsen",
        [8] = "kahdeksan",
        [9] = "yhdeksän",
        [10] = "kymmen"
    }

    if len2 == nil then
        if len1 <= 10 then
            return text[len1] .. "tavuiset sanat"
        else
            return len1 .. "-tavuiset sanat"
        end
    end

    if len1 > len2 then
        len1, len2 = len2, len1
    end

    local text1 = text[len1] or tostring(len1)
    local text2 = text[len2] or tostring(len2)

    if len2 <= 10 then
        return text1 .. "- tai " .. text2 .. "tavuiset sanat"
    elseif len1 == 10 and len2 == 11 then
        return "kymmen- tai 11-tavuiset sanat"
    else
        return text1 .. "- tai " .. text2 .. "-tavuiset sanat"
    end
end

--- Palauttaa pelkät tekstit tavutiedoista.
local function get_syllables(syllableInfos)
    return mallinetyokalut.map(
        function(syllableInfo)
            return syllableInfo.text
        end,
        syllableInfos
    )
end


local function get_result_substing(syllabifications)
    local templates = {}

    local category_text = ""
    local with_k_param = true
    if #syllabifications > 1 and #syllabifications[1] ~= #syllabifications[2] then
        with_k_param = false
        category_text = " {{+luokka|fi|" .. get_category_text(len(syllabifications[1]), len(syllabifications[2])) .. "}}"
    end

    local syllables
    if with_k_param then
        for k, syllableInfos in pairs(syllabifications) do
            syllables = get_syllables(syllableInfos)
            table.insert(templates, "{{tavut|" .. table.concat(syllables, "|") .. "|k=fi}}")
        end
    else
        for k, syllableInfos in pairs(syllabifications) do
            syllables = get_syllables(syllableInfos)            
            table.insert(templates, "{{tavut|" .. table.concat(syllables, "|") .. "}}")
        end
    end

    templates[1] = templates[1]:gsub("%{%{tavut%|", "{{tavutus|", 1)    
    
    return table.concat( templates, " / " ) .. category_text
end




local function get_result_not_substing(syllabifications)
    if #syllabifications > 1 and #syllabifications[1] ~= #syllabifications[2] then
        luokitus.asetaAakkostajalla2{
            kieli  = "fi",
            luokka = "Suomen kielen " .. get_category_text(#syllabifications[1], #syllabifications[2]),
            nimiavaruus = 0
        }
    else
        luokitus.asetaAakkostajalla2{
            kieli  = "fi",
            luokka = "Suomen kielen " .. get_category_text(#syllabifications[1]),
            nimiavaruus = 0
        }
    end

    local out = {}
    local syllable
    for k, syllableInfos in pairs(syllabifications) do
        syllables = get_syllables(syllableInfos)
        table.insert(out, table.concat(syllables, "‧"))
    end
    
    return "*tavutus: " .. table.concat(out, " / "):gsub("*", ""), tostring(luokitus)
end




local function get_memoized_function(func)
    local memoizations = {}
    
    return function (param)
        if not memoizations[param] then
            memoizations[param] = func(param)
        end

        return memoizations[param]
    end
end

--- Tehdään funktio joka tallentaa tavutuksen tuloksen, koska tavutusta kutsutaan kahdessa paikassa.
local memoized_tavuta = get_memoized_function(tavutus.tavuta)

local function get_syllabifications(words)
    -- Haetaan jokaisen sanan tavutus, ja lisätään ne yhteiseen listaan. Poistetaan
    -- tuplat.
    local all_syllabifications = {}
    local syllabifications_of_word
    
    for i, word in ipairs(words) do
        
        syllabifications_of_word = memoized_tavuta(mw.ustring.lower(word))

        for j, syllabification in ipairs(syllabifications_of_word) do
            table.insert(all_syllabifications, syllabification)
        end
        
    end

    return all_syllabifications
end


local function copy_args(args)
    local words = {}

    for i, word in ipairs(args) do
        words[i] = word
    end
    
    return words
end


local function get_words(frame)
    local words = copy_args(frame.args)
    if not words[1] then
        words[1] = mw.title.getCurrentTitle().text   
    elseif words[1] == "*" then
        words[1] = mw.title.getCurrentTitle().text .. "*"
    end
    
    return words
end


function export.Tavuta(frame)
    local pframe = frame:getParent()
    local words = get_words(pframe)
    local all_syllabifications = get_syllabifications(words)
    
    if mw.isSubsting() then
        return get_result_substing(all_syllabifications)
    end

    return get_result_not_substing(all_syllabifications)
end




local function get_ipas(words)
    local all_syllabifications = get_syllabifications(words)
    local stressed_word
    local ipas = {}

    local function get_text(syllable_info)
        return syllable_info.text
    end

    for i, syllable_infos in ipairs(all_syllabifications) do
        stressed_word = paino.get_stresses2(syllable_infos)
        ipas[i]       = "/" .. ipa.translitteroi_merkkijono(stressed_word) .. "/"
    end

    return ipas
end

function export.Translitteroi(frame)
    local pframe = frame:getParent()
    local words = get_words(pframe)
    
    local ipas = mallinetyokalut.poista_tuplat(get_ipas(words))

    if mw.isSubsting() then
        local text = ("{{IPA2|" .. table.concat(ipas, "}} tai {{IPA2|") .. "}}"):gsub("%{%{IPA2%|", "{{IPA|", 1)
        return text
    end
    
    local templates = {}
    
    templates[1] = frame:expandTemplate{
        title = "IPA",
        args = {
            ipas[1]
        }
    }
    
    for i = 2, #ipas do
        templates[i] = frame:expandTemplate{
            title = "IPA2",
            args = {
                ipas[i]
            }
        }
    end
    
    return mw.text.listToText(templates, ", ", " tai ")
end



function export.Aantaminen(frame)

    if mw.isSubsting() then
        local words = get_words(frame:getParent())
        return "{{fi-IPA|" .. table.concat(words, "|") .. "}}\n{{fi-tavutus|" .. table.concat(words, "|") .. "}}"
    end
    
    return export.Translitteroi(frame) .. "\n" .. export.Tavuta(frame), tostring(luokitus)
end



return export