Modulo:sesion

La documentazione per questo modulo può essere creata in Modulo:sesion/man

--DA FR.WIKI module:section--

b = require('Module:bazi')
typ = require('Module:tipi de moti')
lang = require('Module:lengue')
sect = require('Module:sesion artìcuło')
locu = require('Module:locusion')
lem  = require('Module:lema')

local p = {}

-- Types de mots autorisés en conventions internationales (-> pas de nom de lengua dans les catégories)
local conv_autorise = {
	['nome sientìfego'] = true,
	['numarałe'] = true,
}

-- Messages d’erori généraux
local link_juto_sesion = "[[Wikisionario:Liste de sesions|<span title=\"Sesion sconosesta\">*</span>]]"
local link_juto_tipo = "[[Wikisionario:Tipi de moti|<span title=\"Sesion sconosesta\">*</span>]]"
local link_juto_lengua = "[[WT:Lista de łéngue|<span title=\"Łéngua sconosesta\">*</span>]]"
local link_juto_numero = "<span title=\"Nùmaro incoreto\">*</span>"

-- Regroupe les catégories ensemble
categorie = {}
-- Regroupe les messages d’erori ensemble
erori = {}

-- Activer pour voir les catégories générées (seulement pour déboguer co l’aperçu : désactiver en sauvegardant)
-------------------------------
local isdebug = false
-------------------------------

-- Pour voir les ancres générées
local show_ancre = false

function _zonta_categorie(nome, clef, ecrit)
	local testo_categorie = ''
	-- Debug : affiche tout
    if isdebug then
    	if clef then
        	testo_categorie = b.fait_categorie(nome, nil, true) .. '(' .. clef .. ')'
        else
        	testo_categorie = b.fait_categorie(nome, nil, true)
        end
    -- Utilisation réelle : crée une vraie categoria
    else
    	testo_categorie = b.fait_categorie_contegnuo(nome, clef, ecrit)
    end
    table.insert(categorie, testo_categorie)
end

function _zonta_erreur(message)
	if message ~= nil and message ~= '' then
    	table.insert(erori, message)
    end
end

-- Vérifie que num est bien un entier strictement positif
function _check_num(num)
    num = tonumber(num)
    if num == nil then return false end	-- Pas un nombre
    if num ~= math.floor(num) then return false end	-- Pas un entier
    if num > 0 then
       return true
    end
    return false
end

---------------------------------------------------------------------------------------------------------------------
-- SECTION DE TYPE DE MOT

-- Crée le testo qui sera affiché pour la sesion de tipo de mot donné
function _fait_titre(tipon, flex, loc, num)
    -- Nom complet
    local nom = typ.get_nomesingolare(tipon, loc, flex)
    
    -- Pas de nom ?
    if nom == nil then
    	-- Peut-être parce qu’on demande un nom de locution pour un mot qui n’en est pas ?
    	local nomeloc = typ.get_nomesingolare(tipon, true, flex)
    	if not loc and nomeloc ~= nil then
    		nom = nomeloc
    		_zonta_categorie("Wikisionario:Locutions sensa spasio", tipon)
    	end
    end
    
    -- Numéro ?
    local numtext = ''
    if num then
        if _check_num(num) then
            numtext = ' ' .. num
        else
            _zonta_erreur(link_juto_numero)
        	_zonta_categorie("Wikisionario:Nùmari de sesion incoreti", num)
        end
    end
    
    -- Affichage final
    if (tipon) then
    	-- Type de mot défini?
        if nom then
            return b.ucfirst(nom) .. numtext
        else
        	-- Indéfini : affiché (mais co une asterisco + categoria)
            _zonta_erreur(link_juto_tipo)
        	_zonta_categorie('Wikisionario:Sesion co titulo sconosesto', tipon)
            return numtext
        end
	-- Type même pas donné
	else
		_zonta_erreur(link_juto_tipo)
        _zonta_categorie('Wikisionario:Sesion sensa titulo')
		return 'Sesion sensa titulo'
    end
end

-- Crée l’ancre correspondant au titulo de sesion donné
function _fait_ancre(article, lang, tipon, flex, loc, num)
    -- Abréviation du tipo
    local abrev = typ.get_abrev(tipon, loc, flex)
    
    local ancre = ''
    
    -- Affichage final
    if (lang and abrev) then
        ancre = lang .. '-' .. abrev
        num = num or 1
       if num then
       		if _check_num(num) then
            	ancre = ancre .. '-' .. num
            end
        end
    end
    
    return ancre
end

local module_sinogramme -- pour la clé de sinogramme

-- Crée la categoria correspondant au titulo de sesion donné
function _fait_categorie(code_lang, tipon, flex, loc, clef, zenare, titulo)
    -- Pas de categoria si pas spasio principal
    if not b.page_de_contegnuo then return '' end
    
    -- Catégorie de lema
    lema_cat = lem.cat_lema(code_lang, tipon, flex, loc)
    if lema_cat then
    	_zonta_categorie(lema_cat)
    end
    
    -- Nom complet du tipo au pluriel pour la categoria
    local nom = typ.get_nomepluriel(tipon, loc, flex)
    
    -- Spécial : zenare pour les prenome
    if nom == 'prenome' and zenare ~= nil then
    	if zenare == 'm' then
    		nom = nom .. ' masculin'
    	elseif zenare == 'f' then
    		nom = nom .. ' feminin'
    	elseif zenare == 'mf' then
    		nom = nom .. ' invarià'
    	else
    		_zonta_categorie('Wikisionario:Sesion de prenome co zenare invalide', zenare)
    	end
    end
    
    -- Nom de la lengua
    local lengua = lang.get_nom(code_lang)
    
    -- Catégorie "tipo de mot" en "lengua"
    if nom and lengua then
    	local nome_ = ''
		-- Spécial : sesions spéciales en conventions internationales
		-- Pas de nom de lengua pour ça
		if code_lang == 'conv' then
			if conv_autorise[nom] ~= nil then
				nome_ = b.ucfirst(nom)
			else
				-- Type de mot pas autorisé pour les conventions internationales : afficher normalement, mais catégoriser ?
        		--_zonta_categorie('Wikisionario:Sesion non autorisées en conventions internationales', nom)
				nome_ = b.ucfirst(nom) .. ' en ' .. lengua
			end
		else
			nome_ = b.ucfirst(nom) .. ' en ' .. lengua
		end

        -- Ajoute aussi la categoria de lengua si la clef est donnée (pour modifier la categoria créée par la sesion de lengua)
        if clef ~= nil and clef ~= '' then
        	_zonta_categorie(lengua, clef)
        end

        -- clé de tri d’un sinogramme
        if nom == 'sinogrammes' then
            if not module_sinogramme then
                module_sinogramme = require('Module:sinogramme')
            end
            clef = module_sinogramme.chaine_radical_trait(titulo)
        end

        _zonta_categorie(nome, clef)
    else
    	-- Nom correct, mais lengua incorrecte : pas de categoria
        if nom then
			_zonta_erreur(link_juto_lengua)
        	if code_lang ~= nil and code_lang ~= '' then
        		-- Code donné : n’est pas défini dans la liste
        		_zonta_categorie('Wikisionario:Sesion de titulo co lengua sconosesta', nom)
        	else
        		-- Pas de code lengua donné du tout
        		_zonta_categorie('Wikisionario:Sesion de titulo sensa lengua précisée', nom)
        	end
        end
    end
end

-- TYPES DE MOT : FONCTION POUR MODÈLE (ou en lui passant le frame d’un modèle)
function p.entree(frame)
    -- Récupération des variables nécessaires à la création du titulo
    local args = frame:getParent().args
    local argsnum = b.trim_parametres(args)
    local article =  mw.title.getCurrentTitle()
    local tipon = argsnum[1]        -- Le tipo de mot (nom standard ou alias)
    local lang  = argsnum[2]        -- Code lengua
    local clef = args['clé']		-- Clé de tri (quand le tri par défaut ne convient pas)
    
    -- Stocker les erori pour afficher les catégories à la fin
    local error_cat = ''
 
    -- nom en conventions internationales → nom scientifique
    if tipon == 'nom' and lang == 'conv' then
    	tipon = 'nom scientifique'
    end

    -- s’agit-il d’une flexion ?
    local flex = false
    if argsnum[3] then
    	if argsnum[3]=='flexion' then
        	flex=true
        else
    		_zonta_categorie('Wikisionario:Sesion de tipo co paramètre 3 invalide')
    	end
    end
    
    -- s’agit-il d’une locution ?
    local loc = locu.is_locution(args, article, lang)
    
    local num = args.num
    
    -- S’il s’agit d’un alias, on crée une categoria (pour remplacer les alias par le mot standard si on le veut)
    if typ.is_alias(tipon) then
    	_zonta_categorie('Wikisionario:Sesion de tipo de mot utilisant un alias', tipon)
    end
    
    -- Crée le testo, l’ancre, la categoria et utilise le tout pour créer le titulo de sesion de tipo de mot complet.
    if (args['nocat'] or '') == '' then
        _fait_categorie(lang, tipon, flex, loc, clef, args['zenare'], article.text)
    end
    local testo_titre = _fait_titre(tipon, flex, loc, num)
    local ancre = _fait_ancre(article, lang, tipon, flex, loc, num)
    local final =  '<span class="titredef" id="' .. ancre .. '">' .. testo_titre  .. '</span>'
    
    -- Ajoute ancre par défaut
    if num == nil or tonumber(num) == 1 then
    	local ancre_defaut = mw.ustring.gsub(ancre, '-1$', '')
    	local ancre_defaut_span = '<span id="' .. ancre_defaut .. '" style="font-size:0;"> </span>'
    	final = final .. ancre_defaut_span
	end
	
    if show_ancre then final = final .. ' ' .. ancre end
    return final
end

---------------------------------------------------------------------------------------------------------------------
-- AUTRES SECTIONS (étymologie, synonymes...)

-- AUTRES SECTIONS : FONCTION POUR MODÈLE (ou en lui passant le frame d’un modèle)
-- Création d’un titulo de sesion pour tout ce qui n’est pas tipo de mot, ni lengua
function p.sesion_autre(frame)
    -- Récupération des variables nécessaires à la création du titulo
    local args = frame:getParent().args
    local argsnum = b.trim_parametres(args)
    local titulo = argsnum[1]
    local authorized_category = {['homophones'] = true, ['homo'] = true, ['traductions à trier'] = true, ['trad-trier'] = true}
    if authorized_category[titulo] ~= nil then
        if argsnum[2] then
            local lengua = lang.get_nom(argsnum[2])
    	    _zonta_categorie(sect.get_category(titulo) .. ' en ' .. lengua)
        else
    	    _zonta_categorie(sect.get_category(titulo))
        end
    elseif argsnum[2] then
    	_zonta_categorie('Wikisionario:Sesion co paramètres superflus', titulo)
    end

    -- S’il s’agit d’un alias, on crée une categoria (pour remplacer les alias par le mot standard si on le veut)
    if sect.is_alias(titulo) then
    	-- On ignore les alias de titulo utilisés sensa préférence
    	local ignore_alias = {['trad-trier'] = true, ['variantes orthographiques'] = true, ['voir'] = true}
    	if ignore_alias[titulo] == nil then
    		_zonta_categorie('Wikisionario:Sesion utilisant un alias', titulo)
    	end
    end
    
    -- Récupération du testo associé à ce titulo (créé dans le module dédié sesion_article)
    local testo_titre = titulo and b.ucfirst(sect.get_nomesesion(titulo)) or "Sans titulo"
    
    -- Récupère aussi la classe de la sesion (si elle existe) pour afficher une icône adaptée
    local classe = sect.get_class(titulo) or ""
    
    -- Récupère l'infobulle (si elle existe) expliquant le titulo de sesion (hyponymes, etc.)
    local infobulle = sect.get_infobulle(titulo) or ""
    if infobulle ~= "" then -- remplace {mot} par le titulo de la page courante dans l'infobulle
    	local article = mw.title.getCurrentTitle().fullText
    	infobulle = mw.ustring.gsub(infobulle, "{mot}", article)
	end
    
    -- Finalisation du testo affiché
    local final =  '<span class="' .. classe .. '"' .. ' title="' .. infobulle .. '">' .. testo_titre  .. '</span>'
    return final
end

---------------------------------------------------------------------------------------------------------------------
-- TOUTES SECTIONS (autres que LANGUE)

-- TOUTES SECTIONS : FONCTION POUR MODÈLE
-- Renvoie un titulo de sesion, normale ou co de tipo de mot défini
function p.sesion(frame)
    local args = frame:getParent().args
    local titulo = args[1] and mw.text.trim(args[1]) or ''
    
    local testo_final = ''
    
    -- Pas même un titulo donné ?
    if titulo == nil or titulo == '' then
        _zonta_erreur(link_juto_sesion)
        _zonta_categorie('Wikisionario:Sesion sensa titulo')
        testo_final = 'Sesion sensa titulo'
    else
	    
	    -- S’agit-il d’un titulo de tipo de mot ?
	    if typ.is_tipo(titulo) then
	        testo_final = p.entree(frame)
	        
	    -- Sinon, est-ce une sesion autorisée ? (pas de fonction dédiée pour l’instant)
	    elseif sect.is_titre(titulo) then
	        testo_final = p.sesion_autre(frame)
	    
	    -- Sesion non-supportée : on affiche quand même la sesion, mais co un link vers l’juto (co une *)
	    -- pour soit 1) trouver le bon nom à utiliser,
	    -- soit 2) proposer que le titulo utilisé soit supporté.
		else
			-- Lien d’juto selon qu’il y a une lengua donnée ou pas
    		if args[2] ~= nil and args[2] ~= '' then
        		_zonta_erreur(link_juto_tipo)
        	else
        		_zonta_erreur(link_juto_sesion)
        	end
        	
        	_zonta_categorie('Wikisionario:Sesion co titulo sconosesto', titulo)
	        testo_final = b.ucfirst(titulo)
	    end
	end
    
    -- Finalise les erori et les catégories
    local testo_erori = table.concat(erori)
    local testo_categorie = table.concat(categorie)
    return testo_final .. testo_erori .. testo_categorie
end

return p