Module:Protection/Bac à sable

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

Ce module implémente les modèles {{Protection}}, {{Semi-protection}}, {{Semi-protection longue}} et {{Nom protégé}}. Voir la documentation des modèles pour les instructions d'utilisation.

Fonctions exportables

• protection(frame) – Fonction implémentant le modèle {{Protection}} – à appeler avec #invoke.
• semiProtection(frame) – Fonction implémentant le modèle {{Semi-protection}} – à appeler avec #invoke.
• semiProtectionLongue(frame) – Fonction implémentant le modèle {{Semi-protection longue}} – à appeler avec #invoke.
• nomProtégé(frame) – Fonction implémentant le modèle {{Nom protégé}} – à appeler avec #invoke.
• main(args, typeProtection, titrePage) – Fonction qui peut être appelée dans un autre module avec require(). Ceci est une bonne pratique d'appeler directement cette fonction dans un autre module car vous n'avez pas besoin d'avoir l'objet frame de disponible, ce qui améliore les performances et simplifie la gestion des arguments. Le paramètre typeProtection prend la valeur du nom des fonctions définies précédemment. Si aucune valeur n'est renseignée, le type sera initialisé à protection.

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.

local p = {}
 
-- Chargement du module de données.
--local donnees = mw.loadData('Module:Protection/Données')
 
--Redéfinitions utiles
local format = mw.ustring.format
local insert = table.insert

local types = {
	protection = {
		image = 'Crystal Clear action lock1.png',
		mode = 'protégée',
		niveau = 'sysop'
	},
	semiProtection = {
		categorie = 'Catégorie:Page semi-protégée',
		texte = 'Cette page est semi-protégée.',
		image = 'Crystal Clear action half lock.png',
		mode = 'semi-protégée',
		niveau = 'autoconfirmed'
	},
	semiProtectionLongue = {
		image = 'Crystal Clear action half lock.png',
		niveau = 'autoconfirmed'
	},
	['nomProtégé'] = {
		image = 'Crystal Clear action lock5.png',
		mode = 'nom protégé',
		niveau = 'sysop'
	},
}
 
function p.main(typeProtection, args)
	local modeProtection = types[typeProtection]
	local titrePage = mw.title.getCurrentTitle()
	local res = {}
 
	if typeProtection == 'protection' and args.nocat then
		return bandeauProtection(typeProtection, titrePage)
	end
 
	if protectionPage(modeProtection, titrePage) then
		-- Création de l'icône de titre selon le mode de protection.
		insert(res, creerIconeTitre(modeProtection))
		-- Création du bandeau de protection pour le mode 'protection'.
		if typeProtection == 'protection' then
			insert(res, bandeauProtection(typeProtection, titrePage))
		end
		-- Catégorisation selon le mode de protection.
		insert(res, insertionCategorie(modeProtection, titrePage))
	elseif not estSousPage(titrePage) then
		-- Catégorisation lorsque le niveau de protection en écriture ne
		-- correspond pas ou plus. Note : les sous-pages '/Documentation',
		-- '/Bac à sable' ou '/Test' appartenant aux modèles ou aux modules
		-- ne sont pas – et ne doivent pas être – concernées.
		insert(res, '[[Catégorie:Page dont la protection est à vérifier]]')
	end
 
	return table.concat(res)
end
 
function protectionPage(modeProtection, titrePage)
	-- Retourne vrai si la page courante est protégée et correspond
	-- au type de protection.
	local niveauProtection = titrePage.protectionLevels.edit[1]
	return modeProtection.niveau == niveauProtection
end
 
function estSousPage(titrePage)
	-- Teste si la page actuelle est une sous-page /Documentation,
	-- /Bac à sable ou /Test de modèle ou de module. Retourne vrai
	-- si c'est le cas et faux sinon.
	local espaceNom = titrePage.nsText == 'Modèle' or titrePage.nsText == 'Module'
	local sousPage = titrePage.isSubpage and 
		(titrePage.subpageText == 'Documentation'
		or titrePage.subpageText == 'Bac à sable'
		or titrePage.subpageText == 'Test')
 
	return espaceNom and sousPage
end
 
function creerIconeTitre(modeProtection)
	local iconeTitre = require('Module:Icône de titre')._main
	local argsIcone = {
		lien = format(':Catégorie:Page %s', modeProtection.mode),
		image = modeProtection.image,
		texte = format('Cette page est %s.', modeProtection.mode),
		taille = 15
	}

	return iconeTitre(argsIcone)
end

function insertionCategorie(modeProtection, titrePage)
	local espaceNom = titrePage.nsText
	local lienCategorie = '[[Catégorie:%s %s]]'

	if espaceNom ~= 'Modèle' and espaceNom ~= 'Module' then
		espaceNom = 'Page'
	end

	return format(lienCategorie, espaceNom, modeProtection.mode)
end
 
function bandeauProtection(typeProtection, titrePage)
	return 'Lorem ipsum dolor'
end
 
-- Insertion dans la table p des fonctions appelées par les
-- modèles à l'aide d'un adaptateur de fonction.
function adaptateur(nomFonction)
	return function (frame)
		local args = {}
		local argsParent = frame:getParent().args
 
		-- Paramètres vides interprétés par Lua.
		for cle, val in pairs(argsParent) do
			if val ~= '' then
				args[cle] = mw.text.trim(val)
			end
		end
 
		return p.main(nomFonction, args)
	end
end
 
local nomsFonction = {'protection', 'semiProtection', 'semiProtectionLongue', 'nomProtégé'} 
for _, nomFonction in ipairs(nomsFonction) do
	p[nomFonction] = adaptateur(nomFonction)
end
 
return p