Modulo:Linguaggi

À prupositu di Wikipedia
Jump to navigation Jump to search

La documentazione per questo modulo può essere creata in Modulo:Linguaggi/man

local language = {}

-- File di configurazione contenente due tabelle:
-- lg.alias: per normalizzare gli alias a un codice unico
-- lg.codici: che dato un codice restituisce un array contente
-- nome della lingua e collegamento all'articolo su it.wiki dedicato alla lingua
local lg = mw.loadData( 'Modulo:Linguaggi/Configurazione');

-- ritorna il nome della voce corrispondente a "code". Se "code" non corrisponde a nessuna
-- lingua inserita in tabella ritorna una stringa nulla
function language.get_voce(code)
    if code == nil then return '' end
    local code = mw.ustring.lower(code)
    if lg.alias[code] then code = lg.alias[code] end
    lingua = lg.codici[code]
    if lingua then
        return lingua[2]
    end
    return ''
end

-- ritorna vero se "code" corrisponde a un linguaggio, falso altrimenti
function language.esiste(code)
    if code == nil or code=='' then return false end
    if lg.alias[code] then code= lg.alias[code] end
    if lg.codici[code] then return true end
    return false
end

-- ritorna il nome standard della lingua corrispondente a "code"  e il codice normalizzato
--  a quella della tabella codici
-- Se "code" non corrisponde a nessuna lingua inserita in tabella ritorna la coppia valore di default
-- o stringa nulla se questo non è indicato e il codice richiesto. Se maiuscolo è vero il
-- nome viene ritornato con la prima lettera maiuscola
function language.get_nome(code, maiuscolo, default)
    local nome = default or ''
    if code ~= nil and code ~= '' then
        code = mw.ustring.lower(code)
        if lg.alias[code] then code = lg.alias[code] end
        local lingua = lg.codici[code]
        if lingua then nome = lingua[1] end
    end
    if maiuscolo then
        nome = mw.ustring.gsub(nome, '^%l', mw.ustring.upper)
    end
    return nome, code
end

-- funzione di interfaccia per template:Nomelingua/voce
function language.voce(frame)
    local code = frame.args[1]
    if code == nil or code == '' then
        return ''
    end
    return language.get_voce(code)
end

-- funzione di interfaccia per template:Nomelingua/nome
function language.nome(frame)
    local maiuscolo = false
    local code = frame.args[1] or ''
    local default = (frame.args[2] == 'v' and '') or code
    if frame.args['M']~=nil and frame.args['M']~='' then
        maiuscolo = true
    end
    return language.get_nome(code, maiuscolo, default), _

end

--funzione di interfaccia per template:Nomelingua
function language.nomecompleto(frame)
    local code = frame.args[1]
    if code == nil or code == '' then
        return ''
    end
    local maiuscolo = false
    if frame.args['M']~=nil and frame.args['M']~='' then
        maiuscolo = true
    end
    local voce = language.get_voce(code)
    local nome = language.get_nome(code, maiuscolo, code)
    if nome == "" and voce ~="" then
        if maiuscolo then
            nome = mw.ustring.gsub(voce, '^%l', mw.ustring.upper)
        else
            nome = voce
        end
    end
    if voce == "" then
        return nome
    else
        return table.concat({'[[', voce, "|", nome, "]]"})
    end
end

--funzione di interfaccia per template:Lingue, se viene passato anche il parametro
--usa_codice (qualunque sia il suo valore), allora il testo mostrato tra parentesi
--viene normalizzato a quello standard della lingua, piuttosto che essere quello
--passato
--In aggiunta può ricevere se il paremtro return_error è vero ritorna in caso di
--codici lingua non ritrovati in tabella una tabella aggiuntiva con i codici errati
--return_error viene controllato solo se la funzione è richiamata da un modulo Lua
--se è richiamata da un template è sempre falsa
function language.lingue(frame)
    local lingue_list = { }
    -- Se chiamata mediante  #invoke, usa gli argomenti passati al template invocante.
    -- Altrimenti a scopo di test assume che gli argomenti siano passati direttamente
    local args
    local return_error = false
    local error_list = {}
    if frame == mw.getCurrentFrame() then
        args = frame:getParent().args
    else
        args = frame
        return_error = args['return_error'] or False
    end
    local usa_codice = false
    local lingua, codice_normalizzato, code_to_show
    local usa_codice = (args['usacodice'] ~= nil)


    for _,code in ipairs(args) do
        lingua, codice_normalizzato = language.get_nome(code)
        code_to_show = mw.ustring.upper((usa_codice and codice_normalizzato) or code)
        if lingua ~= "" then
            lingue_list[#lingue_list+1] = '<abbr title="' .. lingua .. '">' ..code_to_show .. "</abbr>"
        else
            lingue_list[#lingue_list+1] = code
            if return_error then error_list[#error_list+1] = code end
        end
    end
    local reply
    if #lingue_list > 0 then
        reply = '(<span style="font-weight:bolder; font-size:80%">' .. table.concat(lingue_list, ",&nbsp;") .. "</span>)"
    else
        reply = ''
    end
    reply = reply
    if #error_list>0 then
        return reply, error_list
    else
        return reply
    end
end

-- Restituisce una tabella con tutti i codici riconosciuti dal modulo
function language.tabella(frame)
    local HtmlBuilder = require('Module:HtmlBuilder')
 
    -- genera una tabella codici -> lista alias e una di codici per ordinarla
    local alias_table = {}
    local codici_sorted = {}
    for code, _ in pairs(lg.codici) do
        alias_table[code] = {"'''" .. code .. "'''"}
        codici_sorted[#codici_sorted+1] = code
    end
    for alias, code in pairs(lg.alias) do
        if alias_table[code] then table.insert(alias_table[code], alias) end
    end
    table.sort(codici_sorted)
 
    root = HtmlBuilder.create('table')
    root
        .addClass('wikitable sortable')
        .tag('tr')
            .tag('th').wikitext('Codici').done()
            .tag('th').wikitext('[[template:Nomelingua/voce]]').done()
            .tag('th').wikitext('[[template:Nomelingua/voce]]').done()
            .tag('th').wikitext('[[template:Lingue]]')
 
    for _,code in ipairs(codici_sorted) do
        local code_string = table.concat(alias_table[code], ", ")
        local nome, voce = language.get_nome(code), language.get_voce(code)
        if voce ~= '' then voce = '[[' .. voce .. ']]' end
        root
            .tag('tr')
                .tag('td').wikitext(code_string).done()
                .tag('td').wikitext(nome).done()
                .tag('td').wikitext(voce).done()
                .tag('td').css('text-align', 'center').wikitext(language.lingue({code}))
    end
    return tostring(root)
end

-- Restituisce una tabella degli alias in formato alias;codice
function language.tabella_alias(frame)
    local HtmlBuilder = require('Module:HtmlBuilder')

    root = HtmlBuilder.create('table')
    root
        .addClass('wikitable sortable')
        .tag('tr')
            .tag('th').wikitext('Alias').done()
            .tag('th').wikitext('codice').done()
    for alias, code in pairs(lg.alias) do
        root
            .tag('tr')
                .tag('td').wikitext(alias).done()
                .tag('td').wikitext(code)
    end
    return tostring(root)
end

-- Restituisce una tabella dei codici in formato codice;nome;voce
function language.tabella_codici(frame)
    local HtmlBuilder = require('Module:HtmlBuilder')

    root = HtmlBuilder.create('table')
    root
        .addClass('wikitable sortable')
        .tag('tr')
            .tag('th').wikitext('Codice').done()
            .tag('th').wikitext('Nome').done()
            .tag('th').wikitext('Voce').done()
    for code, valore in pairs(lg.codici) do
        root
            .tag('tr')
                .tag('td').wikitext(code).done()
                .tag('td').wikitext(valore[1]).done()
                .tag('td').wikitext(valore[2])
    end
    return tostring(root)
end

-- ritorna una whitelist di tutti i codici riconosciuti ad uso bot in python
function language.whitelist(frame)
    local rows = { 'WHITELIST_LINGUE = set( [' }
    -- genera una tabella codici -> lista alias e una di codici per ordinarla
    local codici = {}
    for code, _ in pairs(lg.codici) do
        codici[#codici+1] = code
    end
    for alias, _ in pairs(lg.alias) do
        codici[#alias+1] = alias
    end
    table.sort(codici)
    for _, codice in ipairs(codici) do
        rows[#rows+1] = "    '" .. codice .."',"
    end
    rows[#rows+1] = "])"
    return table.concat(rows, '\n')
end

return language