Module:langues/analyse

La documentation pour ce module peut être créée à Module:langues/analyse/Documentation

b = require("Module:bases")
l = require("Module:langues")

local wlangues = mw.loadData('Module:langues/data')

p = {}

-- Recherche la langue dans la liste de Wikimedia
function p.get_nom_wikimedia(code)
    if (code) then
        local langue = mw.language.fetchLanguageName(code, 'fr') -- fr = nom en français
        
        -- Langue trouvée ? On renvoie nil si c'est vide, pas ''
        if (langue ~= nil and langue ~= '') then
            return langue
        else
            return nil
        end
    else
        return nil
    end
end

-- AFFICHAGE DES LANGUES
-- Affiche directement le nom de la langue
function p.affiche_nom_wikimedia(frame)
    local code = frame.args[1]
    if (code == nil) then
        return 'Pas de code langue donné'
    end
    
    -- Récupère la langue dans la liste Wikimedia
    local langue = p.get_nom_wikimedia(code)
    
    -- A-t-on un résultat ?
    if (langue ~= nil and langue ~= '') then
        return langue
    else
        return 'Pas de langue Wikimédia'
    end
end

function p.sort_nom_langue(nom_langue)
	-- retourne nil si la langue ne contient pas de caractère spécial
	if mw.ustring.toNFD(nom_langue) == nom_langue and not mw.ustring.find(nom_langue, '[’)(]') then
		return
	end
	-- retourne la clé de tri sinon
	cle_de_tri = mw.ustring.toNFD(nom_langue)
	cle_de_tri = mw.ustring.gsub(cle_de_tri, '[^%a-]', '')
	cle_de_tri = mw.ustring.gsub(cle_de_tri, 'æ',        "ae")
	cle_de_tri = mw.ustring.gsub(cle_de_tri, '[œ]',      "oe")
	cle_de_tri = mw.ustring.gsub(cle_de_tri, "['’)(]",   "")
	cle_de_tri = mw.ustring.gsub(cle_de_tri, '[-\/]',    " ")
	return cle_de_tri
end

function p.sort_langues(tab1, tab2)
	t1 = wlangues[tab1]['tri'] and wlangues[tab1]['tri'] or p.sort_nom_langue(wlangues[tab1]['nom']) or wlangues[tab1]['nom']
	t2 = wlangues[tab2]['tri'] and wlangues[tab2]['tri'] or p.sort_nom_langue(wlangues[tab2]['nom']) or wlangues[tab2]['nom']
    if t1 < t2 then
        return true
    else
        return false
    end
end

-- Affiche les langues
-- (seules les langues locales, je ne sais pas si on peut récupérer un tableau de Wikimédia)
function p.affiche_tableau_langues_locales(frame)
    local titres = {'n', 'Code', 'Nom', 'Lien Wikimédia'}
    
    -- Récupère les clés
    local keyset={}
    local n=0
    
    for k,v in pairs(wlangues) do
      n=n+1
      keyset[n]=k
    end
    
    -- Intro
    local textet_tableau = {"Cette liste est générée automatiquement à partir de [[Module:langues/data]].\r\n\r\nIl y a actuellement " .. n .. " codes langues dans cette liste.\r\nLa liste peut être triée par nom de langue (défaut) ou par code."}
    
    -- Tri par nom de langue
    table.sort(keyset, p.sort_langues)
    
    table.insert(textet_tableau, b.tableau_entete(titres))
    for k, code in ipairs(keyset) do
        local infos = wlangues[code]
        local langue = infos['nom'] or 'NOM MANQUANT'
        local langue_tri = infos['tri'] or p.sort_nom_langue(langue) or langue
        local langue_cat = b.fait_categorie(langue, langue, true)
        local langue_col = 'data-sort-value="' .. langue_tri .. '"|' .. langue_cat
        local lien_WM = infos['wmlien'] or ''
        local ligne = {k, '<span id="' .. code ..'">' .. code .. '</span>', langue_col, lien_WM}
        table.insert(textet_tableau, b.tableau_ligne(ligne))
    end
    
    table.insert(textet_tableau, b.tableau_fin())
    return table.concat(textet_tableau, "\r\n")
end

-- Affiche la liste des langues en format python
function p.affiche_langues_python(frame)
    -- Récupère les clés
    local keyset={}
    local n=0
    
    local debut = "<pre>\r\nlangues = {\r\n"
    local fin = "\r\n}\r\n</pre>\r\n"
    local lignes = {}
    for k,v in pairs(wlangues) do
      --table.insert(lignes, "\t'" .. k .. "': '" ..v .. "'")
      table.insert(lignes, '\t"' .. k .. '": "' .. v['nom'] .. '",')
    end
    
    local liste_python = debut .. table.concat(lignes, "\r\n") .. fin
    return liste_python
end

-- À partir d'une liste de codes donnés en paramètres:
-- 1) vérifie que le code est présent dans la liste des langues locales
-- 2) sinon, écrit une ligne à copier-coller dans la liste (en supposant que le modèle correspondant existe)
function p.compare_liste(frame)
    -- Récupère tous les codes langue
    local codes = frame.args
    -- Récupère la liste de langues locales actuelle
    local langues = mw.loadData('Module:langues/data')
    
    -- Pour chaque code langue, vérifier qu'il existe dans la liste locale
    -- Sinon, le garder à part
    local langues_locales = {}
    local autres_langues = {}
    for i, code in pairs(codes) do
        code = mw.ustring.gsub(code, "%s", '')
        if (type(i)=='number') then
            if (langues[code] ~= nil and langues[code]['nom'] ~= nil) then
                table.insert(langues_locales, code)
            else
                table.insert(autres_langues, code)
            end
        end
    end
    
    -- Affiche statistiques
    local stats = "* Langues locales : " .. #langues_locales .. "\r\n* Langues à ajouter : " .. #autres_langues
    
    if (#autres_langues > 0) then
        -- Liste les langues restantes !
        nouvelles_langues = {}
        for i, code in pairs(autres_langues) do
            local langue = frame:preprocess("{{" .. code .. "}}")
            
            if (langue ~= nil and langue ~= '') then
                nouvelles_langues[code] = langue
            else
                nouvelles_langues[code] = 'ERREUR!!'
            end
        end
    
        -- Affichage !
        textet = {'<pre>'}
        for code, langue in pairs(nouvelles_langues) do
            table.insert(textet, "l['" .. code .. "'] = { nom = '" .. langue .. "' }")
        end
        table.insert(textet, '</pre>')
        
        return stats .. "\r\n\r\n" .. frame:preprocess(table.concat(textet, "\r\n"))
    else
        return stats
    end
end

return p