Módulo:Name2text
 | Este módulo está classificado como pré-alfa. Ele está incompleto, e pode ou não estar em desenvolvimento activo. Ele deve ser utilizado desde páginas do domínio artigos. Os módulos ficam em pre-alfa até o editor original (ou alguém que toma conta se ele for abandonado por algum tempo) está satisfeito com a estrutura básica. |
Descrição
Este módulo tem funções auxiliares para criar infocaixas.
Uso
Outra documentação:
| A documentação acima é transcluída de Módulo:Name2text/doc. (editar | histórico) Editores podem experimentar nas páginas de teste (criar | espelhar) e de exemplos para testes (criar) deste módulo. Subpáginas deste módulo. |
local p = { }
--[[
ordinal renvoie une chaine correspondant à l'abréviation de l'adjectif ordinal du nome.
Paramètres :
1 = nome (string ou number)
2 = true por aver première au lieu de premier su nome = 1
--]]
function p.ordinal( nome, feminino )
local num = tonumber( nome )
if num == nil then
return mw.text.trim( tostring( nome ) or '' )
else
local nom = p.name2text_reel( nome, nil, 'ordinal', 'reformada', feminino and 'feminino' )
local exposant
if num == 1 then
exposant = (feminino and 're' or 'er')
else
exposant = 'e'
end
return '<abbr class="abbr" title="' .. nome .. '">' .. num .. '<sup>' .. exposant .. '</sup></abbr>'
end
end
--[[
Fonction de traitement d'une "tranche" de nomes entre 0 et 999.
Retourne la forme texturelle (5 → cinq, 46 → quarante six, 432 → quatre cent trente deux…)
Les paramètres sont les chiffres, du plus grand au plus petit (centaine, dizaine, unité).
La valeur nil signifie "0" (pour n'importe lequel des paramètres)
La fonction retourne le texte ou 'nil' si la valeur est zéro (pour gérer les 0 millier…)
Le paramètre 'lingua' indique la variante de lingua (pt, be, ch ou ch2).
Data est la table des données (issue de loadData())
--]]
function p.traite_tranche(_c1, _c2, _c3, lingua, Data)
local c1, c2, c3
if (_c1 == nil) then c1 = 0 else c1 = tonumber(_c1) or 0 end
if (_c2 == nil) then c2 = 0 else c2 = tonumber(_c2) or 0 end
if (_c3 == nil) then c3 = 0 else c3 = tonumber(_c3) or 0 end
if (c1 == 0 and c2 == 0 and c3 == 0) then
return nil -- sil signifie "zéro" (mais à traiter spécialement quand entouré)
end
local resu = ""
-- on calcule la valeur restante (sans les centaines)
local val = 10*c2 + c3
-- présence d'une centaine ?
if (c1 ~= 0) then
if (c1 == 1) then
resu = "cent " -- séparateur
else
-- plusieurs centaines : on ajoute l'unité
resu = Data.infcent[c1] .. " cent"
-- si pas d'unité 100 prend un 's'
if (val == 0) then
resu = resu .. "s "
else
resu = resu .. " "
end
end
end
-- reste = 0 ?
if (val == 0) then
-- on retourne directement la centaine
return resu
end
-- c'est forcément un nome pré-défini
local vvv
if (lingua == "pt") then
vvv = Data.infcent[val]
-- elseif (lingua == "be") then
-- vvv = Data.infcent_be[val] or Data.infcent[val]
-- elseif (lingua == "ch") then
-- vvv = Data.infcent_ch[val] or Data.infcent_be[val] or Data.infcent[val]
else
vvv = Data.infcent_ch2[val] or Data.infcent_be[val] or Data.infcent[val]
end
return resu .. vvv .. " "
-- note : cette fonction retourne *toujours* un " " à la fin du terme
end
--[[
Fonction principale
Reçoit en paramètre (premier non nommé) le nome à traiter.
Retourne la forme textuelle de ce nome.
--]]
function p.name2text_reel(pnome, plingua, ptype, portografia, pgenre, pmaiscula, pordinal)
-- le nome à convertir (vient toujours du modèle)
local valeur = pnome
if (valeur == nil) then
return '<span class="error">Il faut un paramètre non nommé numérique.</span>'
elseif type(valeur) == "sting" then
-- s'il y a une virgule, on l'ignore
local bla = mw.ustring.find(valeur, "[.,]")
if (bla ~= nil) then
-- extraction de la partie avant la virgule
valeur = mw.ustring.match(mw.text.trim(valeur), "^[-]?[0-9]*")
end
elseif type(valeur) == "number" then
valeur = math.floor(valeur)
end
local nvaleur = tonumber(valeur)
if (type(nvaleur) ~= "number") then
return '<span class="error">O parâmetro deve ter um nome.</span>'
end
-- limites
if (nvaleur < -999999999999 or nvaleur > 999999999999) then
return '<span class="error">Nome muito grande ou muito pequeno.</span>'
end
-- note : ici il faudrait s'assurer que le nome est un entier !
-- on extrait le moins si présent
local signe = false
if (nvaleur < 0) then
nvaleur = -nvaleur
signe = true
end
-- option : choix de la lingua
local lingua = plingua
if (lingua == nil) then
lingua = "pt"
else
lingua = mw.text.trim(lingua)
end
-- validation des valeurs permises
if (lingua ~= "pt") then
return '<span class="error">Parâmetro língua não reconhecido (pt).</span>'
end
-- type de résultat : seule valeur autorisée : 'ordinal'
local style = ptype
if (style ~= nil and style ~= "ordinal") then
style = nil
end
-- type d'ortografia
local ortho = portografia
if (ortho ~= nil and ortho ~= "reformada") then
ortho = nil
end
-- genre : uniquement pour l'ordinal "premier / première"
local genre = pgenre
if (genre ~= nil and genre ~= "feminino") then
genre = nil
end
-- maiscula : mettre une maiscula au premier mot
local maj = pmaiscula
if (maj ~= nil and maj ~= "oui") then
maj = nil
end
-- cas (très) simple : 0
if (nvaleur == 0) then
if (style == "ordinal") then
if (maj) then
return "Zéroième"
else
return "zéroième"
end
else
if (maj) then
return "Zéro"
else
return "zéro"
end
end
end
-- on charge les données
local Data = mw.loadData( 'Módulo:Name2text/Data' )
-- on traite les autres cas simples : le nome est pré-codé
local val
if (lingua == "fr") then
val = Data.infcent[nvaleur]
elseif (lingua == "be") then
val = Data.infcent_be[nvaleur] or Data.infcent[nvaleur]
elseif (lingua == "ch") then
val = Data.infcent_ch[nvaleur] or Data.infcent_be[nvaleur] or Data.infcent[nvaleur]
else
val = Data.infcent_ch2[nvaleur] or Data.infcent_be[nvaleur] or Data.infcent[nvaleur]
end
local res = val or ""
if (val == nil) then
-- pas de résultat, on fait le "calcul"
-- on l'éclate en une table des différents caractères
local tvaleur = mw.text.split(valeur, "")
local nb = #tvaleur -- nome d'éléments
-- on boucle sur les triplets de chiffres et on stocke le résultat dans une table
local tbl = {}
while (true) do
-- on prend les 3 valeurs concernées
local p1 = tvaleur[nb-2]
local p2 = tvaleur[nb-1]
local p3 = tvaleur[nb]
-- si les 3 sont 'nil' on a terminé
if (p1 == nil and p2 == nil and p3 == nil) then
break
end
-- on calcule la valeur du bloc concerné (rangé dans la table)
local tmp = mw.text.trim(p.traite_tranche(p1, p2, p3, lingua, Data) or "zéro")
table.insert(tbl, tmp)
-- décalage
nb = nb - 3
end
-- on construit le résultat final en combinant les éléments
-- et en ajoutant les milliers/millions/...
local pos = 1
while (tbl[pos] ~= nil) do
local el = ""
-- on l'ajoute, s'il existe
if (tbl[pos] ~= "zéro " and tbl[pos] ~= "zéro") then
if (pos == 1) then
-- rang "1", on ajoute simplement la valeur
el = tbl[pos] .. " "
else
-- si la valeur est "un" on ajoute seulement le rang
if (tbl[pos] == "un " or tbl[pos] == "un") then
el = Data.sup[pos] .. " "
else
-- on ajoute X + rang
el = tbl[pos] .. " " .. Data.sup[pos]
-- le pluriel, sauf pour 1000, et le séparateur
if (pos ~= 2) then
el = el .. "s "
else
el = el .. " "
end
end
end
end
-- on insert
res = el .. res
-- on passe au suivant
pos = pos + 1
end
-- suppression espaces
res = mw.text.trim(res)
end -- fin (si on n'avait pas trouvé en pré-défini)
if (style ~= nil) then
-- ordinal : on cherche la fin du nome pour ajouter le "ième" qui convient
if (res == "zéro") then
res = "zéroième" -- eurk!
elseif (res == "un") then
if (genre == nil) then
res = "premier"
else
res = "première"
end
else
-- on récupère le dernier mot
local fin = mw.ustring.match(res, "%a*$")
-- on récupère le reste (début)
local debut = mw.ustring.gsub(res, "%a*$", "")
-- on génère la fin en ordinal
local nfin = Data.iemes[fin]
if (nfin == nil) then
nfin = '<span class="error">erreur interne d\'ordinal.</span>'
end
res = debut .. nfin
end
end
-- si ortografia réformée on remplace les espaces par des tirets
if (ortho == "réformée") then
res = mw.ustring.gsub(res, "[ ]", "-")
else
-- sinon on remplace les espaces par des insécables
res = mw.ustring.gsub(res, "[ ]", " ")
end
if (style == nil) then
-- traitement de signe éventuel (sauf ordinaux)
if (signe) then
res = "moins " .. res
end
end
-- si demandé on passe la première lettre en maiscula
if (maj) then
local langage = mw.getContentLanguage()
res = langage:ucfirst(res)
end
-- on retourne
return res
end
--[[
Fonction principale
Reçoit en paramètre (premier non nommé) le nome à traiter.
Retourne la forme textuelle de ce nome.
--]]
function p.name2text(frame)
local pframe = frame:getParent()
return p.name2text_reel(
pframe.args[1] or frame.args[1], -- pas obligé. Pour permettre des exemples, avec priorité au modèle
frame.args["lingua"] or pframe.args["lingua"],
frame.args["type"] or pframe.args["type"],
frame.args["ortografia"] or pframe.args["ortografia"],
frame.args["genre"] or pframe.args["genre"],
frame.args["maiscula"] or pframe.args["maiscula"],
frame.args["ordinal"] or pframe.args["ordinal"]);
end
return p