Aller au contenu

Module:Test

Ajouter des liens
Une page de Wikipédia, l'encyclopédie libre.
Ceci est une version archivée de cette page, en date du 20 mai 2014 à 14:29 et modifiée en dernier par Hexasoft (discuter | contributions). Elle peut contenir des erreurs, des inexactitudes ou des contenus vandalisés non présents dans la version actuelle.

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

Voir : {{Test-module}}

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.

-- Ceci est un module de test.
-- Il fournit une seule fonction, qui affiche ses paramètres non nommés.

local ssm = require "Module:Test/sous-module"

-- la table du module, vide (mais déclarée)
local p = {}

function p.test1(frame)
	require('Module:Coordinates/Test')
	return wikidatacoords()
end

function p.test2(frame)
	return require('module:Coordinates/Test').dec2dms(frame.args[1], frame.args[2], frame.args[3]).d
end

function p._distance(a, b, globe) -- calcule la [[distance orthodromique]] en kilomètres entre deux points du globe
 
	-- a and b must be tables with latitude and longitude
	if not a or not a.latitude or not b or not b.latitude then
		makecat({message= 'please provide latitude and longitude for both end points'})
	end
	if type(a.latitude) ~= 'number' or  type(a.longitude) ~= 'number' or  type(b.latitude) ~= 'number' or type(b.longitude) ~= 'number' then
		return error('bad datatype')
	end
	globe = globe or 'earth'
 
	-- distance angulaire en degrés
	local angle = math.acos(math.sin(a.latitude) * math.sin(b.latitude) + math.cos(a.latitude) * math.cos(b.latitude) * math.cos(b.longitude - a.longitude))
 

	return angle
end
function p.distance(frame)
	local args = frame.args
	return p._distance(
		{latitude = tonumber(args.latitude1), longitude = tonumber(args.longitude1)}, 
		{latitude = tonumber(args.latitude2), longitude = tonumber(args.longitude2)},
		args.globe)
end
function p.test5(frame)
	return require('module:Coordinates/Test').dec2dms(frame.args[1], frame.args[2], frame.args[3]).direction
end

function p.test6(frame)
	return require('module:Coordinates/Test').dec2dms(frame.args[1], frame.args[2], frame.args[3]).dec
end

function p.test7(frame)
	return require('module:Coordinates/Test').displaydms(require('module:Coordinates/Test').dec2dms(frame.args[1], frame.args[2], frame.args[3]))
end

function p.test8(frame)
	return require('module:Coordinates/Test').displaydms({d= 12, m = 23, s = 35, direction = 'N'})
end

function p.othertest(frame)
	return #frame.args()
end

function nill(frame)
	if {} == nil then return "oui" else return "no" end
end
function p.etat_print( frame )
    local titre = mw.title.getCurrentTitle()
    
    if (titre == nil) then
        return "Pas de titre !"
    end

    local tmp = titre.fullText

    -- on récupère le fragment
    local frag = titre.fragment
    if (frag == nil) then
        return tmp .. " Pas printable (1)."
    end
    
    -- partie avec printable ?
    local tst = mw.ustring.find(frag, "printable=yes", 1, true)
    if (tst == nil) then
        return tmp .. " Pas printable (2)."
    else
        return "Printable."
    end

end



function p.link( frame )
    local page = frame.args.page
    local title = mw.title.new( page )
    return '<a href="' .. title:fullUrl() .. '" itemprop="url">' .. page .. '</a>'
end

function p.ouvre_boite(titre)
    local res
    res = '<div class="fr-collapsible fr-collapsed"><h2 style="font-size:1.1em; border:0; padding-top:0.3em; padding-bottom:0.3em; margin-top:0.6em; margin-bottom:0.2em; float:none;" class="fr-collapsible-toggle">'
    res = res .. titre .. '</h2>'
    res = res .. '<div class="fr-collapsible-content" style="border:1px solid #aaa; border-radius:5px; margin:0 18px; padding:10px;">'
    return res
end
function p.ferme_boite()
    return '</div></div>\n'
end


-- fonction qui reçoit une table de paramètres et retourne
-- la liste des paramètres non nommés, mise en forme.
function p.formate_parametres(args)
    local res = ""
    -- args est une table, et les paramètres non nommés sont indexés
    -- numériquement à partir de 1
    if (args[1] == nil) then
        return "aucun paramètre."
    end
    
    -- on parcours les paramètres
    local pos = 1
    while (args[pos] ~= nil) do
        local sep
        
        if (pos == 1) then
            sep = ""
        elseif (args[pos+1] == nil) then
            sep = " et " -- le dernier
        else
            sep = ", "
        end
        res = res .. sep .. args[pos]
        pos = pos + 1
    end
    res = res .. "."
    
    return res
end

-- la fonction principale (et unique).
-- les fonctions appelables reçoivent 'frame' en paramètre
function p.test(frame)
   
    -- les paramètres
    local pframe = frame:getParent()
    local args = pframe.args
    local margs = frame.args

    local res = "" -- va servir à contenir le texte qu'on retourne
   
    -- texte général
    res = res .. "Bonjour, je suis un [http://fr.wikipedia.org/w/index.php?namespace=828&tagfilter=&title=Sp%C3%A9cial%3AModifications+r%C3%A9centes module].<br/>"
    res = res .. "J'ai reçu du modèle qui m'appelle les paramètres non nommés : " .. p.formate_parametres(margs) .. "<br/>"
    res = res .. "J'ai reçu lors de l'appel du modèle les paramètres non nommés : " .. p.formate_parametres(args) .. "<br/>"
    
    -- on retourne le résultat
    return res
end


-- génère une erreur
function p.erreur(texte)
    return '<span class="error">' .. (texte or "''aucune erreur indiquée''") .. "</span>"
end


-- découpe un nombre, sans virgule (une séquence de chiffres sans interuption)
-- au format "français" (espace tous les 3 digits).
-- le découpage se fait à partir de la gauche : 1234 → 1 234
function p.decoupe_nombre(nombre, separateur)

    -- validation
    if (nombre == nil or nombre == "" or type(nombre) ~= "string") then
        return ""
    end
    if (separateur == nil) then
        separateur = "&#160;" -- séparateur par défaut
    end

    local res = ""  -- resultat en cours de construction
    local i = -1 -- boucle de parcours
    while(true) do
        local tmp = string.sub(nombre, i-2, i)
        if (tmp ~= nil and tmp ~= "") then
            if (i < -1) then
                res = separateur .. res
            end
            res = tmp .. res
        end
        if (string.len(tmp) < 3) then
            break
        end
        i = i - 3
    end
    return res -- on retourne le résultat    
end

-- fonction qui retourne prend un nombre (codé dans une chaîne) et retourne
-- ce même nombre en enlevant les 0 inutiles à gauche ou à droite (selon paramètre "cote")
-- préserve un éventuel signe devant
function p.enleve_zeros(nombre, cote)
    -- validation
    if (nombre == nil or nombre == "" or type(nombre) ~= "string") then
        return ""
    end
    -- cas de 0 tout seul → a celui qui reçoit le résultat de gérer
    -- coté ?
    if (cote ~= "droite") then
        cote = "gauche" -- si autre chose que "droite" → par défaut
    end

    if (cote == "droite") then
        local pos = string.find(nombre, "0+$")
        if (pos == nil) then
            return nombre
        else
            return string.sub(nombre, 1, pos-1)
        end
    else -- pas touche aux parenthèses ici : elles ont un sens
        return ( string.gsub(nombre, "^([+-]?)0*([0-9]*)$", "%1%2") )
    end
end

-- reçoit un nombre (partie décimale) dans une chaîne et
-- applique l'arrondi au nombre de digits indiqué, avec le mode
-- indiqué dans "mode" :
--  inf : arrondi à l'inférieur
--  sup : arrondi au supérieur
--  autre (toute autre valeur) : arrondi au plus proche
function p.arrondi(nombre, arrondi, mode)
    -- validation
    if (nombre == nil or nombre == "" or type(nombre) ~= "string") then
        return ""
    end
    -- a finir
    return nombre
end

-- test : refaire les fonctionnalités de "formatnum" pour fr:
function p.formatnum(frame)
    -- premier paramètre non nommé : le nombre à traiter
    local pframe = frame:getParent()
    local param = pframe.args[1]
    local resultat = ""

    -- gestion des erreurs de paramètre
    if (param == nil) then
        return p.erreur("La fonction ''formatnum'' attend un paramètre.")
    end
    -- nettoyage (espaces avant/après)
    param = string.gsub(string.gsub(param, "^%s*", ""), "%s*$", "")
    local paramn = tonumber(param) or "pas un nombre"
    if (type(paramn) ~= "number") then
        return p.erreur("La fonction ''formatnum'' attend un nombre comme paramètre (\"" .. param .. "\" reçu).")
    end
    
    -- après les vérifications on cherche les paramètres de contrôle de la sortie, qui viennent du *modèle*
    local virgule = frame.args["virgule"] or ","
    local separateur = frame.args["séparateur"] or "&#160;"

    -- option permettant de virer les 0 inutiles à droite et/ou à gauche
    -- valeurs possibles : droite, gauche, tous, aucun
    local zeros = pframe.args["zéros"] or "aucun"
    if (zeros ~= "droite" and zeros ~= "gauche" and zeros ~= "tous" and zeros ~= "aucun") then
        return p.erreur("Le paramètre ''zéros'' ne peut valoir que ''droite'', ''gauche'', ''tous'' ou ''aucun'' (\"" .. zeros .. "\" reçu).")
    end

    -- option permettant de gérer le signe (+/-). valeurs possibles :
    -- toujours : toujours mettre le signe (si positif et non donné il est ajouté)
    -- jamais : ne jamais le mettre (un nombre négatif devient donc positif)
    -- identique (défaut) : garder la notation de la valeur (si + on le laisse, sinon on ne l'ajoute pas)
    -- auto : on laisse le -, on vire le + si présent
    local psigne = pframe.args["signe"] or "identique"
    if (psigne ~= "toujours" and psigne ~= "jamais" and psigne ~= "identique" and psigne ~= "auto") then
        return p.erreur("Le paramètre ''signe'' ne peut valoir que ''toujours'', ''jamais'', ''identique'' ou ''auto'' (\"" .. psigne .. "\" reçu).")
    end

    -- option permettant de fixer la partie décimale à N éléments.
    -- s'il y en a plus le reste est coupé. s'il y en a moins pas de changement
    -- sauf si N est négatif : complété par des 0
    -- Note : le padding se fait après les traitements pour enlever les 0 inutiles.
    local precision = pframe.args["précision"]
    local N = nil
    local pad0 = false
    if (precision ~= nil) then -- vérification que c'est un nombre
        N = tonumber(precision)
        if (N == nil) then
            return p.erreur("Le paramètre ''précision'' attend un nombre (\"" .. precision .. "\" reçu).")
        end
        if (N < 0) then
            pad0 = true
            N = -N
        end
    end

    -- est-ce qu'il y a une partie décimale ? (true → pas de regex)
    local pos = string.find(param, ".", 1, true)

    -- on coupe le nombre en deux parties : avant et après la virgule (nil si vide)
    local entier
    local decimal
    local signe = ""
    if (pos == nil) then
        entier = param
        decimal = nil
    else
        entier = string.match(param, "^([+-]?[0-9]*)[.]")
        decimal = string.match(param, "[.]([0-9]*)$")
    end

    -- on récupère le signe si présent
    local i = string.find(entier, "^[+-]")
    if (i ~= nil) then -- il y en a un
        -- note : + et - sont ASCII. Sinon il faudrait utiliser ustring
        signe = string.sub(entier, 1, 1)
        entier = string.sub(entier, 2, -1)
    end

    -- on traite les cas ".3", "+.3" ou "-.3" en ajoutant un 0
    local tst = string.find(entier, "[0-9]")
    if (tst == nil) then -- pas de chiffre, on met un 0
        entier = entier .. "0"
    else
        -- si demandé (et pas dans le cas réduit à 0) on vire les 0 inutiles
        if (zeros == "gauche" or zeros == "tous") then
            entier = p.enleve_zeros(entier, "gauche")
        end
    end
    -- si partie décimale et demandé on vire les 0 inutiles
    if (decimal ~= nil and decimal ~= "" and (zeros == "droite" or zeros == "tous")) then
        decimal = p.enleve_zeros(decimal, "droite")
    end

    -- on demande le traitement de la partie entière
    rentier = p.decoupe_nombre(entier, separateur)
    
    -- on traite si besoin la précision
    if (N ~= nil) then
        -- spécial : si N=0 on supprime la partie décimale
        if (N == 0) then
            decimal = nil
        else
            -- longueur de la partie décimale
            local lng
            if (decimal == nil or decimal == "") then
                lng = 0
            else
                lng = string.len(decimal)
            end
            -- si plus grand que voulu on coupe
            if (lng > N) then
                decimal = string.sub(decimal, 1, N)
            else
                -- sinon si padding on ajoute les 0
                if (pad0) then
                    decimal = (decimal or "") .. string.rep("0", N-lng)
                end
            end
        end
        -- si on a "créé" du décimal on fixe pos qui indique la présence d'une virgule
        if (decimal ~= nil and decimal ~= "") then
            pos = 1
        end
    end
    
    -- traitements particuliers
    -- ? 0.0 → 0
    -- ? -0 → 0

    -- on fait le résultat
    local rsigne
    -- gestion du signe
    if (psigne == "jamais") then
        rsigne = ""
    elseif (psigne == "toujours") then
        if (signe == "+" or signe == "") then
            rsigne = "+"
        else
            rsigne = "-"
        end
    elseif (psigne == "identique") then
        rsigne = signe
    else -- auto
        if (signe == "+") then
            rsigne = ""
        else
            rsigne = signe
        end
    end
    resultat = rsigne
    if (rentier ~= nil) then
        resultat = resultat .. rentier
    end
    if (pos ~= nil and decimal ~= nil and decimal ~= "") then
        resultat = resultat .. virgule
    end
    if (decimal ~= nil and decimal ~= "") then
        resultat = resultat .. decimal
    end

    return resultat
end

-- tests de fonctionnalités
function p.divers(frame)
    local res = ">>"

    local d = os.date("*t")
    for f, v in pairs(d) do
        res = res .. f .. " = "
        if (type(v) == "string" or type(v) == "number") then
            res = res .. v .. "<br/>\n"
        elseif (type(v) == "boolean") then
            if (d[f]) then
                res = res .. "true" .. "<br/>\n"
            else
                res = res .. "false" .. "<br/>\n"
            end
        else
            res = res .. "???" .. type(v) .. "???<br/>\n"
        end
        
    end
    
    if (mw.title == nil) then
        res = res .. "title toujours nil<br/>\n"
    else
        res = res .. "title existe !<br/>\n"
    end
    
    res = res .. ssm.sousmodule("appel sous-module")

    return res .. "<< <br/>\n" .. mw.text.listToText( { 1, 2, 3, 4, 5 }, '; ', ' or ' )
end

-- retourne le texte après avoir supprimer les espaces, retour ligne... en début et fin de texte.
-- si texte == nil, la fonction retourne nil. 
-- Si le texte est vide ou composé uniquement d'espces, la fonction retourne un texte vide ''.
function p.trim (texte)
    return texte and string.match (texte, '^%s*(.-)%s*$')
end


-- dump a table content, with formating
function p.dump(tbl, name, dec)
    if (tbl == nil or type(tbl) ~= "table") then
        return "Table ''" .. (name or "<nil>") .. "'' is invalid.<br/>"
    end
    -- limit depth
    if (dec > 4) then
        return "''limite de récursion atteinte (4).''"
    end

    local res = ""
    if (name ~= nil) then
        res = res .. "Table ''" .. name .. "'' content:\n"
    end

    -- just check all content, first the functions, then anything but tables, then table
    for k, v in pairs(tbl) do -- functions
        if (type(v) == "function") then
            res = res .. string.rep("*", dec)
            res = res .. k .. " (" .. type(v) .. ")\n"
        end
    end
    for k, v in pairs(tbl) do -- not functions and tables
        if (type(v) ~= "function" and type(v) ~= "table") then
            res = res .. string.rep("*", dec)
            res = res .. k .. " (" .. type(v) .. "): « " .. (tostring(v or "<nil>")) .. " »\n"
        end
    end
    for k, v in pairs(tbl) do -- only tables
        if (type(v) == "table") then
            local ttl = ""
            ttl = ttl .. string.rep("&nbsp;⋅", dec)
            ttl = ttl .. " " .. k .. " (table) − voir le contenu\n"
            res = res .. p.ouvre_boite(ttl)
            res = res .. p.dump(v, nil, dec+1)
            res = res .. p.ferme_boite()
        end
    end
    return "__NOTOC__\n" .. res
end

function p.disponible(frame)
    return p.dump(mw, "mw", 1)
end


-- pour tester la fonctionnalité "pageincategory"
function p.pageincat(frame)
    -- un paramètre, soit en provenance du modèle soit en provenance de la page
    local cat = frame.args[1] or frame:getParent().args[1]
    local arg = frame.args[2] or frame:getParent().args[2]
    local sel
    
    if (cat == nil or cat == "") then
        -- on utilise le titre de la page courante
        cat = mw.title.getCurrentTitle().text
    end

    -- on regarde le paramètre
    if (arg == "all" or arg == nil or arg == "*") then
        sel = "all"
    elseif (arg == "subcats") then
        sel = "subcats"
    elseif (arg == "files") then
        sel = "files"
    elseif (arg == "pages") then
        sel = "pages"
    else
        return p.erreur("paramètre '" .. (arg or "<nil>") .. "' non reconnu")
    end
    
    local res = mw.site.stats.pagesInCategory(cat, sel)
    if (res == nil) then
        return p.erreur("erreur de récupération des informations")
    end
    return tostring(res) .. ' ' .. sel .. ' dans Catégorie:' .. cat
end

function p.contenu_page(frame)
    local t = mw.title.new("Uroplatus")
    if (t == nil) then
        return "échec création title<br/>"
    end
    if (t.id == 0) then
        return "la page spécifiée n'existe pas<br/>"
    end
    
    return frame:preprocess("<pre>" .. t:getContent() .. "</pre><br/>")
end


-- extractArgs permet de récupérer les arguement du modèle, 
-- ou la table transmise à la fonction par une autre fonction d'un module
local function extractArgs( frame, mandatoryArg )
    if type( frame ) == 'table' then
        if type( frame.getParent ) == 'function' then 
            mandatoryArg = mandatoryArg or 1
            if frame.args[mandatoryArg] then
                return frame.args
            else
                return frame.getParent()
            end
        else
            return frame -- renvoie les arguments transmis par invoke et non par le modèle, pour tester avant de créer les modèle.
        end
    else
        return { frame }
    end
end

-- fonction abréviation discrète, abréviation  (discrète par défaut)
-- paramètres : 1 = abréviation, 2 = texte, 3 = langue, visible = abréviation simple
function p.abr( frame )
    local args = extractArgs( frame )
    if args[2] == nil then 
        return args[1] or ''                 -- retoune l'abréviation ou au minimum une chaine vide s'il n'y a pas de texte
    end

    local wikiText = { '<abbr' }
    if not args.visible then
        table.insert( wikiText, ' class="abbr"' )
    end
    table.insert( wikiText, ' title="' )
    table.insert( wikiText, args[2] )
    if args[3] then 
        table.insert( wikiText, '" lang="' )
        table.insert( wikiText, args[3] )
    end
    table.insert( wikiText, '">' )
    table.insert( wikiText, args[1] )
    table.insert( wikiText, '</abbr>' )

    return table.concat( wikiText )
end

-- test de passage de paramètre contenant du tableau
function p.essaimef(frame)
    return frame:preprocess("<nowiki>" .. (frame.args[1] or "<vide>") .. "</nowiki><br/>" .. (frame.args[1] or "<vide>"))
end

-- test : retourne le titre sans la partie homonyme (entre ()) si présente
function p.simpletitle(frame)
	-- on récupère le title
	local titre = mw.title.getCurrentTitle()
	if (titre == nil) then return "" end
	-- le nom de la page
	local page = titre.text
	if (page == nil or type(page) ~= "string" or page == "") then return "" end
	
	-- on enlève la partie entre parenthèses
	local npage = mw.ustring.gsub(page, " [(].*$", "")
	if (npage == nil or npage == "") then return "" end
	
	return npage
end

-- test : retourne CET ou CEST selon la date
function p.cest(frame)
	local t = mw.getContentLanguage():formatDate("I", nil, true)
	if (t == "1") then
		return CEST
	else
		return CET
	end
end
function p.cest2(frame)
	local t1 = os.date("*t")
	local t2 = os.date("!*t")
	local c1, c2
	if (t1.isdst) then c1 = "CEST" else c1 = "CET" end
	if (t2.isdst) then c2 = "CEST" else c2 = "CET" end
	return t1.year .. "/" .. t1.month .. "/" .. t1.day .. " " .. t1.hour .. ":" .. t1.min .. ":" .. t1.sec .. " (" .. c1 .. ") --- " .. t2.year .. "/" .. t2.month .. "/" .. t2.day ..
	        " " .. t2.hour .. ":" .. t2.min .. ":" .. t2.sec .. " (" .. c2 .. ")"
end


-- obligatoire : il faut retourner le "module" (sa table) à la fin
return p
Ce document provient de « https://fr.wikipedia.org/w/index.php?title=Module:Test&oldid=103962893 ».