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

Projet Scribunto

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("règne", donnees.liste_regnes, false, true)  -- le règne
    -- les options permettant de modifier le comportement
    donnees.defauts.c_titre = fnc.lit_parametre("titre", {"oui","non","boîte","auto"}, false, false)
    donnees.defauts.c_sous_titre = fnc.lit_parametre("sous-titre", {"oui","non","auto"}, false, false)
    donnees.defauts.c_erreurs = fnc.lit_parametre("erreurs", {"oui","non","auto"}, false, false)
    donnees.defauts.c_categories = fnc.lit_parametre("catégories", {"en ligne","non","boîte","auto"}, false, false)
    donnees.defauts.c_categories_err = fnc.lit_parametre("catégorie erreurs", {"en ligne","non","boîte","auto"}, false, false)
    donnees.defauts.c_force_titre = fnc.lit_parametre("force titre", nil, false, false)
    -- 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, false)  -- NV, optionnel
    
    -- on regarde si une erreur (ou plusieurs) s'est produite durant la récupération des paramètres
    if (donnees.defauts.fatal) then
        return fnc.erreur_globale(donnees.defauts, donnees.categorie_erreur)    
    end
    
    dg = dg .. "paramètres récupérés.<br/>"
    -- on analyse les paramètres pour générer la liste des commandes présentes
    fnc.tri_parametres(donnees)
    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
    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
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
                tb = tb .. tmpd
dg = dg .. "    - commande traitée<br/>"
            end
        end
        i = i + 1
    end
    
    -- test
    if (fnc.existe("Fichier:Uroplatus guentheri male.jpg")) then
        dg = dg .. "l'image existe<br/>"
    else
        dg = dg .. "l'image n'existe pas<br/>"
    end

    
    -- traitement titre article (mise en forme si nécessaire)
    local mtitre = ""
    if (donnees.defauts.c_titre == "oui" or donnees.defauts.c_titre == "boîte" or (donnees.defauts.c_titre == "auto" and donnees.defauts.article)) then
        -- seulement si titre forcé ou si mode auto et espace article
        
        -- le nom à considérer est donnees.defauts.c_force_titre
    end
    
    -- traitement sous-titre éventuel
    local mstitre = ""
    if (donnees.defauts.c_sous_titre == "oui" or donnees.defauts.c_sous_titre == "boîte" or (donnees.defauts.c_sous_titre == "auto" and donnees.defauts.article)) then
        -- seulement si titre forcé ou si mode auto et espace article
        
        -- le nom à considérer est donnees.defauts.c_force_titre
    end
    
    -- si besoin et selon les modalités on insert les catégories
    local mcat = ""
    mcat = mcat .. fnc.box_ouverture("Catégorie(s)")
    mcat = mcat .. fnc.box_texte(donnees.defauts.r_categories)
    mcat = mcat .. fnc.box_fermeture()
    
    -- si besoin et selon les modalités on insert les catégories d'erreur
    local mcaterr = ""
    mcaterr = mcaterr .. fnc.box_ouverture("Catégorie d'erreur(s)")
    mcaterr = mcaterr .. fnc.box_texte(donnees.defauts.r_err_categories)
    mcaterr = mcaterr .. fnc.box_fermeture()
    
    -- si besoin et selon les modalités on insert les erreurs
    local merr = ""
    merr = merr .. fnc.box_ouverture("Erreur(s)")
    merr = merr .. fnc.box_texte(donnees.defauts.r_erreurs)
    merr = merr .. fnc.box_fermeture()
    
    -- terminé, on retourne le tout
    return dg .. tb .. mtitre .. mstitre .. mcat .. mcaterr .. merr
end


-- on retourne le module
return p