Moduuli:fi-nom

Kohteesta Wikisanakirja
Siirry navigaatioon Siirry hakuun
Template-info.png

Parametrit[muokkaa]

  • yks: viiva (-), jos yksikköä ei ole
  • mon: viiva (-), jos monikkoa ei ole
  • vokaalisointu: a tai ä sen mukaan kumpaa taivutusmuodoissa käytetään

Seuraaviille parametreille voi antaa useita arvoja käyttämällä niiden perässä numeroa (esim. y-gen1, y-gen2...).

  • 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-ess-vanha: sulkuihin tuleva yksikön essiivi
  • y-tr: yksikön translatiivi
  • y-abess: yksikön abessiivi
  • mon-nom: monikon nominatiivi
  • mon-gen: monikon genetiivi
  • mon-gen-vanha: sulkuihin tuleva monikon genetiivi
  • mon-part: monikon partitiivi
  • mon-part-vanha: sulkuihin tuleva monikon partitiivi
  • mon-iness: monikon inessiivi
  • mon-elat: monikon elatiivi
  • mon-ill: monikon illatiivi
  • mon-ill-vanha: sulkuihin tuleva monikon illatiivi
  • mon-adess: monikon adessiivi
  • mon-abl: monikon ablatiivi
  • mon-all: monikon allatiivi
  • mon-ess:monikon essiivi
  • mon-ess-vanha: sulkuihin tuleva monikon essiivi
  • mon-tr: monikon translatiivi
  • mon-abess: monikon abessiivi
  • mon-ins: monikon instruktiivi
  • mon-kom: monikon komitatiivi

local apu = require('Moduuli:Mallinetyokalut')
local kielilinkki = require("Moduuli:Kielilinkki")

local m = {}


local function rivi(out, ...)
    for i, solu in ipairs({...}) do
        table.insert(out, '| ')
        table.insert(out, solu)
        table.insert(out, '\n')
    end
    table.insert(out, '|-\n')
end

local function valiotsikko(out, teksti)
    table.insert(out, '! colspan="3"| ')
    table.insert(out, teksti)
    table.insert(out, '\n|-\n')
end


local function solu(piilota, args_t, muoto, pohja)
    if piilota then
        return "–"
    end
    
    local muodot = args_t[muoto]
    local vanhat_muodot = args_t[muoto .. '-vanha']
    local vanhat = ''
    local kuvaus
    
    if pohja then
        kuvaus = pohja
    else
        kuvaus = "tm/s-" .. muoto
    end
    
    if vanhat_muodot then
        local arr = apu.map(function (sana) return '(' .. kielilinkki.linkki{ kieli = "fi", kohde = sana, kuvaus = kuvaus} .. ')' end, vanhat_muodot)
        vanhat = '<br/>' .. mw.text.listToText( arr, '<br/>', '<br/>')
    end
    
    if muodot then
        local arr = apu.map(function (sana) return kielilinkki.linkki{ kieli = "fi", kohde = sana, kuvaus = kuvaus} end, muodot)
        return mw.text.listToText( arr, '<br/>', '<br/>') .. vanhat
    end
    return ''
end


local function solu_komitatiivi(piilota, args_t, muoto, vokaalisointu, pohja)
    if piilota then
        return "–"
    end
    
    local kuvaus
    
    if pohja then
        kuvaus = pohja
    else
        kuvaus = "tm/s-" .. muoto
    end
    
    if args_t[muoto] then
        local arr = apu.map(
            function (sana) 
                -- komitatiivi soluetään yksikön 3. persoonan -een-muotoon
                local y3muoto = sana:gsub("-$", "en")
                
                return kielilinkki.linkki{ 
                    kieli  = "fi", 
                    kohde  = y3muoto,
                    teksti = sana, 
                    kuvaus = kuvaus,
                    ["kuvaus-param"] = { 
                        [5]  = y3muoto,
                        [8]  = sana:gsub("-$", ""), -- taivm-mon-kom-mallineen 3. parametri
                        [9] = vokaalisointu
                    }
                } 
            end, args_t[muoto])
        
        return mw.text.listToText( arr, '<br/>', '<br/>') .. '<br/>+ ' .. mw.getCurrentFrame():expandTemplate{ title = 'fi-om' }
    end

    return ''
end


function m.Taivutustaulukko(frame)
    local args = frame.args
    local cur = frame
	
	while cur and cur.args.frame == "+parent" do
		pframe = cur:getParent()
		args = apu.yhdista(args, pframe.args)
		cur = pframe
	end
	
	local otsikko
	if args.tarkennus then
		otsikko = "Taivutus (" .. args.tarkennus .. ") "
	else
		otsikko = "Taivutus "
	end
	
    local args_t = apu.numeroidut_parametrit(args, { 
                                                 '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-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'
    })
    
    local piilota_yks = (args.yks == "-")
    local piilota_mon = (args.mon == "-")
    
    local y_akk   = "–"
    local mon_akk = "–"
    
    if not piilota_yks then
    	y_akk = (args['y-nom'] or "–") .. '; ' .. (args['y-gen'] or "–")
    end
    
    if not piilota_mon then
    	mon_akk = apu.ensimmainen_ei_tyhja{args['mon-akk'], args['mon-nom']}
    end
    
    local out = {}
    table.insert(out, [=[
{| class="wikitable mw-collapsible" data-expandtext="näytä" data-collapsetext="piilota"')
|-
! colspan="3"| ]=] .. otsikko .. [=[

|-
! sijamuoto !! yksikkö !! monikko
|-
]=])
    valiotsikko(out, 'kieliopilliset sijamuodot')    
    rivi(out, '[[nominatiivi]]',  solu(piilota_yks, args_t, 'y-nom'),   solu(piilota_mon, args_t, 'mon-nom', 'tm/s-mon-nom+akk'))
    rivi(out, '[[genetiivi]]',    solu(piilota_yks, args_t, 'y-gen', 'tm/s-y-gen+akk'), solu(piilota_mon, args_t, 'mon-gen'))
    rivi(out, '[[partitiivi]]',   solu(piilota_yks, args_t, 'y-part'),  solu(piilota_mon, args_t, 'mon-part'))
    rivi(out, '[[akkusatiivi]]',  y_akk, mon_akk)
    
    valiotsikko(out, 'sisäpaikallissijat')
    rivi(out, '[[inessiivi]]',    solu(piilota_yks, args_t, 'y-iness'), solu(piilota_mon, args_t, 'mon-iness'))
    rivi(out, '[[elatiivi]]',     solu(piilota_yks, args_t, 'y-elat'),  solu(piilota_mon, args_t, 'mon-elat'))
    rivi(out, '[[illatiivi]]',    solu(piilota_yks, args_t, 'y-ill'),   solu(piilota_mon, args_t, 'mon-ill'))
    
    valiotsikko(out, 'ulkopaikallissijat')
    rivi(out, '[[adessiivi]]',    solu(piilota_yks, args_t, 'y-adess'), solu(piilota_mon, args_t, 'mon-adess'))
    rivi(out, '[[ablatiivi]]',    solu(piilota_yks, args_t, 'y-abl'),   solu(piilota_mon, args_t, 'mon-abl'))
    rivi(out, '[[allatiivi]]',    solu(piilota_yks, args_t, 'y-all'),   solu(piilota_mon, args_t, 'mon-all'))
    
    valiotsikko(out, 'muut sijamuodot')
    rivi(out, '[[essiivi]]',      solu(piilota_yks, args_t, 'y-ess'),   solu(piilota_mon, args_t, 'mon-ess'))
    rivi(out, '[[translatiivi]]', solu(piilota_yks, args_t, 'y-tr'),    solu(piilota_mon, args_t, 'mon-tr'))
    rivi(out, '[[abessiivi]]',    solu(piilota_yks, args_t, 'y-abess'), solu(piilota_mon, args_t, 'mon-abess'))
    
    rivi(out, '[[instruktiivi]]', '–', solu(piilota_mon, args_t, 'mon-ins'))
    rivi(out, '[[komitatiivi]]',  '–', solu_komitatiivi(piilota_mon, args_t, 'mon-kom', args.vokaalisointu))
    
    table.insert(out, '|}')

    return table.concat(out, '')
    
end

return m