Module:Item

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

local p = {}
-- mot vedette, stocké dans une variable globale
-- certes un peu grouik mais évite le passage intempestif en paramètre
-- Utiliser uniquement `definir_vedette` pour assigner une valeur
local vedette = ''

-- Assigne à vedette le nom de l'article appelant le modèle qui invoque se module
-- Si le nom contient des barres obliques, seules la partie après la dernière barre oblique est conservée
-- Logiquement cette fonction devrait être appelé une seule fois par invocation du module.
-- Sa valeur devrait ensuite être directement récupéré par la variable globale `vedette`
function definir_vedette()
	-- les opérations sur mw.title sont assez gourmandes, si la valeur a déjà été définie, inutile de la recalculer
	if vedette ~= '' then
		return vedette
	end
	-- récupération du dernier élément de la scission de la chaîne là où apparaît une barre oblique
	-- ceci est fait pour éviter de se retrouver avec des valeurs comme Utilisateur:Psychoslave/accommodation
	-- dans les tableaux de flexion.
	vedette = table.remove(mw.text.split(mw.title.getCurrentTitle().text, '/'))
end

-- mise en emphase du mot vedette
function emphase_vedette(texte)
	emphase = "%1'''%2'''%3"
	-- seul les occurences précédées et suivies d'une espace ou d'une ponctuation sont prises en compte
	cible = '([%s%p’])(' .. vedette .. ')([%s%p])'
	return string.gsub(texte, cible, emphase)
end

-- renvoie le mot vedette
function p.mot_vedette(frame)
	definir_vedette()
	return vedette
end

-- retourne le code langue associé à args.langue
-- en l'état de protypage ne prend en compte que le français
function code_langue(args)
	local langue = args.langue
	if langue == 'français' then
		return 'fr'
	end
	return 'farenda: code_langue'
end

-- retourne la prononciation api
function prononciation(args)
	return args.prononciation_api
end

-- retourne le type de paradigme associé au mot
function paradigme(args)
	local param = args.paradigme_flexionnel
	if param == 'régulier' then
		return 'rég'
	end
	return 'farenda: paradigme'
end

-- renvoie le modèle de flexion
function p.paradigme(frame)
	definir_vedette()
	local args = frame:getParent().args
	local lang = code_langue(args)
	local paradigme = paradigme(args)
	local pron = prononciation(args)
	 -- Exemple {{fr-rég|a.kɔ.mɔ.da.sjɔ̃}}
	local title = table.concat( {lang, '-', paradigme})
	return frame:expandTemplate{ title = title, args = {pron, s = vedette} } 
end

-- Crée le tableau des définitions, ordonné en arborescence à partir de l’ensemble plat des paramètres
--
-- Ainsi pour un tableau avec une entrée comme args['définition.8.exemple.3.description']
-- la fonction renvoie le tableau avec le tableau avec l’entrée defs[8]['exemple'][3]['description']
function gendef(args)
	local defs = {}
	for clef, desc in pairs(args) do
		-- si clef contient qqc comme définition.8.exemple.3.description
		if string.match(clef, 'définition.') then
			composantes = mw.text.split(clef, '%.')
			table.remove(composantes, 1) -- supprime "définition"
			local subtable = defs
			-- pour chaque composante `id`.
			-- Donc dans l’exemple successivement "8", "exemple", "3", "description"
			for i, id in ipairs(composantes) do
				-- convertir la composante en entier si possible, pour avoir une liste ordonnée
				local num = tonumber(id)
				if num then
					id = num
				end
				-- si c’est le dernier élément des composantes, lui affecter la description
				if i == #composantes then
					subtable[id] = desc
					break;
				end
				-- sinon c’est un tableau, éventuellement à créer, dont la clé `id` sera
				-- assigné par la prochaine itération
				if  subtable[id] == nil then
					subtable[id] = {}
				end
				subtable = subtable[id]
			end
		end
	end
	return defs
end

-- formatage d’une description définitionnelle
function formater_desc(description, niveau)
	return table.concat({"\n", string.rep('#', niveau), ' ', description})
end

-- formatage des exemples liés à une définition
-- `terme` est le tableau contenant les exemples
-- `niveau` est un entier qui indique le niveau de profondeur de la définition
function formater_exemples(terme, niveau)
	local description = ''
	local rang = string.rep('#', niveau) .. '*'
	for i, panel in ipairs(terme['exemple']) do
		description = table.concat(
			{
				description, "\n",
				rang,
				" ''",
				emphase_vedette(panel['description']),
				"''"
			}
		)
		-- traitement des sous-éléments d’un exemple, tel qu’une explication de texte ou une 
		-- modernisation de l’orthographe.
		for i, commentaire in ipairs(panel) do
			description = table.concat(
				{
					description,
					'\n',
					rang,
					': ',
					emphase_vedette(commentaire['description'])
				}
			)
		end
	end
	return description
end

-- formatage des définitions en wikitext
function formater(defs, profondeur)
	local niveau = profondeur or 1
	local texte = ""
	for lieu, matos in ipairs(defs) do
		texte = table.concat(
			{
				texte,
				formater_desc(matos["description"], niveau),
				formater_exemples(matos, niveau),
				formater(matos, niveau + 1)
			}
		)
	end
	return texte
end

-- renvoie les définitions formatés en wikitexte
function p.definitions(frame)
	definir_vedette()
	local args = frame:getParent().args
	local defs = gendef(args)
	return formater(defs)
end

return p