Modulo:Léngoe

Instruçioìn pe l'ûzo
Quésto o l'é 'n mòdolo scrîto in Lua. E instruçioìn chi de sótta són contegnûe inta sotopàgina Modulo:Léngoe/man (modìfica · stöia)
Sandbox: Modulo:Léngoe/sandbox (modìfica · stöia) · Test: Modulo:Léngoe/test (modìfica · stöia · ezegoi)

Quésto Mòdolo Lua o sèrve pe inplementâ e fonçioìn do template {{Léngoe}} e di âtri ligæ a sto lì, p'òfrî e mæxime fonçionalitæ de âtri mòdoli Lua sénsa avéighe da dipénde da-o reciàmmo a-i template.

Fonçioìn

Pe mòdoli Lua

Quésto mòdolo o rénde disponìbili çèrte fonçioìn pe-i âtri mòdoli Lua; pe dêuviâle bezéugna prìmma caregâ o mòdolo con l'instruçión: local lg = require( "Modulo:Léngoe" );.

E fonçioìn saiàn disponìbili cómme lg.nómmefonçión ("lg" o l'é sôlo 'n nómme d'ezénpio, se poriéiva dêuviâ ascì local lingue = require( "Modulo:Léngoe" );, inte sto câxo chi e fonçioìn saiàn reciamæ cómme lingua.nómmefonçión).

esiste(code)

o restitoìsce true se code o corispónde a 'na léngoa, sedónca false.

get_nome(code, maiuscolo, default)

o restitoìsce a cóbia de nómme da léngoa corispondénte a code e code normalizòu (prezénpio se code o l'é "ingléize" o restitoìsce (léngoa ingléize, en)). Se maiuscolo o l'é vêo, a prìmma létia do nómme restitoîo a l'é maióscola. Se o no trêuva de léngoe corispondénti a code, alôa o restitoìsce o valô default se quésto o l'é definîo, âtriménti o restitoìsce a strìnga vêua '' e o valô de code pasòu pe prìmmo.

get_voce(code)

o restitoìsce o nómme da pàgina dedicâ a-a léngoa corispondénte a code. Se o mòdolo o no trêuva a pàgina, alôa o restitoìsce 'na strìnga vêua ''.

lingue(lìsta_de_léngoe))

o restitoìsce e léngoe corispondénti a lìsta_de_léngoe formæ cómme da template {{Léngoe}}. Se o gh'à da pasâ 'na strìnga ciutòsto che 'na lìsta, bezéugna trasformâ quésta inte 'na lìsta, prezénpio ciamàndo a fonçión inta strìnga tra paréntexi gràffe: lg.lingue({strìnga}).

Pe-i template

O mòdolo o l'inclùdde ascì de fonçioìn pe inplementâ di template, a-i quæ se rimànda pe-a scintàsci d'ûzo:

lingue(frame)

o l'inpleménta o mòdolo {{Léngoe}} e o fà ascì da interfàccia pe-i âtri mòdoli Lua.

nomecompleto(frame)

o l'inpleménta e fonçionalitæ de {{Nómmeléngoa}}

nome(frame)

o l'inpleménta e fonçionalitæ de {{Nómmeléngoa/nómme}}

voce(frame)

o l'inpleménta e fonçionalitæ de {{Nómmeléngoa/vôxe}}

In sciâ docomentaçión

tabella

ciamâ da 'na pàgina wiki con {{#Invoke:Lengoàggi|tabella}} o restitoìsce 'na tabélla di còdichi, nómmi e ligàmme a-e pàgine di lengoàggi riconosciûi.

Nòtte téniche

I dæti dêuviæ són pigiæ da-e dôe tabélle do Modulo:Léngoe/Configuraçión: a prìmma a contêgne i alias çernûi pe ciaschedùnn-a léngoa e a l'asòcia a-i còdichi riconosciûi pe 'na léngoa o seu còdice ISO 639-3. A segónda a l'asòcia a ciaschedùn còdice stàndard o nómme pi-â léngoa e a seu pàgina in sciâ lij.wiki (fonçionalitæ no ancón disponìbile).

Pe azónze 'n nêuvo alias pe 'na léngoa za riconosciûa da-o mòdolo o l'abàsta inserî inta tabélla language_config.alias 'na rîga into formâto:

    ["alias"] = "còdice_standard"',

dónde alias o l'é l'alias da inserî e codice_standard o l'é o còdice standard za prezénte inta tabélla language_config.codici.

Pe inserî 'na nêuva léngoa o l'abàsta azónze a-a tabélla language_config.codici 'na rîga into formâto:

    [ "còdice_standard"] = { "nómme_lengoa", "artìcolo" },

dónde còdice_standard o l'é o còdice dêuviòu da-o progràmma, l'é mêgio çèrne o còdice ISO 639-1 (dôe létie) ò ISO 639-2 (træ létie), âtriménti dêuviâ 'n còdice a piâxéi, ch'o no ségge quéllo a-o còdice ISO 639-1 o ISO 639-2 de 'n'âtra léngoa. nómme lengoa o l'é o nómme da léngoa ch'o saiâ mostròu e artìcolo o l'é pe cóntra o nómme da pàgina da wikipedia dedicâ a quélla léngoa. Pe inserî du còdichi alternatîvi pe 'na léngoa védde o paràgrafo de d'âto.

Nòtta bén: i còdichi e i alias de léngue gh'àn da êse inserîi con de létie minóscole, âtriménti no saiàn riconosciûi.

---

local language = {}
local getArgs = require('Module:Arguments').getArgs

-- 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:Léngoe/Configuraçión');

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

-- Restituisce 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, restituisce il valore di default
-- o stringa nulla se questo non è indicato e il codice richiesto. Se maiuscolo è vero il
-- nome viene restituito con la prima lettera maiuscola.
function language.get_nome(code, maiuscolo, default)
	local nome = default or ''
	if code ~= nil and code ~= '' then
		-- prova a cercare la lingua fra gli alias
		if lg.alias[code] then
			code = lg.alias[code]
		-- altrimenti converte il testo in minuscolo e prova sia a ricercare
		-- fra gli alias sia a estrarre la prima parte di codici come it-IT
		else
			code = mw.ustring.lower(code)
			code = lg.alias[code] or mw.ustring.gsub(code, '(%l+)%-.*', '%1')
		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:Nómmeléngoa
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 parametro 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 lingua, codice_normalizzato, code_to_show

	local yet_processed = {}
	for _,code in ipairs(args) do
		lingua, codice_normalizzato = language.get_nome(code)
		codice_normalizzato = mw.ustring.upper(codice_normalizzato)
		if not yet_processed[ codice_normalizzato ] then
			if lingua ~= "" then
				lingue_list[#lingue_list+1] = '<abbr title="' .. lingua .. '">' ..codice_normalizzato .. "</abbr>"
				yet_processed[ codice_normalizzato ] = true
			else
				lingue_list[#lingue_list+1] = code
				if return_error then error_list[#error_list+1] = code end
			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

-- ========================================================
-- Ritorna la stringa txt inserita in un tag <span> con indicato
-- il codice linguaggio del testo (language_code) e il senso
-- di lettura (sinistro o destro).
-- Il parametro "corsivo" permette di indicare se il testo
-- deve essere messo in corsivo, ha tre valori:
-- -- d: consulta le tabelle di configurazione per il linguaggio
-- -- s: forza corsivo attivo
-- -- n: forza corsivo disattivo (è il valore di default)
-- ========================================================
function language._lang_testo(args)
	local txt = args.txt or args[2]
	if not txt then return '' end
	local language_code = args.lang or args[1]
	local direction = "ltr"
	if language_code then
		language_code = mw.ustring.lower(language_code)
		language_code = lg.alias[language_code] or language_code
		local writing = lg.scrittura[language_code]
		if writing then
			direction = writing[1]
			if #writing > 1 then language_code = writing[2] end
		end
	end
	local set_italic = args.corsivo or "n"
	if set_italic ~= "n" then
		local italic = false
		if set_italic:lower() == 's' then
			italic = true
		elseif language_code and lg.codici[language_code] then
			italic = not lg.codici[language_code][3]
		else
			italic = true
		end	  
		if italic then
			if txt[1]=="'" then txt = "<nowiki />" .. txt end
			if txt[#txt] =="'" then txt = txt .. "<nowiwiki />" end
			txt = mw.ustring.format("''%s''", txt)
		end
	end
	local span = mw.html.create('span'):wikitext(txt):addClass(args.class)
	if lg.codici[language_code] then
		span
			:attr('dir', direction)
			:attr('lang', language_code)
			:attr('xml:lang', language_code)
	end			
	return tostring(span)
end

-- ========================================================
-- Funzione di interfaccia per _lang_testo
-- richiamabile nei template
-- ========================================================
function language.lang_testo(frame)
	local args = getArgs(frame)
	return language._lang_testo(args)
end

-- Restituisce una tabella con tutti i codici riconosciuti dal modulo
function language.tabella(frame)

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

	local root = mw.html.create('table')
	root
		:addClass('wikitable sortable')
		:tag('tr')
			:tag('th'):wikitext('Codici'):done()
			:tag('th'):wikitext('[[template:Nomelingua/nome]]'):done()
			:tag('th'):wikitext('[[template:Nomelingua/voce]]'):done()
			:tag('th'):wikitext('[[template:Léngoe]]')

	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 root = mw.html.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 root = mw.html.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