Module:Population de France/Test

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

Utilisation

Voir Discussion module:Population de France/Données pour une description du format des données.

Fonctions exportables :

tableau(frame) – génère un tableau de population pour la commune (article courant ou paramètre « nom ») à partir des données de population stockés dans "Module:Données/NOM-COMMUNE/évolution population" (ou dans "Modèle:Données/NOM-COMMUNE/évolution population" si le premier n'existe pas). Les seuls paramètres sont nom (le nom de la commune, sinon SUBPAGENAME) et titre (utilisé pour surcharger le titre par défaut
introduction(frame) – génère une introduction pour la commune (article courant ou paramètre « nom », seul paramètre)
graphique(frame) – génère un graphique de population pour la commune (article courant ou paramètre « nom », seul paramètre avec « titre », plus « seuil », voir plus bas).
densite(frame) – retourne la densité de population. Les paramètres sont « nom » (le nom de la commune, page courante si absent) ; « précision » (nombre) indique le nombre de chiffres après la virgule. Si « format » est présent et non vide le nombre retourné est mis en forme via formatNum
variation_texte(frame) – retourne une phrase décrivant la variation de population sous la forme « en augmentation/diminution de XXX % par rapport à AAAA ». Les paramètres sont « nom » (le nom de la commune, page courante si absent) et « type ». Si ce dernier vaut « picto » la fonction retourne juste un symbole (augmentation/diminuation) avec la phrase indiquée en infobulle.
derniere_population(frame) – retourne l'année ou la population correspondant aux données les plus récentes. Les paramètres sont « nom » (le nom de la commune, page courante si absent) et « type ». Si « type » vaut « date » l'année est retournée. S'il vaut vide (ou absent) la population est retournée, sans formatage, et s'il vaut « nombre » la population est retournée, formatée via fomatNum.

Fonctions utilisables depuis un autre module :

tableau_m(param) – fonction identique à la précédente (la précédente appelle celle-ci) mais appelable directement depuis un autre module. Les seuls paramètres sont nom (le nom de la commune, sinon SUBPAGENAME) et titre (utilisé pour surcharger le titre par défaut)
introduction_m(param) – fonction identique à la précédente (la précédente appelle celle-ci) mais appelable directement depuis un autre module. Le seul paramètre est nom (le nom de la commune, sinon SUBPAGENAME)
graphique_m(param) – fonction identique à la précédente (la précédente appelle celle-ci) mais appelable directement depuis un autre module. Les paramètres sont nom (le nom de la commune, sinon SUBPAGENAME), titre (utilisé pour surcharger le titre par défaut), et seuil qui fixe le nombre minimal de valeurs pour afficher un graphique (en dessous de cette valeur l'appel ne fait rien) (valeur par défaut : 5)
derniere_population_m(param) – fonction identique à la précédente (la précédente appelle celle-ci) mais appelable directement depuis un autre module. Les seuls paramètres sont nom (le nom de la commune, sinon SUBPAGENAME) et type (le type de données demandé)
densite_m(param) – fonction identique à la précédente (la précédente appelle celle-ci) mais appelable directement depuis un autre module. Les paramètres sont nom (le nom de la commune, sinon SUBPAGENAME), précision (le nombre de décimales) et format (si non vide formatage du nombre avec formatNum)
variation_texte_m(param) – fonction identique à la précédente (la précédente appelle celle-ci) mais appelable directement depuis un autre module. Les paramètres sont nom (le nom de la commune, sinon SUBPAGENAME) et type (si vaut "picto" retourne un symbole d'augmentation/diminution avec le texte en infobulle)

Modules et modules externes dont ce module a besoin pour fonctionner :

Module:Démographie – utilisé pour la construction de la table des populations
Module:Chartes − utilisé pour la charte de couleur (fond des années et des graphiques)
Modèle:Histogramme population manuel − utilisé pour générer les graphiques de population (existe-t-il un module ?)

Sous-modules (modules dédiés utilisés pour alléger le code et regrouper par thématique certaines parties) :

Module:Population de France/Constantes − contient les données constantes du module (textes, noms de catégories…)
Module:Population de France/Sources − contient les fonctions utilisées pour générer les sources présentées par les fonctions du module principal
Module:Population de France/Notes − contient les fonctions utilisées pour générer les notes présentées par les fonctions du module principal
Module:Population de France/Données − contient les fonctions de chargement, de traitement et de manipulation des données de population
Module:Population de France/Outils − contient diverses fonctions non rangées sans les autres sous-modules (par ex. génération de messages d'erreur, arrondi…)
Module:Population de France/Introductions − contient les fonctions chargées de générer les textes d'introduction selon le type de division.

Exemples

Cette section est vide, insuffisamment détaillée ou incomplète. Votre aide est la bienvenue ! Comment faire ?

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.

Projet Scribunto

--[[
  VERSION DE TEST

  Module fournissant diverses fonctions autour des données de population
    des communes françaises.
  Ceci est un module en cours d'écriture / test.
  Merci de ne pas modifier / supprimer pour le moment
--]]

local p = {}


--
-- Les modules et sous-modules dont on aura besoin
--

-- le module démographie (penser à virer le /Test lorsque tout sera à plat)
p.demographie = require("Module:Démographie/Test")
-- le module chartes
p.chartes = require("Module:Chartes")

-- on charge les sous-modules
p.constantes = require("Module:Population de France/Constantes/Test")
p.sources = require("Module:Population de France/Sources/Test")
p.notes = require("Module:Population de France/Notes/Test")
p.donnees = require("Module:Population de France/Données/Test")
p.outils = require("Module:Population de France/Outils/Test")


--[[
  fonction récupérant les différentes données et appelant
  le module démographie pour l'affichage effectif
--]]
function p.tableau_m(param)
	-- le nom de la cible (param. nom ou titre page)
	local ttl = mw.title.getCurrentTitle().subpageText
	local donnees = ""
	local wlm = false
	local vnom = param["nom"] or ttl
	
	-- on charge les données
	local data, wlm = p.donnees.charge_donnees(vnom, false)
	if (data == nil) then
		return p.outils.err_nodata("tableau", donnees)
	end
	if (wlm == false) then
		return p.outils.err_baddata("tableau", donnees)
	end
	-- utilisé pour le lien "modifier"
	donnees = "Module:Données/" .. vnom .. "/évolution population/Test"

	-- on prépare les paramètres à fournir au module Démographie
	local dest = {}
	
	-- éléments constants
	dest["largeur_tableau"] = "48em"
	dest["taille_police"] = "95%"
	dest["marge_interlignes"] = "10px"
	dest["hauteur_lignes"] = "110%"
	dest["population_fond"] = "#F9F9F9"
	dest["style_notes"] = "centré"
	
	-- couleur (on passe par Chartes avec un "truc" pour commune nouvelle)
	if (data["division"] == "commune nouvelle") then
		dest["annees_fond"] = p.chartes.charte_m("geographie", "secondaire", "commune", true)
	else
		dest["annees_fond"] = p.chartes.charte_m("geographie", "secondaire", data["division"], true)
	end

	-- le titre du tableau
	if (param["titre"] ~= nil) then
		dest["titre"] = "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;" ..
			param["titre"] .. " &nbsp;<small>[&#8202;[[" .. donnees ..
			"|modifier]]&#8202;]</small>"
	else
		dest["titre"] = "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;" ..
			p.constantes.titre_tableau .. " &nbsp;<small>[&#8202;[[" .. donnees ..
			"|modifier]]&#8202;]</small>"
	end
	
	-- notes
	local tmp = p.notes.notes(data, vnom)
	if ((tmp ~= nil) and (mw.text.trim(tmp) ~= "")) then
		dest["notes"] = tmp
	end
	
	-- sources
	tmp = p.sources.sources(data, vnom)
	if ((tmp ~= nil) and (mw.text.trim(tmp) ~= "")) then
		dest["sources"] = tmp
	end
	
	-- maintenant on parcours les données elles-mêmes
	for annee, pop in pairs(data) do
		-- les années sont les éléments numériques du tableau
		if (type(annee) == "number") then
			vpop = tonumber(mw.text.trim(pop["pop"]))
			if (vpop > 0) then
				dest[annee] = vpop  -- on stocke
			end
		end
	end

	-- on effectue l'appel terminal et on retourne (et on ajoute la catégorie)
	return p.demographie.demographie_m(dest) .. p.constantes.cat_usage
end

-- fonction "wrapper" pour la précédente, pour appel depuis un modèle
function p.tableau(frame)
	local param = {}
	-- deux paramètres : nom et titre
	local tmp = frame.args["nom"] or frame:getParent().args["nom"] or nil
	if (tmp ~= nil) then
		param["nom"] = tmp
	end
	tmp = frame.args["titre"] or frame:getParent().args["titre"] or nil
	if (tmp ~= nil) then
		param["titre"] = tmp
	end
	-- on appelle la vraie fonction
	return p.tableau_m(param)
end

--[[
  Fonction créant une introduction de population de commune
--]]
function p.introduction_m(param)
	local resu
	local nom = param["nom"] or mw.title.getCurrentTitle().subpageText
	local donnees = "Module:Données/" .. nom .. "/évolution population/Test"

	-- on charge les données associées à la commune
	local data, wlm = p.donnees.charge_donnees(nom)
	if (data == nil) then
		return p.outils.err_nodata("introduction", donnees)
	end
	if (wlm == false) then
		return p.outils.err_baddata("introduction", donnees)
	end
	if ((data["division"] == "commune") or (data["division"] == "commune en DOM")) then
		-- première partie
		resu = mw.ustring.format(p.constantes.intro_debut, data["premier"])
		-- selon la population
		if (data[data["dernier"]]["pop"] < 10000) then
			resu = resu .. p.constantes.intro_petite
			-- partie de "petit" qui nécessite calcul et traitements
			resu = resu .. mw.getCurrentFrame():extensionTag{ name = "ref",
				   content = "[https://www.insee.fr/fr/information/2383265 L'organisation du recensement], sur le site de l'Insee." }
				   .. ". "
			if ((data["recens-prem"] ~= nil) and (data["source_collecte"] ~= nil)) then
				resu = resu .. p.constantes.intro_petite2 .. data["recens-prem"]
				resu = resu .. mw.getCurrentFrame():extensionTag{ name = "ref",
					    content = "[" .. data["source_collecte"] .. " Calendrier départemental des recensements], sur [http://insee.fr/ le site de l'Insee]" }
			end
		else
			resu = resu .. p.constantes.intro_grande
			resu = resu .. mw.getCurrentFrame():extensionTag{ name = "ref",
					    content = "[https://www.insee.fr/fr/information/2383265 L'organisation du recensement], sur le site de l'Insee" }
		end
		-- la note
		resu = resu .. "<sup class=\"reference cite_virgule\">,</sup>" .. mw.getCurrentFrame():extensionTag{ name = "ref", args = { group = 'Note' },
					content = p.constantes.intro_note } .. ".\n\n"
	else
		resu = ""
	end
	
	-- dernière partie : chiffres, comparatifs…
	resu = resu .. "En " .. data["dernier"] .. ", "
	if (data["division"] == "canton") then
		resu = resu .. "le canton comptait "
	elseif (data["division"] == "arrondissement") then
		resu = resu .. "l'arrondissement comptait "
	elseif (data["division"] == "département") then
		resu = resu .. "le département comptait "
	elseif (data["division"] == "région") then
		resu = resu .. "la région comptait "
	else -- commune
		resu = resu .. "la commune comptait "
	end
	resu = resu .. mw.language.getContentLanguage():formatNum(data[data["dernier"]]["pop"]) .. " habitants"
	-- ajout d'une note à ce propos
	resu = resu .. mw.getCurrentFrame():extensionTag{ name = "ref", content =
				"Population municipale légale en vigueur au 1<sup>er</sup>&nbsp;janvier&nbsp;" .. data["dernier"]+3 ..
				", millésimée " .. data["dernier"] .. ", définie dans les limites territoriales en vigueur au 1<sup>er</sup>&nbsp;janvier&nbsp;" .. data["dernier"]+2 ..
				", date de référence statistique : {{Date-|1er|janvier|2014}}.", args = { group = "Note" } }
	-- calcul de l'augmentation / diminution
	local delta = p.donnees.variation_texte(data)
	if (delta ~= nil) then
		resu = resu .. ", " .. delta
	end

	-- département associé (sauf pour les départements)
	local nomd = data["nom-dep"] -- on en a besoin plus tard
	data, wlm = p.donnees.charge_donnees(nomd)
	local deltad = nil
	local nomdwp = nil
	if ((data ~= nil) and (wlm == true)) then
		nomdwp = data["nom-wp"]
		deltad = p.donnees.variation(data, false)
	end
	-- France
	data, wlm = p.donnees.charge_donnees("France")
	local deltaf = nil
	if ((data ~= nil) and (wlm == true)) then
		deltaf = p.donnees.variation(data, false)
	end
	-- dernière partie
	if ((deltad == nil) and (deltaf == nil)) then
		resu = resu .. "."
	else
		resu = resu .. " ("
		if (deltad ~= nil) then
			if (deltad > 0) then
				resu = resu .. nomdwp .. " : +" .. mw.language.getContentLanguage():formatNum(deltad) .. " %"
			else
				resu = resu .. nomdwp .. " : " .. mw.language.getContentLanguage():formatNum(deltad) .. " %"
			end
		end
		if (deltaf ~= nil) then
			if (deltad ~= nil) then
				resu = resu .. " ; "
			end
			if (deltaf > 0) then
				resu = resu .. "[[Démographie de la France|France]] hors [[Mayotte]] : +" .. mw.language.getContentLanguage():formatNum(deltaf) .. " %"
			else
				resu = resu .. "[[Démographie de la France|France]] hors [[Mayotte]] : " .. mw.language.getContentLanguage():formatNum(deltaf) .. " %"
			end
		end
		resu = resu .. ")."
	end

	return resu
end

-- fonction "wrapper" pour la fonction précédente, pour appel depuis un modèle
function p.introduction(frame)
	local pframe = frame:getParent()
	local param = {}
	-- récupération de l'unique paramètre (nom)
	param["nom"] = frame.args["nom"] or pframe.args["nom"] or nil
	return p.introduction_m(param)	
end


-- fonction de tri utilisée par la fonction suivante
-- tri sur la valeur du 1er élément des éléments
function p.sort_par_annee(el1, el2)
	if (el1[1] < el2[1]) then
		return true
	end
	return false
end

--[[
  Fonction créant un graphique de population de commune
--]]
function p.graphique_m(param)
	local resu
	local nom = param["nom"] or mw.title.getCurrentTitle().subpageText
	local donnees = "Module:Données/" .. nom .. "/évolution population/Test"

	-- on charge les données associées à la commune
	local data, wlm = p.donnees.charge_donnees(nom)
	if (data == nil) then
		return p.outils.err_nodata("graphique", donnees)
	end
	if (wlm == false) then
		return p.outils.err_nodata("graphique", donnees)
	end

	-- "Histogramme population manuel" étant un modèle, on fabrique la structure d'appel
	-- ici il faudrait modifier "couleur-barres" qui devrait dépendre de la charte…
	prm = { ["largeur"] = 710, ["hauteur"] = 340, ["couleur-fond"] = "rgb(1,1,1)" }
	local cb
	if (data["division"] == "commune nouvelle") then
		cb = p.chartes.charte_m("geographie", "primaire", "commune", true)
	else
		cb = p.chartes.charte_m("geographie", "primaire", data["division"], true)
	end
	cb = p.outils.color2rgb(cb)
	if (cb == nil) then
		prm["couleur-barres"] = "rgb(0.7,0.9,0.7)" -- couleur "par défaut"
	else
		prm["couleur-barres"] = "rgb(" .. cb .. ")"
	end

	prm["nom"] = param["nom"]
	prm["titre"] = param["titre"] or p.constantes.titre_graphique
	prm["max"] = data["pmax"]
	-- parcours des données
	local tmp = {}
	for annee, pop in pairs(data) do
		if ((type(annee) == "number") and (pop["recens"])) then
			table.insert(tmp, { annee, pop["pop"] })
		end
	end
	-- tri des éléments
	table.sort(tmp, p.sort_par_annee)
	-- on insert année / valeur dans l'ordre (histogramme pop… a besoin des données dans l'ordre)
	local nb = 1
	local nbp = 0
	for k, v in pairs(tmp) do
		prm[nb] = v[1]
		prm[nb+1] = v[2]
		nb = nb + 2
		nbp = nbp + 1  -- nombre de barres (réel)
	end
	prm["nombre"] = nbp
	prm["sources"] = p.sources.sources_graphique(data, nom)
p.outils.dump(prm)
	-- on "appelle" le modèle
	return mw.getCurrentFrame():expandTemplate{ title = 'Histogramme population manuel', args = prm }
end

-- fonction "wrapper" pour la fonction précédente, pour appel depuis un modèle
function p.graphique(frame)
	local pframe = frame:getParent()
	local param = {}
	-- récupération des paramètre (nom et titre)
	param["nom"] = frame.args["nom"] or pframe.args["nom"] or nil
	param["titre"] = frame.args["titre"] or pframe.args["titre"] or nil
	return p.graphique_m(param)	
end


--[[
  Retourne la dernière population (ou la dernière date) pour la commune "nom" (ou courante)
  Si prm[1] est vide retourne la population, sans formatage
  Si prm[1] vaut "date", retourne la date
  Si prm[1] vaut "nombre", idem premier cas mais avec formatage du nombre
--]]
function p.derniere_population_m(prm)
	local nom = prm["nom"] or mw.title.getCurrentTitle().subpageText
	local donnees = "Module:Données/" .. nom .. "/évolution population/Test"

	-- on charge les données associées à la commune
	local data, wlm = p.donnees.charge_donnees(nom)
	if (data == nil) then
		return p.outils.err_nodata("dernière_population", donnees, true)
	end
	if (wlm == false) then
		return p.outils.err_baddata("dernière_population", donnees, true)
	end
	
	local tmp = p.donnees.valeur_recente(data)
	if (tmp == nil) then
		return p.outils.err_baddata("dernière_population", donnees, true)
	end
	
	if (prm["type"] == "date") then
		return tmp[1]
	end
	if ((prm["type"] == nil) or (mw.text.trim(prm["type"]) == "")) then
		return tmp[2]
	end
	return mw.language.getContentLanguage():formatNum(tmp[2])
end

-- fonction "wrapper" pour la fonction précédente, pour appel depuis un modèle
function p.derniere_population(frame)
	local pframe = frame:getParent()
	local param = {}
	-- récupération des paramètre (nom et titre)
	param["nom"] = frame.args[2] or pframe.args[2] or nil
	param["type"] = frame.args[1] or pframe.args[1] or nil
	return p.derniere_population_m(param)	
end


--[[
  Retourne une phrase décrivant la variation de population de la commune
    courante (ou "nom") ou un pictograme si "type" = "picto"
--]]
function p.variation_texte_m(prm)
	local nom = prm["nom"] or mw.title.getCurrentTitle().subpageText
	local donnees = "Module:Données/" .. nom .. "/évolution population/Test"

	-- on charge les données associées à la commune
	local data, wlm = p.donnees.charge_donnees(nom)
	if (data == nil) then
		return p.outils.err_nodata("variation_texte", donnees, true)
	end
	if (wlm == false) then
		return p.outils.err_baddata("variation_texte", donnees, true)
	end
	
	local txt, sens = p.donnees.variation_texte(data)
	if (txt == nil) then
		return p.outils.err_baddata("variation_texte", donnees, true)
	end
	if (prm["type"] ~= "picto") then
		return txt
	end
	-- on crée le pictogramme
	if (sens) then
		return "[[Fichier:Increase2.svg|11px|" .. txt .. "]]"
	else
		return "[[Fichier:Decrease2.svg|11px|" .. txt .. "]]"
	end
end

-- fonction "wrapper" pour la fonction précédente, pour appel depuis un modèle
function p.variation_texte(frame)
	local pframe = frame:getParent()
	local param = {}
	-- récupération des paramètre (nom et titre)
	param["nom"] = frame.args["nom"] or pframe.args["nom"] or nil
	param["type"] = frame.args["type"] or pframe.args["type"] or nil
	return p.variation_texte_m(param)	
end


--[[
  Retourne la densité de la commune. Si "précision" indiquée utilise celle-ci,
  sinon précision 1 par défaut
--]]
function p.densite_m(prm)
	local nom = prm["nom"] or mw.title.getCurrentTitle().subpageText
	local donnees = "Module:Données/" .. nom .. "/évolution population/Test"

	-- on charge les données associées à la commune
	local data, wlm = p.donnees.charge_donnees(nom)
	if (data == nil) then
		return p.outils.err_nodata("densité", donnees, true)
	end
	if (wlm == false) then
		return p.outils.err_baddata("densité", donnees, true)
	end

	local prc = 1
	if (type(prm["précision"]) == "number") then
		prc = prm["précision"]
	end
	if ((data[data["dernier"]]["pop"] == nil) or (data["superficie"] == nil)) then
		return p.outils.err_baddata("dernière_population", donnees, true)
	end
	
	if (prm["format"] ~= nil) then
		return mw.language.getContentLanguage():formatNum(
			p.outils.round(data[data["dernier"]]["pop"] / data["superficie"], prc))
	else
		return p.outils.round(data[data["dernier"]]["pop"] / data["superficie"], prc)
	end
end

-- fonction "wrapper" pour la fonction précédente, pour appel depuis un modèle
function p.densite(frame)
	local pframe = frame:getParent()
	local param = {}
	-- récupération des paramètre (nom et titre)
	param["nom"] = frame.args["nom"] or pframe.args["nom"] or nil
	param["précision"] = tonumber(frame.args["précision"] or pframe.args["précision"] or nil)
	param["format"] = frame.args["format"] or pframe.args["format"] or nil
	return p.densite_m(param)	
end

return p