« Module:Langue » : différence entre les versions
Contenu supprimé Contenu ajouté
tout le monde n'utilise pas l'éditeur de code… par exemple je copie dans un éditeur externe |
détection d'erreur en cherchant « class="error" » : commentaire code plus précis, et ajout d'un exemple de recherche de ces codes sur le wiki |
||
(43 versions intermédiaires par 5 utilisateurs non affichées) | |||
Ligne 1 : | Ligne 1 : | ||
-- luacheck: globals mw, no max line length |
|||
local Langue = { } |
local Langue = { } |
||
local dataLangue = mw.loadData 'Module:Langue/Data' |
local dataLangue = mw.loadData( 'Module:Langue/Data' ) |
||
-- attention, plusieurs modules cherchent « class="error" » pour détecter si ce module a retourné une erreur |
|||
-- pour trouver ces codes, on peut rechercher dans le namespace Module : insource:Langue insource:/(find|match)\([^)]+error/ |
|||
local langErrorMess = '<span class="error">langue non reconnue : %s</span>' |
local langErrorMess = '<span class="error">langue non reconnue : %s</span>' |
||
Ligne 24 : | Ligne 29 : | ||
end |
end |
||
-- determinationCode retourne une table contenant le code de langue principal et la liste des |
-- determinationCode retourne une table contenant le code de langue principal et la liste des subcodes |
||
-- si le code de langue principal n'est pas reconnu, retourne nil. |
-- si le code de langue principal n'est pas reconnu, retourne nil. |
||
function Langue.determinationCode( langue ) |
function Langue.determinationCode( langue ) |
||
Ligne 67 : | Ligne 72 : | ||
return 'ltr' |
return 'ltr' |
||
end |
end |
||
-- séparation du code de langue en code principal et les différents |
-- séparation du code de langue en code principal et les différents subcodes. |
||
local tabCode = Langue.determinationCode( arg ) |
local tabCode = Langue.determinationCode( arg ) |
||
if tabCode then |
if tabCode then |
||
Ligne 73 : | Ligne 78 : | ||
local codeScript = tabCode[2] |
local codeScript = tabCode[2] |
||
if codeScript and string.len( codeScript ) == 4 and dataLangue[ 'rtl script' ] then |
if codeScript and string.len( codeScript ) == 4 and dataLangue[ 'rtl script' ] then |
||
-- il y a un subcode d' |
-- il y a un subcode d'écriture, c'est lui qui est pris en compte |
||
codeScript = string.upper( string.sub( codeScript, 1, 1 ) ) .. string.sub( codeScript, 2 ) |
codeScript = string.upper( string.sub( codeScript, 1, 1 ) ) .. string.sub( codeScript, 2 ) |
||
if dataLangue[ 'rtl script' ][ codeScript ] then |
if dataLangue[ 'rtl script' ][ codeScript ] then |
||
Ligne 79 : | Ligne 84 : | ||
end |
end |
||
else |
else |
||
-- il n'y a pas de |
-- il n'y a pas de subcode d'écriture, on prend en compte le code de langue principal. |
||
local tabLangue = dataLangue[ tabCode[1] ] |
local tabLangue = dataLangue[ tabCode[1] ] |
||
if tabLangue and tabLangue.rtl then |
if tabLangue and tabLangue.rtl then |
||
Ligne 86 : | Ligne 91 : | ||
end |
end |
||
end |
end |
||
-- la langue n'est pas écrite de droite à gauche, donc ltr. |
-- la langue n'est pas écrite de droite à gauche, donc ltr. |
||
return 'ltr' |
return 'ltr' |
||
Ligne 92 : | Ligne 97 : | ||
local function getDataLangue( frame ) |
|||
-- Voir Modèle:Nom langue |
|||
-- Obtenir le code de la langue |
|||
-- Paramètre : |
|||
local codeLangue = premierParametre( frame, true ) |
|||
-- 1 : code IETF de langue. |
|||
-- Si le paramètre est incorrect, retourner un message d'erreur |
|||
function Langue.nomLangue( frame ) |
|||
if type( codeLangue ) ~= 'string' or codeLangue == '' then |
|||
local arg = premierParametre( frame, true ) |
|||
return nil, '<span class="error">langue non précisée</span>' |
|||
if type( arg ) ~= 'string' or arg == '' then |
|||
return '<span class="error">langue non précisée</span>' |
|||
end |
end |
||
local tabLangue = dataLangue[ arg ] |
|||
-- Obtenir le tableau contenant les informations sur la langue |
|||
if tabLangue == nil then |
|||
local tabLangue = dataLangue[ codeLangue ] |
|||
-- Si le code étendu n'est pas trouvé, chercher à nouveau avec le code racine |
|||
if not tabLangue then |
|||
tabLangue = dataLangue[ mw.ustring.match( codeLangue, '^(%a-)%-' ) ] |
|||
end |
end |
||
-- Si on n'a toujours rien trouvé, retourner un message d'erreur |
|||
if not tabLangue then |
if not tabLangue then |
||
return |
return nil, langErrorMess:format( codeLangue ) |
||
end |
end |
||
return tabLangue |
|||
end |
|||
-- Fonction fournissant un wikilien vers l'article |
|||
-- traitant d'une langue à partir de son code. |
|||
-- Voir Modèle:Lien langue |
|||
-- Paramètre : |
|||
-- 1 : code IETF de langue. |
|||
function Langue.lienLangue( frame ) |
|||
local tabLangue, erreur = getDataLangue( frame ) |
|||
if not tabLangue then |
|||
return erreur |
|||
end |
|||
-- Créer un lien pour la langue depuis le tableau |
|||
if type( tabLangue.page ) == 'string' then |
if type( tabLangue.page ) == 'string' then |
||
if tabLangue.page ~= '' then |
if tabLangue.page ~= '' then |
||
Ligne 118 : | Ligne 142 : | ||
end |
end |
||
-- Fonction permettant de récupérer le nom d'une langue à partir de son code. |
|||
-- Voir Modèle:Nom langue |
|||
-- Paramètre : |
|||
-- 1 : code IETF de langue. |
|||
-- Retourne : |
|||
-- Le nom de la langue, un message d'erreur sinon. |
|||
function Langue.nomLangue( frame ) |
|||
local tabLangue, erreur = getDataLangue( frame ) |
|||
if not tabLangue then |
|||
return erreur |
|||
end |
|||
-- Extraire le nom de la langue depuis le tableau |
|||
return tabLangue.nom |
|||
end |
|||
-- Fonction permettant de récupérer le nom de l'article |
|||
-- portant sur une langue à partir de son code. |
|||
-- Voir Modèle:Article langue |
|||
-- Paramètre : |
|||
-- 1 : code IETF de langue. |
|||
-- Retourne : |
|||
-- Le nom de l'article portant sur la langue |
|||
-- si le code est trouvé, un message d'erreur sinon. |
|||
function Langue.articleLangue( frame ) |
|||
local tabLangue, erreur = getDataLangue( frame ) |
|||
if not tabLangue then |
|||
return erreur |
|||
end |
|||
-- Extraire le titre de l'article depuis le tableau |
|||
if type( tabLangue.page ) == 'string' and tabLangue.page ~= '' then |
|||
return tabLangue.page |
|||
else |
|||
return tabLangue.nom |
|||
end |
|||
end |
|||
-- Voir Modèle:Langue |
-- Voir Modèle:Langue |
||
Ligne 133 : | Ligne 194 : | ||
end |
end |
||
local dir = args.dir |
local dir = args.dir |
||
local namespaceCategorisation = { [0] = true, [4] = true, [10] = true, [12] = true, [14] = true, [100] = true } |
|||
local categorisation = namespaceCategorisation[ mw.title.getCurrentTitle().namespace ] and not args.nocat |
|||
-- Décalage des paramètres si code contient la direction du texte (obsolète mais toujours possible). |
-- Décalage des paramètres si code contient la direction du texte (obsolète mais toujours possible). |
||
if code == 'ltr' or code == 'rtl' then |
if code == 'ltr' or code == 'rtl' then |
||
Ligne 141 : | Ligne 204 : | ||
end |
end |
||
local codeArg = code |
local codeArg = code |
||
-- sortie immédiate s'il n'y a pas de texte |
|||
if texte == '' then |
|||
if categorisation then |
|||
return '<span class="error">erreur du modèle [[modèle:Langue|{{langue}}]] : texte absent</span>[[Catégorie:Page utilisant un modèle avec une syntaxe erronée|Langue]]' |
|||
else |
|||
return '' |
|||
end |
|||
end |
|||
-- récursion si texte contient des blocs |
-- récursion si texte contient des blocs |
||
if texte:match('\n *\n') or texte:match('\n[*#:]') then |
if texte:match('\n *\n') or texte:match('\n[*#:]') then |
||
-- les parenthèses permettent d'éliminer la seconde valeur retournée par gsub (nombre de |
-- les parenthèses permettent d'éliminer la seconde valeur retournée par gsub (nombre de remplacements) |
||
return ( texte:gsub( |
return ( texte:gsub( |
||
'(\n?[*#:]?%s*)([^\n]+)', |
|||
function ( init, ligne ) |
|||
return init .. Langue.langue{ code, ligne } |
|||
end |
|||
) ) |
|||
end |
end |
||
-- Si la langue est reconnue, la valeur de la table est prise en compte (permet de corriger les noms de langue en toutes lettres). |
-- Si la langue est reconnue, la valeur de la table est prise en compte (permet de corriger les noms de langue en toutes lettres). |
||
local tabCode = Langue.determinationCode( code ) |
local tabCode = Langue.determinationCode( code ) |
||
Ligne 159 : | Ligne 231 : | ||
code = table.concat( tabCode, '-' ) |
code = table.concat( tabCode, '-' ) |
||
tabLangue = dataLangue[ tabCode[1] ] |
tabLangue = dataLangue[ tabCode[1] ] |
||
local codeScript = tabCode[2] |
local codeScript = tabCode[2] |
||
-- Si codeScript est bien un style d'écriture (len = 4) on applique sa direction |
-- Si codeScript est bien un style d'écriture (len = 4) on applique sa direction |
||
Ligne 171 : | Ligne 243 : | ||
end |
end |
||
end |
end |
||
-- Préparation du rendu de direction du texte. |
-- Préparation du rendu de direction du texte. |
||
dir = dir and dir:lower() |
dir = dir and dir:lower() |
||
Ligne 183 : | Ligne 255 : | ||
html:wikitext( texte ) |
html:wikitext( texte ) |
||
else |
else |
||
html |
local span = mw.html.create( 'span' ) |
||
:addClass( 'lang-' .. code ) |
:addClass( 'lang-' .. code ) |
||
:attr |
:attr( 'lang', code ) |
||
:attr( 'dir', dir ) |
|||
:wikitext( texte ) |
:wikitext( texte ) |
||
:done() |
|||
if args.class and args.class ~= '' then |
|||
span:addClass( args.class ) |
|||
end |
|||
html:node( span ) |
|||
-- Translittération. |
-- Translittération. |
||
if ( args.trans or '' ) ~= '' then |
if ( args.trans or '' ) ~= '' then |
||
local trans = args.trans:gsub( "^''%f[^'](.+)%f[']''$", "%1" ) |
|||
html:wikitext( " (''" ) |
html:wikitext( " (''" ) |
||
:tag( 'span' ) |
:tag( 'span' ) |
||
Ligne 196 : | Ligne 275 : | ||
:attr( 'lang', code .. '-Latn' ) |
:attr( 'lang', code .. '-Latn' ) |
||
:attr( 'dir', 'ltr' ) |
:attr( 'dir', 'ltr' ) |
||
:wikitext( |
:wikitext( trans ) |
||
:done() |
:done() |
||
:wikitext( "'')" ) |
:wikitext( "'')" ) |
||
Ligne 204 : | Ligne 283 : | ||
-- Ajout de la catégorie Page avec code de langue invalide si le code langue non reconnu ou invalide. |
-- Ajout de la catégorie Page avec code de langue invalide si le code langue non reconnu ou invalide. |
||
if type( tabLangue ) ~= 'table' or tabCode.invalide then |
if categorisation and ( type( tabLangue ) ~= 'table' or tabCode.invalide ) then |
||
local erreur = string.format( langErrorMess, codeArg ) |
|||
local namespaceCategorisation = { [0] = true, [4] = true, [10] = true, [12] = true, [14] = true, [100] = true } |
|||
if codeArg == '' then |
|||
if namespaceCategorisation[ mw.title.getCurrentTitle().namespace ] then |
|||
erreur = '<span class="error">langue non précisée</span>' |
|||
local erreur = string.format( langErrorMess, codeArg ) |
|||
if codeArg == '' then |
|||
erreur = '<span class="error">langue non précisée</span>' |
|||
end |
|||
html:wikitext( '[[Catégorie:Page avec code de langue invalide]] ' .. erreur ) |
|||
end |
end |
||
html:wikitext( '[[Catégorie:Page avec code de langue invalide|Langue]] ' .. erreur ) |
|||
end |
end |
||
Ligne 234 : | Ligne 310 : | ||
local texte = args.texte |
local texte = args.texte |
||
local dir = args.dir |
local dir = args.dir |
||
local wikiText = '' |
|||
-- Cas où le premier et/ou le deuxième paramètre est vide. |
-- Cas où le premier et/ou le deuxième paramètre est vide. |
||
if code == '' and nomLangue == '' then |
if code == '' and nomLangue == '' then |
||
Ligne 250 : | Ligne 326 : | ||
-- Gestion du texte. |
-- Gestion du texte. |
||
if texte and texte ~= '' then |
if texte and texte ~= '' then |
||
texte = ' |
texte = '\194\160' .. Langue.lang{ code, dir = dir, texte = texte } |
||
else |
else |
||
texte = '' |
texte = '' |
||
Ligne 263 : | Ligne 339 : | ||
:done() |
:done() |
||
:wikitext( texte ) |
:wikitext( texte ) |
||
return tostring( html ) |
return tostring( html ) |
||
end |
end |
||
Ligne 273 : | Ligne 349 : | ||
local listeNom = { } |
local listeNom = { } |
||
local listeCode = { } |
local listeCode = { } |
||
local tabLangue |
|||
-- Valeur par défaut du premier paramètre = 'mul'. |
-- Valeur par défaut du premier paramètre = 'mul'. |
||
local code = mw.text.trim( args[1] or '' ) |
local code = mw.text.trim( args[1] or '' ) |
||
Ligne 279 : | Ligne 355 : | ||
code = 'mul' |
code = 'mul' |
||
end |
end |
||
local maxLang = tonumber(args.maxLang) or nil |
|||
if not args[2] and not dataLangue[ mw.ustring.lower( code ) ] then |
if not args[2] and not dataLangue[ mw.ustring.lower( code ) ] then |
||
local split = mw.text.split( code, '[+,;:/ .]+' ) |
local split = mw.text.split( code, '[+,;:/ .]+' ) |
||
if #split > 1 then |
if #split > 1 then |
||
split.maxLang = maxLang |
|||
return Langue.indicationMultilingue( split ) |
return Langue.indicationMultilingue( split ) |
||
end |
end |
||
Ligne 306 : | Ligne 384 : | ||
code = mw.text.trim( args[i] or '' ) |
code = mw.text.trim( args[i] or '' ) |
||
until code == '' |
until code == '' |
||
-- Préparation et renvoi du texte. |
-- Préparation et renvoi du texte. |
||
local n = #listeCode |
local n = #listeCode |
||
if n == 0 then |
if n == 0 then |
||
return '' |
return '' |
||
end |
|||
if maxLang and n > maxLang then |
|||
listeCode = {'mul'} |
|||
end |
end |
||
local plusieurs = ( n > 1 ) |
local plusieurs = ( n > 1 ) |
||
local html = mw.html.create( 'abbr' ) |
local html = mw.html.create( 'abbr' ) |
||
:addClass( 'abbr' ) |
:addClass( 'abbr' ) |
||
:addClass( 'indicateur-langue' ) |
:addClass( 'indicateur-langue' ) |
||
:attr( 'title', 'Langue' .. ( plusieurs and 's' or '' ) .. ' : ' .. mw.text.listToText( listeNom ) ) |
:attr( 'title', 'Langue' .. ( plusieurs and 's' or '' ) .. ' : ' .. mw.text.listToText( listeNom ) ) |
||
:wikitext( '(' .. table.concat( listeCode, ' |
:wikitext( '(' .. table.concat( listeCode, '\194\160+\194\160' ) .. ')' ) |
||
return tostring( html ) |
return tostring( html ) |
||
end |
end |
||
Ligne 336 : | Ligne 417 : | ||
local trans = args.trans |
local trans = args.trans |
||
local dir = args.dir |
local dir = args.dir |
||
local wikiText = '' |
|||
-- Détection de la direction du texte. |
-- Détection de la direction du texte. |
||
Ligne 346 : | Ligne 426 : | ||
-- Définition du nom de la langue en français. |
-- Définition du nom de la langue en français. |
||
local nom = Langue. |
local nom = Langue.lienLangue{ code } |
||
if texte ~= '' then |
if texte ~= '' then |
||
texte = ' |
texte = ' ' .. Langue.lang{ code, dir = dir, texte = texte, trans = trans } |
||
end |
end |
||
return nom .. ' :' .. texte |
|||
return wikiText |
|||
end |
end |
||
Ligne 376 : | Ligne 454 : | ||
-- pour la page de discussion de la base de données et ceux qui veulent surveiller cette page. |
-- pour la page de discussion de la base de données et ceux qui veulent surveiller cette page. |
||
function Langue.erreurModuleData() |
function Langue.erreurModuleData() |
||
if type( dataLangue ) ~= 'table' |
if type( dataLangue ) ~= 'table' then |
||
local message = [[<strong class="error">Le chargement du module Langue/Data génère une erreur |
local message = [[<strong class="error">Le chargement du module Langue/Data génère une erreur.</strong> <br> |
||
<span class="error">Cette erreur doit être corrigée au plus vite car des milliers de pages ne s'affichent pas correctement.</span> |
<span class="error">Cette erreur doit être corrigée au plus vite car des milliers de pages ne s'affichent pas correctement.</span> |
||
]] |
]] |
||
return |
return message |
||
end |
end |
||
end |
end |
||
Ligne 393 : | Ligne 471 : | ||
!scope=col|Code IETF |
!scope=col|Code IETF |
||
!scope=col|Nom principal |
!scope=col|Nom principal |
||
!scope=col| |
!scope=col|Titre de l'article<br>(si différent du nom) |
||
!scope=col|Lien vers l'article |
|||
!scope=col|RTL |
!scope=col|RTL |
||
!scope=col|Invalide]] |
!scope=col|Invalide]] |
||
local ligneTab, ligneSrt |
local ligneTab, ligneSrt |
||
for |
for k, v in pairs( dataLangue ) do |
||
if v.code then |
if v.code then |
||
ligneTab = { |
ligneTab = { |
||
k, |
|||
v.code, |
v.code, |
||
v.nom, |
v.nom, |
||
v.page or '', |
v.page or '', |
||
Langue.lienLangue(v.code), |
|||
v.rtl and '[[Image:Yes check.svg|15px|oui|lien=]]' or '', |
|||
v. |
v.rtl and '[[Fichier:Yes check.svg|15px|oui|lien=]]' or '', |
||
v.invalide and '[[Fichier:Yes check.svg|15px|oui|lien=]]' or '', |
|||
} |
} |
||
ligneSrt = table.concat( ligneTab, '\n|' ) |
ligneSrt = table.concat( ligneTab, '\n|' ) |
||
Ligne 415 : | Ligne 495 : | ||
table.insert( tableau, 1, entete ) |
table.insert( tableau, 1, entete ) |
||
table.insert( tableau, '}' ) |
table.insert( tableau, '}' ) |
||
return table.concat( tableau, '\n|-\n|' ) |
return table.concat( tableau, '\n|-\n|' ) |
||
end |
end |
||
Ligne 423 : | Ligne 503 : | ||
local languesTab, listeCodesAlias = { }, { } |
local languesTab, listeCodesAlias = { }, { } |
||
local code, alias, codeAlias |
local code, alias, codeAlias |
||
for |
for k, v in pairs( dataLangue ) do |
||
-- on construit un table avec pour indices les codes de langue, et pour valeurs une table avec la liste des alias |
-- on construit un table avec pour indices les codes de langue, et pour valeurs une table avec la liste des alias |
||
code = v.code |
code = v.code |
||
if code and not v.invalide then |
if code and not v.invalide then |
||
languesTab[code] = languesTab[code] or { } |
languesTab[code] = languesTab[code] or { } |
||
if |
if k ~= mw.ustring.lower( code ) then |
||
table.insert( languesTab[code], |
table.insert( languesTab[code], k ) |
||
end |
end |
||
end |
end |
||
end |
end |
||
for |
for k, v in pairs( languesTab ) do |
||
-- transformation en un table séquence, avec pour valeur une chaine correspondant à une ligne de la liste |
-- transformation en un table séquence, avec pour valeur une chaine correspondant à une ligne de la liste |
||
alias = table.concat( v, ', ' ) |
alias = table.concat( v, ', ' ) |
||
if alias == '' then |
if alias == '' then |
||
codeAlias = '* <code>' .. |
codeAlias = '* <code>' .. k .. '</code>' |
||
else |
else |
||
codeAlias = '* <code>' .. |
codeAlias = '* <code>' .. k .. '</code> : ' .. alias |
||
end |
end |
||
table.insert( listeCodesAlias, codeAlias ) |
table.insert( listeCodesAlias, codeAlias ) |
||
end |
end |
||
table.sort( listeCodesAlias ) |
table.sort( listeCodesAlias ) |
||
return table.concat( listeCodesAlias, '\n' ) |
return table.concat( listeCodesAlias, '\n' ) |
||
end |
end |
||
Ligne 452 : | Ligne 532 : | ||
local languesTab = { } |
local languesTab = { } |
||
local code |
local code |
||
for |
for k, v in pairs( dataLangue ) do |
||
-- on construit un table avec pour indices les codes de langue, et pour valeurs une table avec la liste des alias |
-- on construit un table avec pour indices les codes de langue, et pour valeurs une table avec la liste des alias |
||
code = v.code |
code = v.code |
||
if code and |
if code and k ~= code and not v.invalide then |
||
table.insert( languesTab, '* ' .. |
table.insert( languesTab, '* ' .. k .. ' = ' .. code ) |
||
end |
end |
||
end |
end |
||
table.sort( languesTab ) |
table.sort( languesTab ) |
||
return table.concat( languesTab, '\n' ) |
return table.concat( languesTab, '\n' ) |
||
end |
end |
Dernière version du 25 décembre 2023 à 23:55
[voir] [modifier] [historique] [purger]
Utilisation
Fonctions exportables :
codeLangue(frame)
: Convertit en code de langue IETF les noms français de langues les plus couramment citées.codeLangue2(frame)
: Similaire àcodeLangue
à une exception près : si le nom de la langue ne se trouve pas dans la liste qui suit, le modèle n'affiche rien.directionLangue(frame)
: Convertit en code de direction (rtl ou ltr) les codes ou noms français de langues.lienLangue(frame)
: À partir d'un code de langue, retourne un lien avec le nom descriptif de celle-ci et pointant vers son article.nomLangue(frame)
: À partir d'un code de langue, retourne le nom descriptif de celle-ci.articleLangue(frame)
: À partir d'un code de langue, retourne le titre de l'article concernant celle-ci.lang(frame)
: Indique la langue d’un texte dans le code HTML, notamment pour les synthétiseurs vocaux et l’indexation correcte des inclusions de mots en langue différente par les moteurs de recherche.langue(frame)
: Similaire àlang
mais permet d’employer dans certains cas le nom de la langue en toutes lettres.indicationDeLangue(frame)
: Utilisable comme métamodèle pour créer des indications de langue (cf. (fr), (de), etc.).indicationMultilingue(frame)
: Similaire àindicationDeLangue
à l'exception qu'elle indique plusieurs langues. Sans paramètre, (mul) est indiqué.langueAvecNom(frame)
: Indique le nom de la langue avant un court texte dans une langue donnée et met le texte en langue étrangère entre balisesxml:lang
. Similaire àindicationDeLangue
mais avec la détermination automatique du nom et de la direction de la langue. Elle est donc un peu moins rapide.tableauLangues(frame)
: Génère un tableau triable de la liste des langues disponibles dans Module:langue/Data.
Modules externes et autres éléments dont ce module a besoin pour fonctionner :
Module:Langue/Data
: Base de données avec les codes et les noms des langues les plus courantes.
Exemples
Pour des exemples, voir la page de test permettant de tester diverses modifications apportées.
Voir aussi
- {{Code langue}}
- {{Code langue 2}}
- {{Direction langue}}
- {{Lien langue}}
- {{Nom langue}}
- {{Article langue}}
- {{Langue}}
- {{Indication de langue}}
- {{Mul}}
- {{Langue avec nom}}
La documentation de ce module est générée par le modèle {{Documentation module}}.
Elle est incluse depuis sa sous-page de documentation. Veuillez placer les catégories sur cette page-là.
Les éditeurs peuvent travailler dans le bac à sable (modifier).
Voir les statistiques d'appel depuis le wikicode sur l'outil wstat et les appels depuis d'autres modules.
-- luacheck: globals mw, no max line length
local Langue = { }
local dataLangue = mw.loadData( 'Module:Langue/Data' )
-- attention, plusieurs modules cherchent « class="error" » pour détecter si ce module a retourné une erreur
-- pour trouver ces codes, on peut rechercher dans le namespace Module : insource:Langue insource:/(find|match)\([^)]+error/
local langErrorMess = '<span class="error">langue non reconnue : %s</span>'
-- premierParametre renvoie le premier paramètre de Frame, que celui-ci ait été passé au module par invoke, directement au modèle,
-- ou à l'intérieur d'un module sous forme de string dans un tableau ou directement de string.
-- Si aucun de ces arguments ne contient de chaine, la fonction renvoie nil.
-- Si le deuxième paramètre est true, la chaine est renvoyée trimée et en minuscules.
local function premierParametre( frame, lowerCase )
local arg
if type( frame ) == 'table' then
arg = ( frame.getParent and ( frame.args[1] or frame:getParent().args[1] ) ) or frame[1]
elseif type( frame ) == 'string' then
arg = frame
end
if type( arg ) ~= 'string' then
arg = nil
end
if arg and lowerCase then
arg = mw.ustring.lower( mw.text.trim( arg ) )
end
return arg
end
-- determinationCode retourne une table contenant le code de langue principal et la liste des subcodes
-- si le code de langue principal n'est pas reconnu, retourne nil.
function Langue.determinationCode( langue )
if type( langue ) == 'string' and langue ~= '' then
local tabCode = mw.text.split( langue, '-' )
local tabLangue = dataLangue[ mw.ustring.lower( tabCode[1] ) ]
if tabLangue and tabLangue.code then
tabCode[1] = tabLangue.code
if tabLangue.invalide then
tabCode.invalide=true
end
return tabCode
end
end
end
-- Voir Modèle:Code langue
-- Paramètre :
-- 1 : nom de langue.
function Langue.codeLangue( frame )
local arg = premierParametre( frame, true )
local tabCode = Langue.determinationCode( arg )
return ( tabCode and table.concat( tabCode, '-' ) ) or arg or ''
end
-- Voir Modèle:Code langue 2
-- Paramètre :
-- 1 : nom de langue.
function Langue.codeLangue2( frame )
local arg = premierParametre( frame, true )
local tabCode = Langue.determinationCode( arg )
return ( tabCode and table.concat( tabCode, '-' ) ) or ''
end
-- Voir Modèle:Direction langue
-- Paramètre :
-- 1 : nom de langue ou code IETF.
function Langue.directionLangue( frame )
local arg = premierParametre( frame, true )
if type( arg ) ~= 'string' or arg == '' then
return 'ltr'
end
-- séparation du code de langue en code principal et les différents subcodes.
local tabCode = Langue.determinationCode( arg )
if tabCode then
-- on essaye de savoir si la direction est de droite à gauche
local codeScript = tabCode[2]
if codeScript and string.len( codeScript ) == 4 and dataLangue[ 'rtl script' ] then
-- il y a un subcode d'écriture, c'est lui qui est pris en compte
codeScript = string.upper( string.sub( codeScript, 1, 1 ) ) .. string.sub( codeScript, 2 )
if dataLangue[ 'rtl script' ][ codeScript ] then
return 'rtl'
end
else
-- il n'y a pas de subcode d'écriture, on prend en compte le code de langue principal.
local tabLangue = dataLangue[ tabCode[1] ]
if tabLangue and tabLangue.rtl then
return 'rtl'
end
end
end
-- la langue n'est pas écrite de droite à gauche, donc ltr.
return 'ltr'
end
local function getDataLangue( frame )
-- Obtenir le code de la langue
local codeLangue = premierParametre( frame, true )
-- Si le paramètre est incorrect, retourner un message d'erreur
if type( codeLangue ) ~= 'string' or codeLangue == '' then
return nil, '<span class="error">langue non précisée</span>'
end
-- Obtenir le tableau contenant les informations sur la langue
local tabLangue = dataLangue[ codeLangue ]
-- Si le code étendu n'est pas trouvé, chercher à nouveau avec le code racine
if not tabLangue then
tabLangue = dataLangue[ mw.ustring.match( codeLangue, '^(%a-)%-' ) ]
end
-- Si on n'a toujours rien trouvé, retourner un message d'erreur
if not tabLangue then
return nil, langErrorMess:format( codeLangue )
end
return tabLangue
end
-- Fonction fournissant un wikilien vers l'article
-- traitant d'une langue à partir de son code.
-- Voir Modèle:Lien langue
-- Paramètre :
-- 1 : code IETF de langue.
function Langue.lienLangue( frame )
local tabLangue, erreur = getDataLangue( frame )
if not tabLangue then
return erreur
end
-- Créer un lien pour la langue depuis le tableau
if type( tabLangue.page ) == 'string' then
if tabLangue.page ~= '' then
return '[[' .. tabLangue.page .. '|' .. tabLangue.nom .. ']]'
else
return tabLangue.nom
end
else
return '[[' .. tabLangue.nom .. ']]'
end
end
-- Fonction permettant de récupérer le nom d'une langue à partir de son code.
-- Voir Modèle:Nom langue
-- Paramètre :
-- 1 : code IETF de langue.
-- Retourne :
-- Le nom de la langue, un message d'erreur sinon.
function Langue.nomLangue( frame )
local tabLangue, erreur = getDataLangue( frame )
if not tabLangue then
return erreur
end
-- Extraire le nom de la langue depuis le tableau
return tabLangue.nom
end
-- Fonction permettant de récupérer le nom de l'article
-- portant sur une langue à partir de son code.
-- Voir Modèle:Article langue
-- Paramètre :
-- 1 : code IETF de langue.
-- Retourne :
-- Le nom de l'article portant sur la langue
-- si le code est trouvé, un message d'erreur sinon.
function Langue.articleLangue( frame )
local tabLangue, erreur = getDataLangue( frame )
if not tabLangue then
return erreur
end
-- Extraire le titre de l'article depuis le tableau
if type( tabLangue.page ) == 'string' and tabLangue.page ~= '' then
return tabLangue.page
else
return tabLangue.nom
end
end
-- Voir Modèle:Langue
-- Paramètres :
-- 1 : code IETF de langue ;
-- texte ou 2 : texte dans cette langue ;
-- trans : translittération du texte ;
-- dir : direction de la langue (obsolète : peut être en paramètre 1, avec code en 2 et texte en 3).
function Langue.langue( frame )
local args = ( frame.getParent and frame:getParent().args ) or frame -- préparation pour appel par modèle ou direct.
local code = mw.ustring.lower( mw.text.trim( args[1] or '' ) )
local texte = args.texte or ''
if texte == '' then
texte = args[2] or ''
end
local dir = args.dir
local namespaceCategorisation = { [0] = true, [4] = true, [10] = true, [12] = true, [14] = true, [100] = true }
local categorisation = namespaceCategorisation[ mw.title.getCurrentTitle().namespace ] and not args.nocat
-- Décalage des paramètres si code contient la direction du texte (obsolète mais toujours possible).
if code == 'ltr' or code == 'rtl' then
dir = code
code = mw.ustring.lower( mw.text.trim( args[2] ) or '' )
texte = args[3] or ''
end
local codeArg = code
-- sortie immédiate s'il n'y a pas de texte
if texte == '' then
if categorisation then
return '<span class="error">erreur du modèle [[modèle:Langue|{{langue}}]] : texte absent</span>[[Catégorie:Page utilisant un modèle avec une syntaxe erronée|Langue]]'
else
return ''
end
end
-- récursion si texte contient des blocs
if texte:match('\n *\n') or texte:match('\n[*#:]') then
-- les parenthèses permettent d'éliminer la seconde valeur retournée par gsub (nombre de remplacements)
return ( texte:gsub(
'(\n?[*#:]?%s*)([^\n]+)',
function ( init, ligne )
return init .. Langue.langue{ code, ligne }
end
) )
end
-- Si la langue est reconnue, la valeur de la table est prise en compte (permet de corriger les noms de langue en toutes lettres).
local tabCode = Langue.determinationCode( code )
local tabLangue
if tabCode then
code = table.concat( tabCode, '-' )
tabLangue = dataLangue[ tabCode[1] ]
local codeScript = tabCode[2]
-- Si codeScript est bien un style d'écriture (len = 4) on applique sa direction
if codeScript and string.len( codeScript ) == 4 and dataLangue[ 'rtl script' ] then
-- formatage type Latn correspondant au fromat dans dataLangue[ 'rtl script' ]
codeScript = string.upper( string.sub( codeScript, 1, 1 ) ) .. string.sub( codeScript, 2 )
tabLangue = { code = tabLangue.code,
rtl = dataLangue[ 'rtl script' ][ codeScript ],
invalide = tabLangue.invalide
}
end
end
-- Préparation du rendu de direction du texte.
dir = dir and dir:lower()
if dir ~= 'ltr' and dir ~= 'rtl' then
dir = ( tabLangue and tabLangue.rtl and 'rtl' )
end
-- Compilation du texte à retourner.
local html = mw.html.create( '' )
if code == '' then
html:wikitext( texte )
else
local span = mw.html.create( 'span' )
:addClass( 'lang-' .. code )
:attr( 'lang', code )
:attr( 'dir', dir )
:wikitext( texte )
if args.class and args.class ~= '' then
span:addClass( args.class )
end
html:node( span )
-- Translittération.
if ( args.trans or '' ) ~= '' then
local trans = args.trans:gsub( "^''%f[^'](.+)%f[']''$", "%1" )
html:wikitext( " (''" )
:tag( 'span' )
:addClass( 'transcription lang-' .. code )
:attr( 'lang', code .. '-Latn' )
:attr( 'dir', 'ltr' )
:wikitext( trans )
:done()
:wikitext( "'')" )
end
end
-- Ajout de la catégorie Page avec code de langue invalide si le code langue non reconnu ou invalide.
if categorisation and ( type( tabLangue ) ~= 'table' or tabCode.invalide ) then
local erreur = string.format( langErrorMess, codeArg )
if codeArg == '' then
erreur = '<span class="error">langue non précisée</span>'
end
html:wikitext( '[[Catégorie:Page avec code de langue invalide|Langue]] ' .. erreur )
end
return tostring( html )
end
-- Alias nom de fonction
Langue.lang = Langue.langue
-- Voir Modèle:Indication de langue
-- Paramètres :
-- 1 : nom de langue ;
-- 2 : code IETF ;
-- texte : texte dans cette langue ;
-- dir : direction de la langue.
function Langue.indicationDeLangue( frame )
local args = ( frame.getParent and frame:getParent().args ) or frame
local nomLangue = mw.text.trim( args[1] or '' )
local code = mw.text.trim( args[2] or '' )
local texte = args.texte
local dir = args.dir
-- Cas où le premier et/ou le deuxième paramètre est vide.
if code == '' and nomLangue == '' then
return texte
elseif nomLangue == '' then
nomLangue = dataLangue[ mw.ustring.lower( code ) ]
nomLangue = (nomLangue and nomLangue.nom or '???')
elseif code == '' then
code = dataLangue[ nomLangue ]
code = ( code and code.code or '' )
if code == '' then
return texte
end
end
-- Gestion du texte.
if texte and texte ~= '' then
texte = '\194\160' .. Langue.lang{ code, dir = dir, texte = texte }
else
texte = ''
end
-- Compilation de l'indicateur de langue et du texte.
local html = mw.html.create()
html:tag( 'abbr' )
:addClass( 'abbr' )
:addClass( 'indicateur-langue' )
:attr( 'title', 'Langue : ' .. nomLangue )
:wikitext( '(' .. code .. ')' )
:done()
:wikitext( texte )
return tostring( html )
end
-- Voir Modèle:Mul
-- Paramètres : codes IETF ou noms de langue, en nombre indéfini (string ou nil uniquement).
function Langue.indicationMultilingue( frame )
local args = (frame.getParent and frame:getParent().args) or frame
local listeNom = { }
local listeCode = { }
-- Valeur par défaut du premier paramètre = 'mul'.
local code = mw.text.trim( args[1] or '' )
if code == '' then
code = 'mul'
end
local maxLang = tonumber(args.maxLang) or nil
if not args[2] and not dataLangue[ mw.ustring.lower( code ) ] then
local split = mw.text.split( code, '[+,;:/ .]+' )
if #split > 1 then
split.maxLang = maxLang
return Langue.indicationMultilingue( split )
end
end
-- Ajout des noms et codes de langue de chaque paramètre dans listeNom et ListeCode.
local i = 1
repeat
code = mw.ustring.lower( code )
local tabLangue = dataLangue[ code ]
if not tabLangue then
code = mw.text.split( code, '-' )[1]
tabLangue = dataLangue[ code ]
end
if type( tabLangue ) == 'table' then
table.insert( listeNom, tabLangue.nom )
table.insert( listeCode, tabLangue.code )
else
table.insert( listeNom, '???' )
local erreur = string.format( langErrorMess, code )
table.insert( listeCode, erreur )
end
i = i + 1
code = mw.text.trim( args[i] or '' )
until code == ''
-- Préparation et renvoi du texte.
local n = #listeCode
if n == 0 then
return ''
end
if maxLang and n > maxLang then
listeCode = {'mul'}
end
local plusieurs = ( n > 1 )
local html = mw.html.create( 'abbr' )
:addClass( 'abbr' )
:addClass( 'indicateur-langue' )
:attr( 'title', 'Langue' .. ( plusieurs and 's' or '' ) .. ' : ' .. mw.text.listToText( listeNom ) )
:wikitext( '(' .. table.concat( listeCode, '\194\160+\194\160' ) .. ')' )
return tostring( html )
end
-- Voir Modèle:Langue avec nom
-- Paramètres :
-- 1 : code IETF de langue ;
-- texte ou 2 : texte dans cette langue ;
-- trans : translittération du texte ;
-- dir : direction de la langue.
function Langue.langueAvecNom( frame )
local args = ( frame.getParent and frame:getParent().args ) or frame
local code = mw.ustring.lower( mw.text.trim( args [1] or '') )
local texte = args.texte or args[2] or ''
local trans = args.trans
local dir = args.dir
-- Détection de la direction du texte.
if code == 'ltr' or code == 'rtl' then
dir = code
code = mw.ustring.lower( mw.text.trim( args[2] ) )
texte = args[3] or ''
end
-- Définition du nom de la langue en français.
local nom = Langue.lienLangue{ code }
if texte ~= '' then
texte = ' ' .. Langue.lang{ code, dir = dir, texte = texte, trans = trans }
end
return nom .. ' :' .. texte
end
---
-- latinOnly détermine si la chaine fournie contient uniquement des caractères latin (étendu, unicode < 880)
function Langue.nonLatin( frame )
local texte = premierParametre( frame )
for codepoint in mw.ustring.gcodepoint( texte ) do
if codepoint > 879 and not ( -- > 036F
codepoint > 7423 and codepoint < 7936 or -- suppléments phonétique, diacritiques et latin (1D00 à 1EFF)
codepoint > 8191 and codepoint < 11392 or -- espace, indices, monaies et symboles divers (2000 à 2C7F)
codepoint > 42783 and codepoint < 43008 -- latin étendu D (A720 à A7FF)
) then
return true
end
end
return false
end
-- erreurModuleData affiche un message d'erreur si le Module:Langue/Data n'a pas été chargé correctement,
-- pour la page de discussion de la base de données et ceux qui veulent surveiller cette page.
function Langue.erreurModuleData()
if type( dataLangue ) ~= 'table' then
local message = [[<strong class="error">Le chargement du module Langue/Data génère une erreur.</strong> <br>
<span class="error">Cette erreur doit être corrigée au plus vite car des milliers de pages ne s'affichent pas correctement.</span>
]]
return message
end
end
-- tableauLangues génère un tableau triable de la liste des langues disponible dans Module:langue/Data.
function Langue.tableauLangues()
local tableau = { }
local entete = [[{| class="wikitable alternance sortable"
|-
!scope=col|Alias
!scope=col|Code IETF
!scope=col|Nom principal
!scope=col|Titre de l'article<br>(si différent du nom)
!scope=col|Lien vers l'article
!scope=col|RTL
!scope=col|Invalide]]
local ligneTab, ligneSrt
for k, v in pairs( dataLangue ) do
if v.code then
ligneTab = {
k,
v.code,
v.nom,
v.page or '',
Langue.lienLangue(v.code),
v.rtl and '[[Fichier:Yes check.svg|15px|oui|lien=]]' or '',
v.invalide and '[[Fichier:Yes check.svg|15px|oui|lien=]]' or '',
}
ligneSrt = table.concat( ligneTab, '\n|' )
table.insert( tableau, ligneSrt )
end
end
table.sort( tableau )
table.insert( tableau, 1, entete )
table.insert( tableau, '}' )
return table.concat( tableau, '\n|-\n|' )
end
-- listeCodeAlias génère une liste ; les langues sont de la forme : * code : alias1, alias2
function Langue.listeCodeAlias()
local languesTab, listeCodesAlias = { }, { }
local code, alias, codeAlias
for k, v in pairs( dataLangue ) do
-- on construit un table avec pour indices les codes de langue, et pour valeurs une table avec la liste des alias
code = v.code
if code and not v.invalide then
languesTab[code] = languesTab[code] or { }
if k ~= mw.ustring.lower( code ) then
table.insert( languesTab[code], k )
end
end
end
for k, v in pairs( languesTab ) do
-- transformation en un table séquence, avec pour valeur une chaine correspondant à une ligne de la liste
alias = table.concat( v, ', ' )
if alias == '' then
codeAlias = '* <code>' .. k .. '</code>'
else
codeAlias = '* <code>' .. k .. '</code> : ' .. alias
end
table.insert( listeCodesAlias, codeAlias )
end
table.sort( listeCodesAlias )
return table.concat( listeCodesAlias, '\n' )
end
-- listeAliasCode génère une liste ; les langues sont de la forme : * alias : code
function Langue.listeAliasCode()
local languesTab = { }
local code
for k, v in pairs( dataLangue ) do
-- on construit un table avec pour indices les codes de langue, et pour valeurs une table avec la liste des alias
code = v.code
if code and k ~= code and not v.invalide then
table.insert( languesTab, '* ' .. k .. ' = ' .. code )
end
end
table.sort( languesTab )
return table.concat( languesTab, '\n' )
end
return Langue