Module:Classement musical

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

Ce module implémente les modèles {{Albumchart}} et {{Singlechart}}. Voir la documentation des modèles pour les instructions d'utilisation. Le module produit dans un tableau une ligne avec le pays d'information, la meilleure position de l'album ou du single dans le classement musical ainsi que la référence en question. Il permet de simplifier la mise en forme des articles et des références.

Fonctions exportables

• main(frame) – Fonction implémentant le modèle {{Albumchart}} et {{Singlechart}} – à appeler avec #invoke.
• _main(args, chartType) – Fonction qui peut être appelée dans un autre module avec require(). Ceci est une bonne pratique d'appeler cette fonction dans un autre module car cela permet d'omettre certains champs de l'objet frame, ce qui améliore les performances et simplifie la gestion des arguments. Le paramètre typeChart définit avec l'argument :
  • 'album' importera les classements pour les albums,
  • 'single' importera les classements pour les singles.

Insertion

Pour insérer un nouveau classement musical, voir les modules de données :

• Module:Classement musical/Données/Album, pour les albums,
• Module:Classement musical/Données/Single, pour les singles.

Voir aussi

• Module:Classement musical/Données
• Module:Discographie

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.

--Ce module implémente les modèles {{Singlechart}} et {{Albumchart}}.

local p = {}

--Chargement du module de données
local donnees = mw.loadData('Module:Classement musical/Données')

--Redéfinitions utiles
local format = mw.ustring.format
local insert = table.insert

function p.singleChart(frame)
	typeChart = 's'
	return gestionArgs(frame)
end

function p.albumChart(frame)
	typeChart = 'a'
	return gestionArgs(frame)
end

function gestionArgs(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 _ligneChart(args)
end

function _ligneChart(argsChart)
	args = argsChart
	local res = mw.html.create('tr')
	local cleChart, valChart = elementChart()

	if args.rowheader == 'oui' then
		res
			:tag('th')
			:attr('scope', 'row')
			:css('font-weight', 'normal')
			:node(celluleClassement(cleChart, valChart) or erreurArgs(cleChart))
	else
		res
			:tag('td')
			:node(celluleClassement(cleChart, valChart) or erreurArgs(cleChart))
	end

	res
		:tag('td')
		:css('text-align', 'center')
		:wikitext(args[2] or '{{{2}}}')

	return tostring(res)
end

function elementChart()
	local data
	if typeChart == 's' then
		--Récupération de la table de données pour les singles
		data = mw.loadData('Module:Classement musical/Données/Single')
	else
		--Récupération de la table de données pour les albums
		data = mw.loadData('Module:Classement musical/Données/Album')
	end
	local cleChart = mw.ustring.lower(args[1] or '')
	local valChart = data.charts[cleChart]

	--Récupération de l'alias du classement si existant
	if not valChart then
		for nomChart, aliasCharts in pairs(data.alias) do
			for _, aliasChart in ipairs(aliasCharts) do
				if aliasChart == cleChart then
					return nomChart, data.charts[nomChart]
				end
			end
		end
	end

	return cleChart, valChart
end

function celluleClassement(cleChart, valChart)
	if not valChart then return end
	local res = mw.html.create()
	local frame = mw.getCurrentFrame()
	local argsManquants = gestionErreurArgs(valChart)

	--Gestion des exceptions des arguments du modèle
	if next(argsManquants) then
		res:wikitext(erreurArgs(argsManquants))
		return tostring(res)
	end

	res
		:wikitext(frame:expandTemplate{title = valChart.drapeau})
		:wikitext(format(' (%s)', valChart.chart))
		:wikitext(frame:extensionTag('ref', contenuReference(valChart), {
			name = args.refname or typeChart .. 'c_' .. cleChart,
			group = args.refgroup
		}))

	if args.note then
		res
			:tag('br', {selfClosing = true})
			:done()
			:tag('span')
				:css('font-style', 'italic')
				:css('font-size', '89%')
				:wikitext(args.note)
	end

	return tostring(res)
end

function contenuReference(valChart)
	local res = mw.html.create()
	local frame = mw.getCurrentFrame()

	if valChart.langue then
		res
			:wikitext(frame:expandTemplate{title = valChart.langue})
			:wikitext(' ')
	end

	res:wikitext(format('%s. %s. %s. ',
		gestionLienUrl(valChart),
		valChart.noteChart or valChart.chart,
		valChart.editeur))

	if args['en ligne le'] then
		res:wikitext(format('Mis en ligne le %s. ', args['en ligne le']))
	end

	if args['consulté le'] then
		res:wikitext(format('Consulté le %s.', args['consulté le']))
	end

	return tostring(res)
end

function erreurArgs(argsManquants)
	local res = mw.html.create('span')
		:addClass('error')
		:css('font-size', '100%')
		:wikitext('Erreur : ')

	--Catégorie de détection pour maintenance
	--res:wikitext(donnees.cfg['catDetection' .. typeChart])

	--Exception de type classement non répertorié
	if type(argsManquants) == 'string' then
		res:wikitext(format(donnees.cfg['chartErreur'], argsManquants))
		return tostring(res)
	end

	--Mise en forme des arguments manquants
	for cle, val in ipairs(argsManquants) do
		argsManquants[cle] = '<code>|' .. val .. '=</code>'
	end

	--Maximum de 2 arguments manquants
	res:wikitext(format(donnees.cfg['argErreur' .. #argsManquants],
		args[1],
		unpack(argsManquants)))

	return tostring(res)
end

function gestionErreurArgs(valChart)
	local erreurArgs = {}

	for cleFormats, valFormats in pairs(donnees.formatsLiens) do
		if valChart[cleFormats] then
			for _, argManquant in ipairs(valFormats) do
				if not args[argManquant] then
					insert(erreurArgs, argManquant)
				end
			end
			return erreurArgs
		end
	end

	return erreurArgs
end

function gestionLienUrl(valChart)
	local argLien, argTitre = {}, {}
	local res
 
	for cleFormats, valFormats in pairs(donnees.formatsLiens) do
		if valChart[cleFormats] then
			--Récupération du lien et du titre du classement
			insert(argLien, valChart[cleFormats])
			insert(argTitre, valChart[valFormats.titre])
 
			--Récupération des arguments nécessaires au lien et au titre
			for _, nomArg in ipairs(valFormats) do
				if nomArg ~= 'artisteid'
				and nomArg ~= 'semaine'
				and nomArg ~= 'année'
				and nomArg ~= 'date' then
					insert(argLien, encodeUrl(args[nomArg], valFormats.encode))
				else
					--Cas de l'insertion de l'année à deux reprises (lienAnnee2)
					if valFormats.doubleAnnee and nomArg == 'année' then
						insert(argLien, args[nomArg])
					end
					insert(argLien, args[nomArg])
				end
 
				if nomArg == 'chanson' or nomArg == 'album' then
					insert(argTitre, format("''%s''", args[nomArg]))
				elseif nomArg ~= 'artisteid' then
					insert(argTitre, args[nomArg])
				end
			end
			break
		end
	end
 
	--Récupération des valeurs de la table et transformation en
	--argument pour mise en forme avec la fonction de formatage
	local lien = format(unpack(argLien))
	local titre = format(unpack(argTitre))
 
	--Mise en forme de l'URL
	res = format('[http://%s %s]', lien, titre)

	if valChart.noteInsertion then
		if args.semaine and args['année'] then
			res = res .. format(donnees.cfg['noteInsertion'], args.semaine .. args['année'])
		else
			res = res .. format(donnees.cfg['noteInsertion'], "l'année et la semaine")
		end
	end

	return res
end

function encodeUrl(texteEncode, lienHungMedien)
	local res = mw.uri.encode(texteEncode)
	
	if lienHungMedien then
		--Parcours de la table et substitution
		for cle, val in pairs(donnees.encHungMedien) do
			local copie, valeurMatch = res:gsub(cle, val)
			if valeurMatch > 0 then
				res = copie
			end
		end
	end

	return res
end

return p