Module:Langue

local Langue = { }

-- Chargement du de la base de donnée des langues avec gestion d'erreur. local dataLangue local success, resultat = pcall (mw.loadData, 'Module:Langue/Data' ) if success then

   dataLangue = resultat

else

   -- Base de donnée à minima en cas de bug sur le Module:Langue/Data
   dataLangue = { en = { code = 'en', nom = anglais }, 
       fr = { code = 'fr', nom = 'français' },
       de = { code = 'de', nom = 'allemand' }, 
       es = { code = 'es', nom = 'espagnol' },
       it = { code = 'it', nom = 'italien'  }, 
       la = { code = 'la', nom = 'latin'    },
       ['rtl script'] = { Arab = true } 
   }
   dataLangue.anglais = dataLangue.en
   dataLangue['français'] = dataLangue.fr
   dataLangue.allemand = dataLangue.de
   dataLangue.espagnol = dataLangue.es
   dataLangue.italien = dataLangue.it

end

-- premierParametre renvoie le premier paramètre de Frame, que celui-ci ait été 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 argument 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 minuscule. 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 subcode -- 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 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érent subcode.
   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'écritrure, 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 sub-code 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

-- Voir Modèle:Nom langue -- Paramètre : -- 1  : code IETF de langue. function Langue.nomLangue( frame )

   local arg = premierParametre( frame, true )
   if type( arg ) ~= 'string' or arg ==  then 
       return 'langue non précisée'
   end
   local tabLangue = dataLangue[ arg ]
   if tabLangue == nil then
       tabLangue = dataLangue[ mw.ustring.match( arg, '^(%a-)%-' ) ]
   end
   if tabLangue then
       local nom
       if type( tabLangue.page ) == 'string' then
           nom = tabLangue.page .. '|' .. tabLangue.nom
       else
           nom = tabLangue.nom
       end
       return '' .. nom .. ''
   else
       return 'langue non reconnue : ' .. arg .. ' '
   end

end

-- Voir Modèle:Lang -- Paramètres : -- 1 : code IETF de langue, -- texte ou 2 : texte dans cette langue, -- trans : translité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.lang( frame )

   local args = ( frame.getParent and frame:getParent().args ) or frame or { }         -- 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 trans = args.trans
   
   -- Décalage des paramètres si code contient la direction du texte (obsolete 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
   
   -- Si la langue est reconnue, la valeur de la table est prise en compte (permet de corrigé les noms de langue en toute lettre). 
   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épatation du rendu de direction du texte.
   dir = mw.ustring.lower(dir or )
   if dir == 'ltr' or dir == 'rtl' then
       dir = ' dir=' .. dir
   else
       dir = (tabLangue and tabLangue.rtl and ' dir=rtl') or 
   end

   -- Transliteration.
   if trans and trans ~=  then
       trans = ' (' .. trans .. ')'
   else
       trans = 
   end

   -- Compilation du texte à retourner.
   local wikiText = 
   if code ==  then
       wikiText = texte
   else
       wikiText = '' .. texte .. '' .. trans
   end

   -- Ajout de la catégorie Page avec code de langue invalide si le code langue non reconnu ou invalide.
   if success and ( type( tabLangue ) ~= 'table' or tabLangue.invalide ) then
       local namespaceCategorisation = { [0] = true, [4] = true, [10] = true, [14] = true, [100] = true }
       if namespaceCategorisation[ mw.title.getCurrentTitle().namespace ] then
       	if codeArg ==  then
       		codeArg = ' ' 	-- sinon la catégorie n'est pas wikifiée

end

           wikiText = wikiText .. 
       end
   end

   return wikiText

end

-- Voir Modèle:Langue -- Paramètres : -- 1 : nom de langue ou code IETF, -- texte ou 2 : texte dans cette langue, -- trans : translitération du texte, -- dir : direction de la langue. function Langue.langue( frame )

   return Langue.lang( frame )

end

-- 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 or { }
   local nomLangue = args[1] or 
   local code = args.langue or mw.text.trim( args[2] or  )
   local texte = args.texte
   local dir = args.dir
   local wikiText = 
   -- Cas ou le premier et/ou le deuxième paramètre est vide.
   if code .. 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 = ' ' .. Langue.lang{ code, dir = dir, texte = texte }
   else
       texte = 
   end
   -- Compilation de l'indicateur de langue et du texte.
   wikiText = '('
       .. code .. ')'
       .. texte
   return wikiText

end

-- Voir Modèle:Multiling -- 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 = { }
   local tabLangue
   -- Valeur par défaut du premier paramètre = 'mul'.
   local code = mw.text.trim( args[1] or  )
   if code ==  then
       code = 'mul'
   end
   
   -- Ajout des noms et codes de langue de chaque paramètre dans listeNom et ListeCode.
   local i = 1
   repeat
   	code = mw.text.split( code, '-' )[1]
       tabLangue = dataLangue[ mw.ustring.lower( code ) ]
       if type( tabLangue ) == 'table' then
           table.insert( listeNom, tabLangue.nom )
           table.insert( listeCode, tabLangue.code )
       else
           table.insert( listeNom, '???' )
           local erreur = ' langue non reconnue : ' 
               .. code .. ' '
           table.insert( listeCode, erreur )
       end
       i = i+1
       code = mw.text.trim( args[i] or  )
   until code == 
   
   -- Préparation et renvoie du texte.
   local n = #listeCode
   local pluriel = 
   if n == 0 then
       return 
   elseif n > 1 then
       pluriel = 's'
   end
   
   local wikiText = '('
       .. table.concat( listeCode, '+' ) .. ')'
       
   return wikiText

end

-- Voir Modèle:Langue avec nom -- Paramètres : -- 1 : code IETF de langue, -- texte ou 2 : texte dans cette langue, -- trans : translitération du texte, -- dir : direction de la langue. function Langue.langueAvecNom( frame )

   local args = ( frame.getParent and frame:getParent().args ) or frame or { }
   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
   local wikiText = 

   -- 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.nomLangue{ code }

   if texte ~=  then
       texte = ' ' .. Langue.lang{ code, dir = dir, texte = texte, trans = trans }
   end

   wikiText = nom .. ' :' .. texte

   return wikiText

end

-- erreurModuleData affiche d'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ée et ceux qui veulent surveiller cette page. function Langue.erreurModuleData()

   if success == false then 
       local message = [[
%s

]]

       return string.format( message, resultat )
   end

end

-- tableauLangues génère un tableau triable de la liste des langues disponible dans Module:langue/Data. function Langue.tableauLangues()

   if type( dataLangue ) ~= 'table' then
       return
   end

   local tableau = { } 
   local entete = [[{| class="wikitable alternance sortable"

|- !scope=col|Alias !scope=col|code IETF !scope=col|Nom principal !scope=col|Page (si différente du nom) !scope=col|RTL !scope=col|invalide]]

   local ligneTab, ligneSrt
   for i, v in pairs( dataLangue ) do
       if v.code then
           ligneTab = {
               i,
               v.code,
               v.nom,
               v.page or ,
               v.rtl and '' or ,
               v.invalide and '' 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 la forme : * code : alias1, alias2 function Langue.listeCodeAlias ()

   if type( dataLangue ) ~= 'table' then
       return
   end
   local languesTab, listeCodesAlias = { }, { }
   local code, alias, codeAlias
   for i, v in pairs( dataLangue ) do
       -- on construit un table avec pour indice les code de langue, et pour valeur une table avec la  liste des alias
       code = v.code
       if code then  
           languesTab[code] = languesTab[code] or { }
           if i ~= mw.ustring.lower( code ) then
               table.insert( languesTab[code], i )
           end
       end
   end
   for i, 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 = '\n* ' .. i .. ''
       else
           codeAlias = '\n* ' .. i .. ' : ' .. alias
       end
       table.insert( listeCodesAlias, codeAlias )
   end
   table.sort( listeCodesAlias )
  
   return table.concat( listeCodesAlias )

end

-- listeCodeAlias génére une liste les langues sont la forme : * code : alias1, alias2 function Langue.listeAliasCode ()

   if type( dataLangue ) ~= 'table' then
       return
   end
   local languesTab = {  }
   local code
   for i, v in pairs( dataLangue ) do
       -- on construit un table avec pour indice les code de langue, et pour valeur une table avec la  liste des alias
       code = v.code
       if code and i ~= code then  
           table.insert( languesTab, i .. ' = ' .. code )
       end
   end
   table.sort( languesTab )
  
   return table.concat( languesTab, '\n*' )

end

return Langue