Moduuli:fi-nom-taiv

Wikisanakirjasta
Siirry navigaatioon Siirry hakuun

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

local apu = require('Moduuli:Mallinetyokalut')
local kielilinkki = require("Moduuli:Kielilinkki")
local ttapu = require('Moduuli:Taivutustaulukkotyökalut')

local m = {}




local function sisaltaa_arvon(tab, val)
    for index, value in ipairs(tab) do
        if value == val then
            return true
        end
    end

    return false
end

--- Luo kuvaus-attribuutin tekstin sanan taivutusmuotojen nimistä.
-- @param sanan_ryhma: taulukko taivutusmuodoista, joita sanamuoto edustaa
function m.tee_linkki(sana, muoto)
    local sanan_ryhma = m.ryhmat[sana]
    
    if muoto == "y.nom" then
        return "'''" .. sana .. "'''"
    end
    
    -- Luodaan kuvaus-parametri yhdistämällä kaikkien samannäköisten muotojen nimet (aakkosjärjestyksessä).
    local taivutusmuodot = table.concat(sanan_ryhma, " ")

    local kuvaus = nil
    local kuvaus_param = { }
    if m.sanaluokan_tunnus then
    	kuvaus = "tm/--/n/" .. taivutusmuodot
        kuvaus_param[9] = m.sanaluokan_tunnus
    end
    
    
    return kielilinkki.linkki{
        kieli  = "fi",
        kohde  = sana,
        kuvaus = kuvaus,
        ["kuvaus-param"] = kuvaus_param
    }
end



-- Taulukon solun muotoilu (paitsi komitatiivi).
function m.solu(muoto, pohja)
    if piilota then
        return "–"
    end
    
    local ensisijaiset_muodot = m.taivutusmuodot[muoto]
    if not m.taivutusmuodot[muoto] then
        return "–"
    end
    
    local vanhat_muodot = m.taivutusmuodot[muoto .. ':vanha']


    -- Viiva arvona estää muodon näyttämisen.
    if not ensisijaiset_muodot 
    		or (ensisijaiset_muodot 
    			and (ensisijaiset_muodot == "-" or ensisijaiset_muodot[1] == "-")) then
        return "–"
    end

    -- Jos ohitusparametri on annettu muodolle, käytetään sitä.
    if m.args[muoto .. "!"] then
        return m.args[muoto .. "!"]
    end


    -- Tehdään jokaisesta muodosta kielilinkki. Toissijaiset muodot kääritään lisäksi sulkuihin.
    -- Sen jälkeen yhdistetään kaikki laittamalla väleihin <br/>-elementit.

    local linkit_1s = apu.map(
        function (sana)
            if ei_kuvausta then
                return kielilinkki.linkki{ kieli = "fi" }
            else
                return m.tee_linkki(sana, muoto)
            end
        end,
        ensisijaiset_muodot
    )

    local linkit_vanhat = {}
    if vanhat_muodot then
        linkit_vanhat = apu.map(
            function (sana)
                if ei_kuvausta then
                    return '(' .. kielilinkki.linkki{ kieli = "fi" } .. ')'
                else
                    return '(' .. m.tee_linkki(sana, muoto) .. ')'
                end
            end,
            vanhat_muodot
        )
    end


    if #linkit_vanhat > 0 then
        return mw.text.listToText(linkit_1s, '<br/>', '<br/>')
            .. "<br/>"
            .. mw.text.listToText(linkit_vanhat, '<br/>', '<br/>')
    else
        return mw.text.listToText( linkit_1s, '<br/>', '<br/>')
    end
end



-- Taulukon komitatiivin solun muotoilu.
function m.solu_komitatiivi(muoto)
	local kohde = nil
	local kuvaus = nil
	local kuvausParam = nil
	
    if not m.args['mon.kom.vartalo'] or m.args['mon.kom.vartalo'] == "-" then
        return "–"
    end
    

    if m.sanaluokan_tunnus  then
        kohde = m.args['mon.kom.vartalo']:gsub("-$", "en") -- toinen 3:nsien persoonien muodoista
        kuvaus = "tm/--/n/mon.kom.3p"
        kuvausParam = {
        	[5] = m.args['mon.kom.vartalo']:gsub("-$", "en"),
            [8] = m.args['mon.kom.vartalo']:gsub("-$", ""),
            [7] = m.args['vokaalisointu']
        }
    end
    
    return kielilinkki.linkki{
    	kieli  = "fi",
        kohde  = kohde,
        teksti = m.args['mon.kom.vartalo'],
        kuvaus = kuvaus,
        ['kuvaus-param'] = kuvausParam
    }
        .. '<br/>+ '
        .. mw.getCurrentFrame():expandTemplate{ title = 'fi-om' }
end

function m.suodata_taivutusmuodot(suodatus)
    if suodatus == "mon" then
        -- Poistetaan yksikkömuodot.
        for k, v in pairs(m.taivutusmuodot) do
            if mw.ustring.sub(k, 1, 2) == "y." then
                m.taivutusmuodot[k] = "-"
            end
        end
    elseif suodatus == "yks" then
        -- Poistetaan monikkomuodot.    
        for k, v in pairs(m.taivutusmuodot) do
            if mw.ustring.sub(k, 1, 4) == "mon." then
                m.taivutusmuodot[k] = "-"
            end
        end
    end
end


function m.Taivutustaulukko(frame)
    m.args = frame.args

    -- Sanaluokka-parametri tarvitaan määrittämään sanaluokan artikkelipohjaa käytetään, koska 
    -- artikkelipohjissa on sanaluokkakohtaisia eroja.
    if m.args.sanaluokka == "substantiivi" then
        m.sanaluokan_tunnus = "s"
    elseif m.args.sanaluokka == "adjektiivi" then
        m.sanaluokan_tunnus = "adj"
    elseif m.args.sanaluokka == "verbi" then
        m.sanaluokan_tunnus = "v"
    end

    -- Luetaan mahdolliset ylimääräiset arvot kutsuvan mallineen parametereista.
    -- TODO ehkä parempi välittää arvot eksplisiittisesti mallineessa.
    local cur = frame
    if cur.args.frame == "+parent" then
        pframe = cur:getParent()
        m.args = apu.yhdista(m.args, pframe.args)
        cur = pframe
    end
    
    local otsikko
    local tarkenne = apu.ensimmainen_ei_tyhja{m.args.tarkenne}
    if tarkenne then
        otsikko = "Taivutus (" .. tarkenne .. ") "
    else
        otsikko = "Taivutus "
    end

    
    m.taivutusmuodot = apu.numeroidut_parametrit(m.args, {
                                                     'y.akk',
                                                     'y.nom',
                                                     'y.gen',
                                                     'y.part',
                                                     'y.iness',
                                                     'y.elat',
                                                     'y.ill',
                                                     'y.adess',
                                                     'y.abl',
                                                     'y.all',
                                                     'y.ess', 'y.ess:vanha',
                                                     'y.tr',
                                                     'y.abess',
                                                     'mon.akk',
                                                     'mon.nom',
                                                     'mon.gen',  'mon.gen:vanha',
                                                     'mon.part', 'mon.part:vanha',
                                                     'mon.iness',
                                                     'mon.elat',
                                                     'mon.ill',  'mon.ill:vanha',
                                                     'mon.adess',
                                                     'mon.abl',
                                                     'mon.all',
                                                     'mon.ess',  'mon.ess:vanha',
                                                     'mon.tr',
                                                     'mon.abess',
                                                     'mon.ins',
                                                     'mon.kom'
    })


    -- Lisätään akkusatiivimuodot, jotka ovat aina samat kuin nominatiivit tai genetiivi.
    m.taivutusmuodot['y.akk'] = {}
    for i,v in ipairs(m.taivutusmuodot['y.nom']) do
    	table.insert(m.taivutusmuodot['y.akk'], v)
    end
    for i,v in ipairs(m.taivutusmuodot['y.gen']) do
    	table.insert(m.taivutusmuodot['y.akk'], v)
    end
    
    m.taivutusmuodot['mon.akk'] = m.taivutusmuodot['mon.nom']


    -- Suodatetaan pois muodot joita ei haluta, jos yks=- tai mon=- on annettu.
    if m.args.yks ~= "-" and m.args.mon ~= "-" then
        m.suodata_taivutusmuodot("")
    elseif m.args.yks == "-" and m.args.mon ~= "-" then
        m.suodata_taivutusmuodot("mon")
    elseif m.args.yks ~= "-" and m.args.mon == "-" then
        m.suodata_taivutusmuodot("yks")
    else
        error("Mielipuolinen ''yks-' ja ''mon''-parametriyhdistelmä.")
    end

    
    -- Luodaan ryhmät samannäköisten taivutusmuotojen mukaan.
    m.ryhmat = ttapu.ryhmittele_arvoittain(m.taivutusmuodot)


    return frame:expandTemplate{
        title = "fi-nom-taiv/taulukko",
        args = {
            ['otsikko']  = otsikko,
            ['y.nom']     = m.solu('y.nom'),
            ['y.gen']     = m.solu('y.gen'),
            ['y.part']    = m.solu('y.part'),
            ['y.akk.(nom)'] = m.solu('y.nom'),
            ['y.akk.(gen)'] = m.solu('y.gen'),

            ['y.iness']   = m.solu('y.iness'),
            ['y.elat']    = m.solu('y.elat'),
            ['y.ill']     = m.solu('y.ill'),

            ['y.adess']   = m.solu('y.adess'),
            ['y.abl']     = m.solu('y.abl'),
            ['y.all']     = m.solu('y.all'),

            ['y.ess']     = m.solu('y.ess'),
            ['y.tr']      = m.solu('y.tr'),
            ['y.abess']   = m.solu('y.abess'),

            ['mon.nom']   = m.solu('mon.nom'),
            ['mon.gen']   = m.solu('mon.gen'),
            ['mon.part']  = m.solu('mon.part'),
            ['mon.akk']   = m.solu('mon.akk'),

            ['mon.iness'] = m.solu('mon.iness'),
            ['mon.elat']  = m.solu('mon.elat'),
            ['mon.ill']   = m.solu('mon.ill'),

            ['mon.adess'] = m.solu('mon.adess'),
            ['mon.abl']   = m.solu('mon.abl'),
            ['mon.all']   = m.solu('mon.all'),

            ['mon.ess']   = m.solu('mon.ess'),
            ['mon.tr']    = m.solu('mon.tr'),
            ['mon.abess'] = m.solu('mon.abess'),

            ['mon.ins']   = m.solu('mon.ins'),
            ['mon.kom']   = m.solu_komitatiivi('mon.kom.vartalo')
        }
    }
end

return m