Siirry sisältöön

Moduuli:fi-nom-taiv

Wikisanakirjasta

Moduulia käytetään nominien taivutustaulukkomallineiden sisällä.

Parametrit

[muokkaa]
  • tarkenne: otsikon Taivutus-tekstin perään suluissa lisättävä huomautus
  • mon=-: monikko piilotetaan
  • yks=-: yksikkö piilotetaan
  • sanaluokka: substantiivi, adjektiivi, verbi tai numeraali

Taivutusmuotojen parametrit

[muokkaa]

Kaikkia parametreja voi antaa useita lisäämällä perään numeron. Essiiveille sekä monikon genetiiville, partitiiville ja illatiiville sulkuihin tulevat muodot voi antaa lisäämällä perään tekstin :vanha. Esim. y.ess:vanha.

  • y.nom: yksikön nominatiivi
  • y.gen: yksikön genetiivi
  • y.part: yksikön partitiivi
  • y.iness: yksikön inessiivi
  • y.elat: yksikön elatiivi
  • y.ill: yksikön illatiivi
  • y.adess: yksikön adessiivi
  • y.abl: yksikön ablatiivi
  • y.all: yksikön allatiivi
  • y.ess: yksikön essiivi
  • y.tr: yksikön translatiivi
  • y.abess: yksikön abessiivi
  • mon.nom: monikon nominatiivi
  • mon.gen: monikon genetiivi
  • mon.part: monikon partitiivi
  • mon.akk: monikon akkusatiivi
  • mon.iness: monikon inessiivi
  • mon.elat: monikon elatiivi
  • mon.ill: monikon illatiivi
  • mon.adess: monikon adessiivi
  • mon.abl: monikon ablatiivi
  • mon.all: monikon allatiivi
  • mon.ess: monikon essiivi
  • mon.tr: monikon translatiivi
  • mon.abess: monikon abessiivi
  • mon.ins: monikon instruktiivi

Komitatiivin kohdalla käytetään jompaakumpaa seuraavista

  • mon.kom: monikon komitatiivi
  • mon.kom.vartalo: monikon komitatiivi silloin kun perään lisätään omistusliite

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 == "numeraali" then
        m.sanaluokan_tunnus = "num"
    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.part:vanha',
                                                     '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',
                                                     
                                                     'vart.vok',
                                                     'vart.heik',
                                                     'vart.vah',
                                                     'vart.kons',
    })


    -- 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("''yks-' ja ''mon''-parametria ei voi käyttää yhdessä.")
    end

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


	local komitatiivi
	if m.taivutusmuodot['mon.kom'] ~= nil and m.args['mon.kom.vartalo'] ~= nil then
		error("Anna vain jompikumpi parametreista ''mon.kom'' tai ''mon.kom.vartalo''")
		
	elseif m.taivutusmuodot['mon.kom'] ~= nil then
		komitatiivi = m.solu('mon.kom')
		
	elseif m.args['mon.kom.vartalo'] ~= nil then
        komitatiivi = m.solu_komitatiivi('mon.kom.vartalo')
    end


    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']   = komitatiivi,
            
            
            ['vart.vok']  = m.args['vart.vok'],
            ['vart.heik'] = m.args['vart.heik'],
            ['vart.vah']  = m.args['vart.vah'],
            ['vart.kons'] = m.args['vart.kons'],
        }
    }
end

return m