Module:bases

Définition, traduction, prononciation, anagramme et synonyme sur le dictionnaire libre Wiktionnaire.
Sauter à la navigation Sauter à la recherche
Ce module contient des fonctions simples mais très utiles utilisables dans les autres modules.
is_elidable( texte ) 
Renvoie "true" si le mot précédent peut être élidé (devant une voyelle, en français). Le cas du h muet n’est pas pris en compte et doit donc être traité à part.
is_locution( texte ) 
Renvoie "true" si le terme donné est une locution (s'il contient une espace).
ucfirst( texte ) 
Renvoie le texte avec la première lettre mise en majuscule (selon la norme du français).
lcfirst( texte ) 
Renvoie le texte avec la première lettre mise en minuscule (selon la norme du français).
uc( texte ) 
Renvoie le texte en majuscule (selon la norme du français).
lc( texte ) 
Renvoie le texte en minuscule (selon la norme du français).
fait_categorie( texte, clef, [écrite] ) 
Renvoie le texte d'une catégorie nommée texte, avec éventuellement la clé de tri clef. Un troisième paramètre permet d'afficher la catégorie (avec :Catégorie), plutôt que de catégoriser attention Pas d'accent !
fait_categorie_contenu( texte, clef, [écrite] ) 
Comme fait_categorie mais seulement dans une page de contenu : espace principal, annexe ou thésaurus
page_existe(titre) 
teste l’existence d’une page.
tableau_entete(titres) 
crée l'entête d'un tableau wiki triable (avec les titres en paramètre)
tableau_ligne(liste) 
écrit une ligne avec les éléments donnés
tableau_fin() 
termine le tableau
exposant() 
met en exposant comme {{e}}
balise_langue(txt, code) 
balisage correctement un texte en langue étrangère comme {{Lang}}
trim_parametres(args) 
enlève les espaces de part et d'autres d'un tableau de paramètres (args). Renvoie la liste modifiée.
lien_modele(mot, lang, ancre, dif) 
crée un lien comme {{lien m}}

info Documentation du Module:bases : v · d · m · h. Page de tests unitaires : Module:bases/testcases


local b = {}
local locale = mw.language.new('fr')
local currentTitle = mw.title.getCurrentTitle()

-- Doit-on faire une élision devant ce mot ?
-- NB: cas particuliers non pris en charge (p. ex. haricot)
function b.is_elidable(mot)
    mot = b.lcfirst(mot)
    if (mw.ustring.match( mot, "^h?[aáàâäeéèêëiíìîïoóòôöuúùûüǘǜ]" ) ~= nil) then
        return true
    else
        return false
    end
end

-- S’agit-il d’une locution ?
function b.is_locution(mot)
    if mot==nil then return nil end
    if (mw.ustring.find(mot, ". .") ~= nil) then
        return true
    else
        return false
    end
end

function b.page_existe(titre)
    if titre == nil then return nil end
    -- On crée un objet "mw.title" avec le titre de la page dont on cherche à vérifier l’existence
    return mw.title.new(titre).exists
end

-- Renvoie le texte avec la première lettre en majuscule (si le texte est en français)
function b.ucfirst(texte)
    if (texte == nil) then return texte end
    return (mw.ustring.gsub(texte, "^([’ǂǃǀǁ]*.)", b.uc)) -- parenthèses nécessaires
end
-- Renvoie le texte avec la première lettre en minuscule (si le texte est en français)
function b.lcfirst(texte)
    if (texte == nil) then return texte end
    return locale:lcfirst(texte)
end
-- Renvoie le texte en majuscule (si le texte est en français)
function b.uc(texte)
    if (texte == nil) then return texte end
    return locale:uc(texte)
end
-- Renvoie le texte en minuscule (si le texte est en français)
function b.lc(texte)
    if (texte == nil) then return texte end
    return locale:lc(texte)
end

-- Renvoie vrai si on est dans une page de contenu (principal, annexe, thésaurus)
function b.page_de_contenu()
    local ns = currentTitle.namespace
	return ns == 0 or ns == 100 or ns == 106 or ns == 110 -- 0 = normal, 100 = Annexe, 106 = Thésaurus, 110 = Reconstruction
end

-- Renvoie vrai si on est dans une page principale
function b.page_principale()
    return currentTitle:inNamespace(0)
end

-- Renvoie une catégorie bien formée
function b.fait_categorie(texte, clef, ecrite)
    local cat = ecrite and ':Catégorie:' or 'Catégorie:'
    
    if (texte ~= nil) then
        if (clef ~= nil and clef ~= '') then
            return '[[' .. cat .. texte .. '|' .. clef .. ']]'
        else
            return '[[' .. cat .. texte .. ']]'
        end
    else
        return ''
    end
end

-- Renvoie une catégorie bien formée, si elle est dans un espace principal, d’annexe ou de thésaurus
function b.fait_categorie_contenu(texte, clef, ecrite)
    if b.page_de_contenu() then
        return b.fait_categorie(texte, clef, ecrite) or ''
    else
        return ''
    end
end

-- Renvoie une catégorie bien formée, si elle est dans un espace principal
function b.fait_categorie_principale(texte, clef, ecrite)
    if b.page_principale() then
        return b.fait_categorie(texte, clef, ecrite) or ''
    else
        return ''
    end
end

-- Crée l’entête d’un tableau wiki triable (avec les titres en paramètre)
function b.tableau_entete(titres)
    local entete = '{| class="wikitable sortable"\r\n'
    entete = entete .. '|-\r\n!' .. table.concat(titres, ' !! ')
    return entete
end

-- Crée une ligne du tableau wiki
function b.tableau_ligne(elements)
    local ligne = '|-\r\n|' .. table.concat(elements, ' || ')
    return ligne
end

-- Crée la fin d'un tableau
function b.tableau_fin()
    return "|}\r\n"
end

-- Texte en exposant
function b.exposant(txt)
    return '<sup style="font-size:83%;line-height:1">'..txt..'</sup>'
end

-- balise un texte écrit en langue étrangère
function b.balise_langue(txt, code)
	return '<span lang="' .. code .. '" xml:lang="' .. code .. '" class="lang-' .. code .. '">' .. txt .. '</span>'
end

-- Enlève les espaces de part et d'autre de tous les paramètres fournis à arg
function b.trim_parametres(args)
    if args==nil then return nil end
    
    local trim_args = {}
    for k, v in pairs(args) do
        trim_args[k] = mw.text.trim(v)
    end
    return trim_args
end

-- lien
function b.lien_modele(mot, lang, ancre, dif)
	if dif and dif == '' then
		dif = nil
	end

	if mot == currentTitle.prefixedText then
		return b.balise_langue('[[' .. mot .. '|' .. (dif or mot) .. ']]', lang)
	else
		if ancre and ancre ~= '' then
			ancre = lang .. '-' .. ancre
		else
			ancre = lang
		end
		return b.balise_langue('[[' .. mot .. '#' .. ancre .. '|' .. (dif or mot) .. ']]', lang)
	end
end

return b