Module:Population de France/Outils

Documentation[voir] [modifier] [historique] [purger]

Utilisation

Contient diverses fonctions utilisées dans le module principal et certains sous-modules :

p.dump(t, level) : debug. Affiche dans la console le contenu d'une table (récursivement). Ne pas utiliser en prod.
p.round(val, dp) : arrondi val à dp décimale(s)
p.color2rgb(color) : transforme une couleur color de la forme #RRVVBB à la forme rgb(r, v, b) (utilisé pour l'appel au modèle {{Histogramme population manuel}})
p.err_nodata(fonc, donnees, err, court) : retourne un message d'erreur pour la fonction fonc, vis-à-vis du module de données donnees, avec le type d'erreur err. Si court est vrai (true) la version courte est retournée.
p.test_annee(annee, data) : retourne vrai (true) si l'année annee est à utiliser dans lestableaux et graphiques (selon les règles définies pour les affichages)
p.liste_annees(data) : retourne la liste des années ayant une référence, pour l'entité dont les données sont dans data. Cette liste prend la forme : pour les années [ref1 année1], [ref2 année2], … [refX annéeX] et [refY annéeY]. Utilisé pour les notes associées à certains textes.
p.liste_annees_pred(data, annee) : retourne la liste des années qui précèdent annee et qui ont une référence associée, de 5 en 5, par ordre croissant, pour l'entité dont les données sont dans data. Retourne en seconde valeur le nombre d'éléments retournés.

Projet Scribunto

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 (créer).
Voir les statistiques d'appel depuis le wikicode sur l'outil wstat et les appels depuis d'autres modules.

--[[
  Sous-module de Module:Tableau population d'article de commune de France contenant
  diverses fonctions utilitaires (non classées dans les autres catégories)
--]]

local p = {}

-- il nous faut les constantes
p.constantes = require("Module:Population de France/Constantes")

-- fonction de dump récursif d'une table. Ne sert qu'au debug
function p.dump(t, level)
	level = level or 0
    for i,v in pairs(t) do
    	local txt = string.rep('  ', level) .. tostring(i) .. ": "
        if type(v) == 'table' then
        	mw.log(txt .. "{}")
            p.dump(v, level + 1)
        else
        	mw.log(txt .. tostring(v))
        end
    end
end


-- conserve 'dp' décimales dans 'val'
function p.round(val, dp)
	local mult = 10^(dp or 0)
	return math.floor(val * mult + 0.5) / mult
end


-- transforme une couleur de type RRGGBB en valeurs entre 0 et 1 (r, g, b)
function p.color2rgb(color)
	-- on vire le '#' si présent
	if (mw.ustring.sub(color, 1, 1) == "#") then
		color = mw.ustring.sub(color, 2)
	end
	local r = mw.ustring.sub(color, 1, 2)
	local g = mw.ustring.sub(color, 3, 4)
	local b = mw.ustring.sub(color, 5, 6)
	local vr = tonumber(r, 16)
	local vg = tonumber(g, 16)
	local vb = tonumber(b, 16)
	if ((not vr) or (not vg) or (not vb)) then
		return nil
	end
	return p.round(vr/255, 2) .. "," .. p.round(vg/255, 2) .. "," .. p.round(vb/255, 2)
end


-- retourne un message d'erreur "pas de données" ('donnees' est le nom du modèle/module cherché)
function p.err_nodata(fonc, donnees, err, court)
	local namescape = mw.title.getCurrentTitle().namespace
	-- pas de données (ni module ni modèle) : erreur
	local cat = p.constantes.cat_usage
	if (namespace == 0) then
		if (p.constantes.cats_erreur[err] ~= nil) then
			cat = cat .. p.constantes.cats_erreur[err]
		else
			cat = cat .. p.constantes.cats_erreur[1] -- par défaut
		end
	end
	if (court) then
		return mw.ustring.format(p.constantes.err_data_c, p.constantes.code_erreur[err]) .. cat
	else
		return mw.ustring.format(p.constantes.err_data, fonc, p.constantes.code_erreur[err], donnees) .. cat
	end
end


-- retourne la forme élisée ou pas du mot selon la présence d'une voyelle ou pas
function p.apostrophe(mot, pre)
	if (mw.ustring.find(mot, '^[aeiouyAEIOUYéèàÉÈÀÊÂêâûîÛÎëïäüÄËÏÜ]')) then
		if (pre == "de le") then
			return "de l'"
		elseif (pre == "de") then
			return "d'"
		else
			return "l'"
		end
	else
		if (pre == "de le") then
			return "de"
		else
			return pre
		end
	end
end


-- fonction qui retourne true si l'année indiquée doit être sélectionnée par rapport
--  aux règles d'affichage définies
function p.test_annee(annee, data)
	local sup1k = false
	local dep
	
	-- si trop peu de données (commune nouvelle) on retourne tout
	if ((data["dernier"] ~= nil) and (data[data["dernier"]-5] == nil)) then
		return true
	end
	
	if (data["recens-prem"] == "annuel") then
		sup1k = true
		dep = 2006
	else
		dep = data["recens-prem"]
	end
	if (annee <= dep) then
		return true  -- commune de + de 10k → tous les ans avant 2006 inclus
	end              -- commune de - de 10k → tous les ans avant recens-prem inclus
	-- on accepte toujours la dernière
	if (annee == data["dernier"]) then
		return true
	end
	-- ok pour les modulo 5 à partir du premier
	if ((annee - dep) % 5 == 0) then
		return true
	else
		return false
	end
end

-- retourne la liste des années ayant une référence, sous forme d'une liste
function p.liste_annees(data)
	local txt = ""

	if (data["minref"] ~= nil) then
		if (data["minref"] ~= data["maxref"]) then
			txt = txt .. "pour les années "
		else
			txt = txt .. "pour l'année "
		end
		local i
		for i = data["minref"],data["maxref"] do
			if ((data[i] ~= nil) and (data[i]["ref"] ~= nil)) then
				if (i > data["minref"]) then
					if (i == data["maxref"]) then
						txt = txt .. " et "
					else
						txt = txt .. ", "
					end
				end
				if (data[i]["ref"] ~= nil) then
					txt = txt .. "[" .. data[i]["ref"] .. " " .. i .. "]"
				else
					txt = txt .. i
				end
			end
		end
	end
	return txt
end

-- retourne une liste d'années ayant des références, de 5 en 5 à partir
-- de la date indiquée
function p.liste_annees_pred(data, annee)
	local resu = {}
	local nb = 0
	if (data["minref"] == nil) then
		return resu, 0
	end
	for i = data["minref"], annee-1 do
		if ((data[i] ~= nil) and (data[i]["ref"] ~= nil)) then
			table.insert(resu, 1, i)
			nb = nb + 1
		end
	end
	return resu, nb
end

-- fin du module
return p