Modulo:Lingue

Istruzioni per l'uso
Questo è un modulo scritto in Lua. Le istruzioni che seguono sono contenute nella sottopagina Modulo:Lingue/man (modifica · cronologia)
Sandbox: Modulo:Lingue/sandbox (modifica · cronologia) · Sottopagine: lista · Test: Modulo:Lingue/test (modifica · cronologia · Esegui)

Modulo Lua per implementare le funzioni dei template {{Nomelingua}}, {{Lingue}} e templati ad essi collegati e per offrire le medesime funzionalità ad altri moduli Lua senza dover dipendere da chiamate ai medesimi template.

Funzioni

Per moduli Lua

Il modulo rende disponibili alcune funzioni per altri moduli Lua, per utilizzarle occorre prima caricare il modulo con l'istruzione: local lg = require( "Modulo:Lingue" );

Le funzioni saranno disponibili come lg.nomefunzione (lg è solo un nome di esempio, si può scegliere quello che si preferisce purché si richiamino coerentemente le funzioni, per esempio si può usare local lingue = require( "Modulo:Lingue" );, in questo caso le funzioni andranno richiamate come lingua.nomefunzione

esiste(code): ritorna true se code corrisponde a una lingua, altrimenti false
get_nome(code, maiuscolo, default): ritorna la coppia nome della lingua corrispondente a code e code normalizzato (per esempio se code è "inglese" ritorna (lingua inglese, en). Se maiuscolo è vero la prima lettera del nome ritornato è maiuscola. Se non trova una lingua corrispondente a code ritorna il valore default se questo è definito, altrimenti ritorna stringa nulla '' e il valore di code originariamente passato.
get_voce(code): ritorna il nome della voce dedicata alla lingua corrispondente a code. Se il modulo non trova la voce ritorna stringa nulla ''
lingue(lista_di_lingue): ritorna le lingue corrispondenti a lista_di_lingue formattate come da template {{lingue}}. Se si deve passare una stringa piuttosto che una lista trasformarla in lista, per esempio chiamando la funzione racchiudendo la stringa tra parentesi graffe: lg.lingue( {stringa} )

Per i template

Il modulo comprende anche funzioni per implementare direttamente alcuni template, a cui si rimanda per la sintassi d'uso:

lingue(frame): oltre a fare da interfaccia diretta per altri moduli Lua implementa anche il modulo {{Lingue}}
nomecompleto(frame): implementa le funzionalità di {{nomelingua}}
nome(frame): implementa le funzionalità di {{nomelingua/nome}}
voce(frame): implementa le funzionalità di {{nomelingua/voce}}

Di documentazione

tabella: richiamata da una pagina wiki con {{#Invoke:Lingue|tabella}} ritorna una tabella di tutti i codici e dei nomi e collegamenti alle pagine delle lingue riconosciute.

Note tecniche

I dati utilizzati sono caricati nel modulo modulo:Lingue/Configurazione, che contiene due tabelle, la prima di alias di lingue che associa ad ogni codice riconosciuto per una lingua un codice standard (generalmente il codice ISO_639-3 della lingua). La seconda che associa a ogni codice standard il nome per la lingua e la sua pagina su it.wiki.

Per aggiungere un nuovo alias per una lingua già riconosciuta dal modulo basta aggiungere alla tabella language_config.alias una riga nel formato

    ["alias"] = "codice_standard"',

dove alias è l'alias da inserire e codice_standard è il codice standard che deve essere già inserito nella tabella language_config.codici.

Per inserire una nuova lingua basta aggiungere alla tabella language_config.codici una riga nel formato:

    [ "codice_standard"] = { "nome_lingua", "articolo" },

dove codice_standard è il codice standard usato dal programma (usare in ordine di preferenza codice ISO 639-1 (due lettere) altrimenti il ISO 639-2 (tre lettere), se nessuno dei due esiste usare un altro codice, purchè non sia un codice ISO 639-1 o ISO 639-2 dedicato ad altra lingua), nome lingua il nome della lingua come dev'essere visualizzato a video e articolo il nome dell'articolo di wikipedia dedicato alla lingua. Per inserire codici alternativi per la lingua vedi istruzioni del paragrafo sopra.

Nota bene: i codici e gli alias delle lingue devono essere inseriti in lettere minuscole o non verranno riconosciuti.

local language = {}

-- tabella contenente due tabelle:
-- lg.alias: tabella per normalizzare i codici
-- lg.codici: tabella 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 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". Se "code" non corrisponde a nessuna
-- lingua inserita in tabella ritorna il valore di default o stringa nulla se questo non è 
-- indicato. 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
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
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
    if frame == mw.getCurrentFrame() then
        args = frame:getParent().args
    else
        args = frame
    end
    for _,code in ipairs(args) do
        lingua = language.get_nome(code)
        if lingua ~= "" then
            lingue_list[#lingue_list+1] = '<abbr title="' .. lingua .. '">' .. mw.ustring.upper(code) .. "</abbr>"
        else
            lingue_list[#lingue_list+1] = code
        end
    end
    if #lingue_list > 0 then
        return '(<span style="font-weight:bolder; font-size:80%">' .. table.concat(lingue_list, ",&nbsp;") .. "</span>)"
    end
    return ''
end


-- Restitusce 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


return language