Module:Taxobox2

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

Ce module fournit une fonction permettant de générer une taxobox.

Utilisation

Fonctions exportables :

• taxobox(frame) – la fonction servant à créer une taxobox. Voir documentation détaillée pour son utilisation

Autres fonctions :

• genere_sortie(texte, debug) – formate le retour de taxobox(frame) et insert si besoin la sortie debug

Modules externes et autres éléments dont ce module a besoin pour fonctionner :

• Module:Taxobox données − module contenant toutes les données constantes relatives à la construction d'une taxobox
• Module:Taxobox fonctions − module contenant toutes les fonctions de traitement des paramètres et de création du contenu
• mw.title – utilisé pour connaître le titre de la page où on est utilisé
• .mw.text, mw.ustring…

Déroulement de l'exécution

Les étapes pour créer une taxobox sont toujours les mêmes. Les actions de la fonction taxobox(frame) sont :

• enregistrement frame et pframe dans la table donnees.defauts.{frame|pframe}} (pour utilisation par d'autres fonctions
• récupération du titre et du namespace de l'article (donnees.defauts.{article|titre})
• analyse des paramètres nommés. Contenu : "charte" et "nom vernaculaire" ; comportement : c_titre, c_sous_titre, c_categories, c_categories_err, c_erreurs, c_force_titre ; debug : raw, debug. Vérifications sur les paramètres (présence obligatoire de "charte", et qu'elle corresponde à une charte connue).
• analyse des paramètres non nommés pour créer la liste des commandes (suite des lignes de taxobox à créer : donnees.defauts.commandes) avec la commande tri_parametres(). Validation que cette phase c'est bien passée.
• initialisation de l'état courant de la taxobox (ouverte, fermée, nombre de tables ouvertes…)
• recherche des entrées "taxon" (commande tri_taxons). Cette fonction regroupe les lignes "taxon" dans une table, note le dernier "taxon" donné Note également si l'un des taxons indiqué peut correspondre au titre de l'article.
• détermination du titre de la taxobox (genere_titre_taxobox()).
• boucle de parcours des commandes de la taxobox. Parcours sur les lignes de donnees.defauts.commandes :
  • analyse de la ligne (lecture_parametres()) en utilisant la syntaxe de la commande. Retourne resu contenant les paramètres de la ligne
  • exécution de la fonction traitant la commande correspondante, sur les paramètres de la ligne
  • gestion de la structuration (ouverture/fermeture de tables typiquement)
  • ajout du code de la ligne à la taxobox en cours de création
  • note : à chaque étape diverses vérifications de la présence d'erreurs
• détermination des modifications éventuelles du titre de l'article (mise en forme)
• détermination de l'ajout éventuel d'un sous-titre à l'article
• détermination des catégories éventuelles à ajouter (et selon le mode choisi et le namespace)
• détermination des catégories d'erreurs éventuelles à ajouter (et selon le mode choisi et le namespace)
• détermination des erreurs éventuelles à ajouter (et selon le mode choisi et le namespace)
• retour du résultat

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.

--[[
  Module créant une taxobox.
  
  Utilise Module:Taxobox données et Module:Taxobox fonctions.

  Note : le nom est temporaire. Module:Taxobox existe et contient une vieille version destinée à être remplacée.
--]]


-- la table du module
local p = {}

local donnees = require "Module:Taxobox données"
local fnc = require "Module:Taxobox fonctions"



--[[
  Fonction principale : traite les paramètres et génère la taxobox.
  Les paramètres sont :
    règne : obligatoire. Sélectionne le thème (couleur, convention typographique, lignes de classification)
    nom vernaculaire : facultatif. Informe la taxobox du ou des noms vernaculaires existants
    …
--]]
function p.taxobox(frame)
    local dg = ""
    
    donnees.defauts.frame = frame -- pour que les fonctions aient accès à la frame courante simplement
    donnees.defauts.pframe = frame:getParent() -- pour que les fonctions aient accès à la frame courante simplement
    
    dg = dg .. "frames préparées.<br/>"
    
    -- on récupère les infos sur l'article où on se trouve
    local curarticle = mw.title.getCurrentTitle()
    if (curarticle.namespace == 0) then -- est-ce un article ou pas
        donnees.defauts.article = true
    else
        donnees.defauts.article = false
    end
    -- le titre courant
    donnees.defauts.titre = curarticle.text
    
    dg = dg .. "namespaces+titre extraits.<br/>"
    
    -- récupération des paramètres
    donnees.defauts.regne = fnc.lit_parametre("charte", donnees.liste_regnes, false, nil)  -- la charte
    if (donnees.defauts.regne == nil) then
        donnees.defauts.regne = fnc.lit_parametre("règne", donnees.liste_regnes, false, true)  -- le règne
    end
    donnees.defauts.nom_vernaculaire = fnc.lit_parametre("nom vernaculaire", nil, false, nil)  -- le non vernaculaire
    -- les options permettant de modifier le comportement
    donnees.defauts.c_titre = fnc.lit_parametre("titre", {"oui","non","boîte","auto"}, false, "auto")
    donnees.defauts.c_sous_titre = fnc.lit_parametre("sous-titre", {"oui","non","auto"}, false, "auto")
    donnees.defauts.c_erreurs = fnc.lit_parametre("erreurs", {"oui","non","auto"}, false, "auto")
    donnees.defauts.c_categories = fnc.lit_parametre("catégories", {"en ligne","non","boîte","auto"}, false, "auto")
    donnees.defauts.c_categories_err = fnc.lit_parametre("catégorie erreurs", {"en ligne","non","boîte","auto"}, false, "auto")
    donnees.defauts.c_force_titre = fnc.lit_parametre("force titre", nil, false, nil)
    -- si force titre vide on utilise le titre réel
    if (donnees.defauts.c_force_titre == nil) then
        donnees.defauts.c_force_titre = donnees.defauts.titre
    end

    -- debug
    donnees.defauts.c_raw = fnc.lit_parametre("raw", nil, true, nil)
    donnees.defauts.c_debug = fnc.lit_parametre("debug", nil, true, nil)

if (donnees.defauts.c_debug == nil) then
    dg = dg .. "debug=nil<br/>"
elseif (donnees.defauts.c_debug == true) then
    dg = dg .. "debug=true<br/>"
elseif (donnees.defauts.c_debug == false) then
    dg = dg .. "debug=false<br/>"
else
    dg = dg .. "debug=" .. donnees.defauts.c_debug .. "<br/>"
end
donnees.defauts.c_debug=true

    -- on regarde si une erreur (ou plusieurs) s'est produite durant la récupération des paramètres
    if (donnees.defauts.fatal) then
        return dg .. fnc.erreur_globale(donnees.defauts, donnees.categorie_erreur)    
    end
    
    dg = dg .. "paramètres récupérés.<br/>"

    -- on récupère la structure règne
    donnees.defauts.regne_data = donnees.regnes[donnees.defauts.regne]
    if (donnees.defauts.regne_data == nil) then
        fnc.erreur_normale("Le règne indiqué ''" .. donnees.defauts.regne .. "'' n'est pas reconnu.", "syntaxe")
        return fnc.erreur_globale(donnees.defauts, donnees.categorie_erreur)    
    end

    -- on analyse les paramètres pour générer la liste des commandes présentes
    local xxx, yyy = fnc.tri_parametres(donnees)
    dg = dg .. yyy
    if (donnees.defauts.fatal) then -- erreur → fatal
        return fnc.erreur_globale(donnees.defauts, donnees.categorie_erreur)    
    end
    
    dg = dg .. "commandes analysées.<br/>"
    
    -- initialisation de l'état de la taxobox en construction
    donnees.etat = {}
    donnees.etat.ouvert = false -- la taxobox est commencée
    donnees.etat.ferme = false -- la taxobox est terminée
    donnees.etat.ligne = "non commencé" -- le nom de la ligne en cours
    donnees.etat.tbl = 0 -- nombre de tables ouvertes
    
    dg = dg .. "état taxobox initialisé.<br/>"
    
    -- on parcours les commandes pour trouver les "taxon", afin de valider leur présence
    -- et de trouver le titre de la taxobox
    fnc.tri_taxons()
    if (donnees.defauts.fatal) then -- erreur → fatal
        return fnc.erreur_globale(donnees.defauts, donnees.categorie_erreur)
    end
    
    dg = dg .. "taxons analyés (dernier taxon et titre = " .. donnees.defauts.titre_taxobox .. ").<br/>"
    
    -- on traite le titre/sous-titre : est-ce le NS ? Est-ce le NV ? Autre ?
    fnc.genere_titre_taxobox()
    dg = dg .. "titre taxobox géré (titre = " .. donnees.defauts.titre_taxobox .. ").<br/>"

    -- parcours des commandes et appel des fonctions de traitement de chaque ligne
    local tb = ""
    local i = 1
    local courant = ""
    local precedent = ""
    while (donnees.defauts.commandes[i] ~= nil) do
        -- le mot-clé
        local cle = donnees.defauts.commandes[i][1]
        if (cle == nil) then  -- fatal
            fnc.erreur_fatale("La " .. i .. "ème commande n'existe pas.", "interne")
            return dg .. fnc.erreur_globale(donnees.defauts, donnees.categorie_erreur)
        end
        courant = cle
dg = dg .. "  - commande : " .. cle .. "<br/>"
        -- on récupère le descriptif de cette commande
        local cmd = fnc.syntaxe[cle]
        if (cmd == nil) then
dg = dg .. "    -> commande non référencée<br/>"
            fnc.erreur_fatale("La " .. i .. "ème commande (''" .. cle .. "'') n'est pas référencée dans les actions.", "interne")
            return dg .. fnc.erreur_globale(donnees.defauts, donnees.categorie_erreur)
        end
dg = dg .. "   -> cmd : " .. type(cmd[1]) .. ", " .. type(cmd[2]) .. ", " .. type(cmd[3]) .. "<br/>"
        -- si pas de fonction associée erreur non fatale et on ignore
        if (cmd[3] == nil) then
dg = dg .. "    -> commande non implémentée<br/>"
            fnc.erreur_normale("La commande ''" .. cle .. "'' n'est pas encore implémentée.", "interne")
        else
            -- on analyse la ligne
            local etat, resu = pcall(fnc.lecture_parametres, donnees.defauts.commandes[i], 2, cmd[2])
            if (not etat) then
                fnc.erreur_fatale("Échec d'appel à lecture_parametres (" .. cle .. ") (" .. resu .. ").", "interne")
                return dg .. fnc.erreur_globale(donnees.defauts, donnees.categorie_erreur) -- on quitte
            end
dg = dg .. "    - syntaxe analysée<br/>"
            -- gestion des erreurs
            if (resu == nil or resu.erreurs ~= nil) then
                -- une erreur sur cette ligne est-elle fatale ?
dg = dg .. "    -> commande retourne une erreur<br/>"
                if (cmd[1] == 2) then
                    fnc.erreur_fatale(resu.erreur, "syntaxe")
                    return dg .. fnc.erreur_globale(donnees.defauts, donnees.categorie_erreur) -- on quitte
                else
                    fnc.erreur_normale(resu.erreur, "syntaxe")
                end
            else 
dg = dg .. "    - syntaxe validée<br/>"
                -- on exécute la ligne
                local tmpr, tmpd
                tmpr, tmpd = pcall(cmd[3], resu)
                if (not tmpr) then
                    fnc.erreur_fatale("Échec d'appel à la fonction de gestion de ''" .. cle .. "'' (" .. tmpd .. ").", "interne")
                    return dg .. fnc.erreur_globale(donnees.defauts, donnees.categorie_erreur) -- on quitte
                end
dg = dg .. "données : precedent=" .. precedent .. ", courant=" .. courant .. ", tbl=" .. donnees.etat.tbl .. "<br/>"
                -- gestion des fermetures de tables
                if (precedent == "rang" and courant ~= "rang") then
                    -- on quitte un rang → on ferme la table
                    tb = tb .. "</table>"
                    donnees.etat.tbl = donnees.etat.tbl - 1
                end
                -- traitement de "dépannage" : si "rang" sans table ouverte on ouvre la table mais c'est une erreur
                if (courant == "rang" and donnees.etat.tbl <= 0) then
                    fnc.erreur_normale("Ligne " .. i .. " : commande ''rang'' en dehors d'une zone adéquate.", "syntaxe")
                    tb = tb .. '<table  class="taxobox_classification taxoalternance"><caption>Erreur</caption>\n'
                    donnees.etat.tbl = donnees.etat.tbl + 1
                end

                -- on insert l'élément
                tb = tb .. tmpd
dg = dg .. "    - commande traitée<br/>"
            end
        end
        -- on bascule courant/precedent
        precedent = courant
        -- ligne suivante
        i = i + 1
    end
    
    -- traitement titre article (mise en forme si nécessaire)
    local mtitre = ""
    if (donnees.defauts.taxon_titre ~= nil) then -- il y a un titre NS
        if (donnees.defauts.c_titre ~= "non") then
dg =dg .. "titre a modifier a priori : titre = " .. donnees.defauts.c_force_titre .. ", ciblé = " .. donnees.defauts.commandes[donnees.defauts.taxon_titre][3] .. "<br/>"
            -- le titre modifié
            local tmp = fnc.italiques_titre(donnees.defauts.c_force_titre, donnees.defauts.commandes[donnees.defauts.taxon_titre][3], donnees.defauts.commandes[donnees.defauts.taxon_titre][2])
dg = dg .. " -> " .. tmp .. "<br/>"
            -- selon le mode
            if (donnees.defauts.c_titre == "boîte" or (donnees.defauts.c_titre == "auto" and not donnees.defauts.article)) then
                mtitre = mtitre .. fnc.box_ouverture("Titre")
                mtitre = mtitre .. fnc.box_texte(frame:preprocess("<nowiki>" .. tmp .. "</nowiki>"))
                mtitre = mtitre .. fnc.box_fermeture()
            elseif (donnees.defauts.c_titre == "oui" or (donnees.defauts.c_titre == "auto" and donnees.defauts.article)) then
                mtitre = mtitre .. frame:preprocess(tmp)
            end
        end
    end


    -- traitement sous-titre éventuel
    local mstitre = ""
    if (donnees.defauts.c_sous_titre ~= "non") then
dg = dg .. "sous-titre potentiel<br/>"
        local sst = nil
        -- si taxon_titre → titre en NS, on ajoute le NV si présent
        if (donnees.defauts.taxon_titre ~= nil) then
dg = dg .. " -> vernaculaire : " .. (donnees.defauts.nom_vernaculaire or "non défini") .. "<br/>"
            sst = donnees.defauts.nom_vernaculaire
        else
            -- titre NV, on ajoute le NS en sous-titre
dg = dg .. " -> scientifique : " .. donnees.defauts.titre_taxobox .. "<br/>"
            sst = donnees.defauts.titre_taxobox
        end
        if (donnees.defauts.c_sous_titre == "boîte" or (donnees.defauts.c_sous_titre == "auto" and not donnees.defauts.article)) then
            if (sst ~= nil) then
                mstitre = mstitre .. fnc.box_ouverture("Sous-titre")
                mstitre = mstitre .. fnc.box_texte(sst)
                mstitre = mstitre .. fnc.box_fermeture()
            end
        elseif (donnees.defauts.c_sous_titre == "oui" or (donnees.defauts.c_sous_titre == "auto" and donnees.defauts.article)) then
            -- on l'insert en tant que sous-titre
            if (sst ~= nil) then
                mstitre = mstitre .. '<span id="sous_titre_h1">' .. sst .. '</span>'
            end
        end
    end
    
    -- si besoin et selon les modalités on insert les catégories
    local mcat = ""
    if (donnees.defauts.r_categories[1] ~= nil and donnees.defauts.c_categories ~= "non") then
        -- selon le mode
        if (donnees.defauts.c_categories == "boîte" or (donnees.defauts.c_categories == "auto" and donnees.defauts.article == false)) then
            mcat = mcat .. fnc.box_ouverture("Catégorie(s)")
            mcat = mcat .. fnc.box_texte(donnees.defauts.r_categories, true)
            mcat = mcat .. fnc.box_fermeture()
        elseif (donnees.defauts.c_categories == "en ligne" or (donnees.defauts.c_categories == "auto" and donnees.defauts.article == true)) then
            -- insertion "en vrai"
            local i = 1
            while (donnees.defauts.r_categories[i] ~= nil) do
                mcat = mcat .. "[[Catégorie:" .. donnees.defauts.r_categories[i] .. "]]"
                i = i + 1
            end
        end
    end
    
    -- si besoin et selon les modalités on insert les catégories d'erreur
    local mcaterr = ""
    if (donnees.defauts.r_err_categories[1] ~= nil and donnees.defauts.c_err_categories ~= "non") then
        -- selon le mode
        if (donnees.defauts.c_err_categories == "boîte" or (donnees.defauts.c_err_categories == "auto" and donnees.defauts.article == false)) then
            mcaterr = mcaterr .. fnc.box_ouverture("Catégorie d'erreur(s)")
            mcaterr = mcaterr .. fnc.box_texte(donnees.defauts.r_err_categories, true)
            mcaterr = mcaterr .. fnc.box_fermeture()
        elseif (donnees.defauts.c_err_categories == "en ligne" or (donnees.defauts.c_err_categories == "auto" and donnees.defauts.article == true)) then
            -- insertion "en vrai"
            local i = 1
            while (donnees.defauts.r_err_categories[i] ~= nil) do
                mcat = mcat .. "[[Catégorie:" .. donnees.categorie_erreur .. "|" .. donnees.defauts.r_categories[i] .. "]]"
                i = i + 1
            end
        end
    end
    
    -- si besoin et selon les modalités on insert les erreurs
    local merr = ""
    if (donnees.defauts.r_erreurs[1] ~= nil and donnees.defauts.c_erreurs ~= "non") then
        -- selon le mode
        if (donnees.defauts.c_erreurs == "boîte" or (donnees.defauts.c_erreurs == "auto" and donnees.defauts.article == false)) then
            merr = merr .. fnc.box_ouverture("Erreur(s)")
            merr = merr .. fnc.box_texte(donnees.defauts.r_erreurs)
            merr = merr .. fnc.box_fermeture()
        end
    end

    -- terminé, on retourne le tout
    if (donnees.defauts.c_debug) then
        return dg .. tb .. mtitre .. mstitre .. mcat .. mcaterr .. merr
    else
        return tb .. mtitre .. mstitre .. mcat .. mcaterr .. merr
    end
end


-- on retourne le module
return p