Module:Nsm/Lib/Sub

Une page de Wikiversité.
Sauter à la navigation Sauter à la recherche

Librairie de fonctions pour l’outil wmflabs/fr-wikiversity-ns aussi appelé Namespace monitor. Cette Bibliothèque regroupe les sous-fonctions, communes aux suivi des différents espaces de noms ; elle complète les librairies suivantes :

ns_prop
Affiche la table des propriétés de l’espace de noms.
ns_pages(table, filtre)
Lit la table des pages et affiche son contenu sous forme de tableau triable. L’argument optionnel filtre permet d’indiquer le nom de(s) pages que vous souhaitez afficher.
ns_stat_sub
Calcul les statistiques sur les sous-pages de l’espace de noms.

info Documentation du Module:Nsm/Lib/Sub : v · d · m · h.


--[[Librairie de fonction pour l'analyse des espaces de noms de la wikiversité]]--
function prefix(lang, label, chaine) -- REVISER principal 0... Calcul le prefixe des titres, accèpte une chaine de caractère comme 3ème argument voir dept. de rech.
	local pfix =  lang .. ':'
	--REVISER PROVISOIRE
	--or label ~= 'Principal'
	-- si principal label ne vaut pas nil c'est une chaine vide ''
	if label == '' then pfix = pfix else pfix = pfix .. label .. ':'  end
	if chaine ~= nil then pfix = pfix .. chaine end
	return pfix
end
function prefix_OLD(lang, label, chaine) -- REVISER PASSER nom=motif dans cahine... Calcul le prefixe des titres, accèpte une chaine de caractère comme 3ème argument voir dept. de rech.
	local pfix =  lang .. ':' .. label .. ':'
	if chaine ~= nil then pfix = pfix .. chaine end
	return pfix
end
function redir(ns_t) --, frame, ns_id Nouvelle version étape 4 ; Vérifier ordre des condition (ne pas iterer la table si nombre ou taux). Voir split_redir pour la table des redirections.
	ns_t = split_redir(ns_t)    -- Filtre les pages de redirection
	return ns_t
end
function redir_tx(t_prop) -- sous-fonction pour calcul du taux de redirection
	local n = t_prop.redirection
	local d = t_prop.total - n
	local tx = n/d*100 
	local r = tx .. ' % ' -- Limiter affichage 2 decimales
	return r
end
function split_redir(t, o) --reçoit une table retourne les pages de re-directions ; le paramètre o = '-r' retourne la liste des pages à l'exception des redirections
	local redir, no_redir = {}, {} 
	for k, v in pairs(t) do
		if v.cible == nil then no_redir[k] = t[k]
		else
			redir[k] = t[k]
		end
	end
	if o == '-r' then return no_redir else return redir end
end
function pages(ns_t, motif) -- La fonction reçoit une table au format namespace monitor et un motif pour le nom des pages à filtrer 
	if motif ~= nil then ns_t = filtre(ns_t, motif) end -- ajoute le prefixe au filtre
	return ns_t
end
-- la fonction est difficile à désactiver il faut réusir à simplifier (voir modules recherche)
function ns_pages(t, filtre) -- attend la table des pages et un filtre optionnel
	local data_set = {}      -- tables des résultats
	for k, v in pairs(t) do  -- itération de la table en entrée avec PAIRS
		if filtre ~= nil then -- si filtre 
			match_filtre = mw.ustring.match(v.page, filtre) --USTRING test match filtre/v.page
			if match_filtre ~= nil then -- Si match
				data_set[k] = v         -- implémente le set de données
	    		end
		else data_set[k] = v end end    -- Pas de filtre implémente tout
	return data_set -- retourne une table
end


-- Une fonction pour filtrer les titres de pages dans la table en entrée
-- COMMENT la fonction p.doc() utilise filtre() ; corriger la fonction pages() et déployer le filtrage sur les autres fonctions AJOUTER liste inverse et nombre de pages
function filtre(it, motif)   -- it désigne la table en entrée, motif désigne l'argument utilisateur
	motif = prefix(lang, label, motif) -- ajoute le prefixe Python
	local to = {}            -- to désigne la table en sortie (table output)
	for k, v in pairs(it) do -- itéreation de la table en entrée
		test = mw.ustring.match(v.page, motif) --USTRING test match filtre/v.page
		if test ~= nil then  -- Si le test n'est pas nul, match
			to[k] = v        -- implémente la table en sortie
		end	end
    return to -- Retourne la table filtrée
end

-- A SUIVRE une fonction pour extraire la valeur Lua baseTexte à partir de la chaine Python
function nsm_base_text(page) -- A documenter !
	local base_text = mw.ustring.match(page, '.*/')
	return base_text
end

function split_nsep(t) -- Scinde la table des titres par nombre de séparateurs, retourne une table t_niv avec k=nsep et v=ts{titre, nsep} - (sous-fx de sort_nsep)
	--local table_tri = require("Module:Lib table tri") --spairs VERIFIER SI NECESSAIRE ??
	local t_niv = {} -- l'index auto désigne nsep et contient une table de noms
	local ts = {}    -- table reduite pour le tri
	for k, v in pairs(t) do ts[v.page] = v.nsep end --table titre/nombre de séparateur
	for k, v in pairs(ts) do --spairs VERIFIER SI NECESSAIRE ?? TEST SANS
		if t_niv[v] == nil then -- si pas de table 
			t_niv[v] = {}       -- créer la table
			table.insert(t_niv[v], k) -- insère titre comme valeur
		else -- donc la table existe
			table.insert(t_niv[v], k) -- insère titre comme valeur
		end	end
	return t_niv
end
function merge_nsep(t_niv, opt) -- Regroupe les titres par prefixe, par défaut montre les sous-pages "orphelines" de la table.
	-- opt = all : ajoute les pages racines au résultat
	local table_tri = require("Module:Lib table tri")
	local result = {}
	for niv, t_title in pairsByKeys(t_niv, function(a, b) return b < a end) do
	--table.sort(t_niv, function(a, b) return b < a end) -- Provoque tri de v
	--for niv, t_title in pairs(t_niv) do                -- qui contient des tables
		-- itération selon k ordre decroissant avec k not index auto
		for ia, title in pairs(t_title) do  --Boucle par Niveau = table
			if t_niv[niv-1] ~= nil then -- vérifie si existe table au niveau suivant
				is_sub = false  -- initialise test sous-page
				for ia_n, title_n in pairs(t_niv[niv - 1]) do -- Cherche niveau sup.
					local s = title .. '/' -- construit patern avec separateur et compare les titres à partir du début 0
					if string.match(s, title_n, 0)~= nil  then is_sub = true end
				end -- mw.ustring error
				if is_sub == false then	table.insert(result, title)	end  -- Ajoute dans table des resultats
			else  -- pas de table au niveau suivant
				if opt == 'all' then table.insert(result, title) end -- Ajoute dans table des resultats si l'option all est active
			end end end
	return result
end
function merge_nsep_(t_niv, opt) -- Regroupe les titres par prefixe, par défaut montre les sous-pages "orphelines" de la table.
	-- opt = all : ajoute les pages racines au résultat
	--local table_tri = require("Module:Lib table tri")
	local result = {}
	local r = '' -- DEBUG
 	local init = 0  --mw.ustring
	-- itération selon k ordre decroissant avec k not index auto
	--for niv, t_title in pairsByKeys(t_niv, function(a, b) return b < a end) do
	for niv, t_title in pairs(t_niv, function(a, b) return b < a end) do
		--r = r..'*'..niv..tostring(t_title)..'\n'
		for ia, title in pairs(t_title) do  --Boucle par Niveau = table
			--r = r ..': '..ia..title..'\n'
 			--sc_title = scribunto_title(title, lang)
 			base_text = nsm_base_text(title) --sc_title.baseText 
			--r = r ..'::'..tostring(base_text).. tostring(init)..'\n'
			if t_niv[niv-1] ~= nil then     -- vérifie si existe table au niveau suivant
				is_sub = false              -- initialise test sous-page
				for ia_n, title_n in pairs(t_niv[niv - 1]) do -- Cherche niveau sup.
					if title_n == base_text then --mw.ustring.match(title_n, base_text, init)
						is_sub = true
						--ia = ia + 1
						end end
				if is_sub == false then	table.insert(result, title)	end  -- Ajoute dans table des resultats
			else  -- pas de table au niveau suivant
				if opt == 'all' then table.insert(result, title) end -- Ajoute dans table des resultats si l'option all est active
			end end end
	return result -- r --
end

function group(t_pages, t_sub, frame, label) -- Affiche uniquement les groupes de pages qui contiennent des sous-pages ; groupes racine et groupes isolés. 
	local r = '; group() : Affiche uniquement les groupes de pages à la racine.\n'
	local t_group = sub_lost(t_pages, 'all') -- Calcul groupes isolés + racines (all) 
	t = ns_find_subpages(t_group, t_sub)     -- Calcul nombre de sous-pages
	local t_group = {}                       -- résultats
	local col = {'page', 'nsep', 'nsub'}     -- Colonnes à afficher
	for k, v in pairs(t) do if v.nsub ~= nil and v.nsub > 0 then t_group[k] = t[k] end 
	end  -- Filtre les groupes contenant au moins une sous-page 
	r = r .. st_print(t_group, col, '-i')    -- imprime le tableau
	--r = r .. t_foot(frame, label) -- Ajoute le pied de page
	return r
end

function ns_find_subpages(t_root, t_sub) --cherche les sous pages de la ns_table from dans la ns_table 'to' ; ajoute les paramètres subpages et nsub et retourne la table 'from'
	local r = ''  --DEBUG
	--to = ns_subpages_only(to)    --FILTRER SUBPAGES AVANT d'entrer dans la fx
	for k1, v1 in pairs(t_root) do   -- Itération de la table racine
		--r = r ..'* '..k1.. tostring(v1.page)..'\n'
		local subpages = {}        -- Table pour les résultats
		local motif = v1.page..'/' --prefixe des sous-pages
		for k2, v2 in pairs(t_sub) do -- Itération table sous-pages
			--r = r ..'* '.. tostring(v2.page)..'\n'
			test = mw.ustring.match(v2.page, motif) -- ATTENTION BUG MODèLES Unclosed capture beginning at pattern character 11
			if test ~= nil then -- Comparaison MW.USTRING
				-- r=r..v2.page..', ' --DEBUG
				table.insert(subpages, v2.page) end      -- Ajoute dans résultats
		end
		local nsub = table.maxn(subpages)
		v1['nsub'] = nsub         -- RENOMMER n_sub(pages)
		v1['subpages'] = subpages -- RENOMMER l_sub
	end
	return t_root --r --
end


function compte(t)       -- Compte occurrences de la table
	local compteur = 0   -- Utile lorsque table.maxn retourne total de la table
	for k, v in pairs(t) do compteur = compteur + 1 end -- itération du set
	return compteur      -- retourne nbre d'ccurences dans le set de données
end

function scribunto_title(pywikibot_page, lang) -- Convertit page pywikibot en titre scribunto. Tronque langue et separateur
	local title = mw.ustring.sub(pywikibot_page, (mw.ustring.len(lang) +1 )) 
	title = mw.title.new(title) -- Construit table Lua
	return title -- Retourne objet titre Lua Scribunto
end


function racine(root_pages, sub_pages, frame) -- Frame/label ?
	local t = root_pages
	local col = {'page', 'nsep'} --, 'nsub'
	local result = '; racine() : Liste les pages racines et affiche le nombre de sous-pages (nsub). \n'
	if frame.args['col'] == 'nsub' then 
		t = ns_find_subpages(root_pages, sub_pages) -- nombre sous-pages dans nsub
		table.insert(col,'nsub') end
	result = result .. st_print(t, col, '-i')
	--result = result .. t_foot(frame, label)
	return result
end
--[[
function racine_old(ns_t, frame, label) --COMMENTER NOUVELLE VERSION !
	local root_page = ns_root_only(ns_t) 
	local result = '; racine() : Liste les pages racines et affiche le nombre de sous-pages (nsub). \n'
	local t = ns_find_subpages(root_page, ns_t) -- nombre sous-pages dans nsub
	local col = {'page', 'nsep', 'nsub'}
	result = result .. st_print(t, col, '-i')
	result = result .. t_foot(frame, label)
	return result
end
]]--

function list_to_nstable(simple_table, ns_table) --reçoit une liste simple et une table au format t_pages retourne, compare les titres et retourne la liste au format ns_table
	local r = {}
	for i, page in pairs(simple_table) do
		for k, v in pairs(ns_table) do 
			if v.page == page then r[k] = ns_table[k] end end end
	return r
end

function unique_v(liste) --[[ A suivre importé depuis rch - Supprime les doublons de la valeur (v) dans une table simple (k,v) ]]--
	local unique = {}   -- filtre le resultat dans unique
	table.sort(liste)   -- tri sur nom des documents
	for k, v in pairs(liste) do --PAIRS
		local inside = false         -- Pas cherché
		for ku , vu in pairs(unique) do -- Cherche
			if vu == v then inside = true end end --Trouvé
		if inside == false then table.insert(unique, v) end end 
	return unique
end

function ns_root_only(t) --filtre les pages racines d'une table au format t_pages sur la base de la valeur nsep ; retourne les pages racines
	local r = {}
	for k, v in pairs(t) do	if v.nsep == 0 then r[k] = t[k] end end 
	return r
end
function ns_subpages_only(t) --filtre les pages racines d'une table au format t_pages sur la base de la valeur nsep ; retourne les sous-pages
	local r = {}
	for k, v in pairs(t) do if v.nsep > 0 then r[k] = t[k] end end 
	return r
end

--[[
function ns_find_subpages_old(from, to) --cherche les sous pages de la ns_table from dans la ns_table 'to' ; ajoute les paramètres subpages et nsub et retourne la table 'from'
	--local cumul = 0
	to = ns_subpages_only(to) --FILTRER SUBPAGES AVANT DE COMPARER
	for k1, v1 in pairs(from) do -- Itération de la table initiale
		local subpages = {}      -- Table pour les sous-pages
		local motif = v1.page..'/' --prefixe des sous-pages
		for k2, v2 in pairs(to) do
			if mw.ustring.match(v2.page, motif) ~= nil then -- MW.USTRING
				table.insert(subpages, v2.page) end end
		local nsub = table.maxn(subpages)
		v1['nsub'] = nsub         -- RENOMMER n_sub(pages)
		v1['subpages'] = subpages -- RENOMMER l_sub
	end
	return from
end
]]--

--COMPARER avec ns_find_subpages
function chk_sub(t_mysub, t_pages) --[[RENOMMER GET_SUB reçoit une table filtrée au format t_pages, cherche les sous-pages dans la table principale et retourne la tables des sous-pages ]]--
	sub_pages = {} 
	for kp, mypage in pairs(t_mysub) do --compare la table reçue
		local patern = mypage.page .. '/'
		for k, v in pairs(t_pages) do   -- à la table principale
			if mw.ustring.match(v.page, patern) ~= nil then sub_pages[k] = t_pages[k] end
		end --copie les sous-pages de la 1ere table contenues dans la seconde
	end
	return sub_pages -- retourne les sous-page dans une troisieme table
end
function add_subpages(from_all, to_set) --Ajoute les sous pages via la fx chk_sub.
	local subt = chk_sub(to_set, from_all)  -- Filtre les sous-pages 
	for k, v in pairs(subt) do to_set[k] = subt[k] end --copie dans la table destination
	return to_set
end
function sub_lost(ns_t, opt) --[[Retourne la liste des sous-pages isolées. opt='all' indique à merge_split d'afficher également les pages racine]]--
	local t_niv = split_nsep(ns_t)   --place les titres dans des tables par niveaux
	local result = merge_nsep(t_niv, opt) --compare les titre et retourne les pages isolées
	result = list_to_nstable(result, ns_t)  -- convertit au format ns_tableTEST
	return result  --retrourne une table à imprimer dans chaque module via p.sub_lost
end



--CATEGORY FUNCTIONS

function lnk(var)     -- Test si la variable correspond à une page de catégorie
	local prefix = lang .. ':Catégorie:'  --CALCULER LE PREFIX LOCAL POUR NS_ID 14
	-- Test pour fichier, modèle
	local len_prefix = mw.ustring.len(prefix)
	local lnk = ''
	if mw.ustring.sub(var, 0, len_prefix) == lang..':Catégorie:' then --lang GLOBAL
		lnk = '[[:' .. var .. ']]' -- Ajoute ':' pour lier une catégorie
	else
		lnk = '[[' .. var .. ']]'  -- lien classique
	end
	return lnk
end
function lastrev(frame, ns_id) --NEW VER.
	local data_module = table_module(ns_id)
	local lastrev = frame:preprocess('{{#time: d M Y | {{REVISIONTIMESTAMP:'..data_module..'}} }}')
	--local lastrev = frame:preprocess( '{{REVISIONTIMESTAMP:'..data_module..'}}' )
	return lastrev
end
function t_foot(frame, ns_id)--Affiche la date de dernière MODIFICATION de la table de données RENOMMER FOOTER--
	local footer = '<small>Dernière modification de la table de données : ' .. lastrev(frame, ns_id) ..'</small>'
	return footer
end
function table_module(ns_id)
	local table_module = "Module:Nsm/Table/"..tostring(ns_id)
	return table_module
end


--[[
function lastrev_old(frame, label) --la fonction à besoin du frame et du label, elle retourne la date de dernière mise à jour de la table des données module:ns_label.
	local lastrev = frame:preprocess( '{{REVISIONTIMESTAMP:Module:Ns '..label..'}}' )
	return lastrev
end

function t_foot_old(frame, label) --Affiche la date de dernière MODIFICATION de la table de données RENOMMER FOOTER
	local foot = '<small>Dernière modification de la table de données : ' .. lastrev(frame, label) ..'</small>'
	return foot
end
]]--

function ns_prop(t) --[[Attend la table des propriétés à afficher (nombre de pages, de redir, de sous-pages, label ]]--
	local r = 'Espace de noms: ' .. t.id .. ' : ' .. t.label .. '\n'
	r = r .. ': Nombre total de pages: ' .. t.total .. ' ; pages racines: ' .. t.racine .. ', sous-pages :' .. t.sous_page  .. '\n'
	r = r .. ': Nombre de redirections: ' .. t.redirection .. '\n' 
	return r
end

function ns_stat_sub(t) --[[Statistiques sur le nombre de sous-page à chaque niveau.]]--
	--local t_merged = ns_merge(t)  -- Scinde racine/sous-page
	local root_page = ns_root_only(t)    -- table des pages racine --t_merged[1]
	local sub_page = ns_subpages_only(t) -- table des sous-pages   --t_merged[2]
	local nsub_set = {}           -- initialise table de séparateurs
	local prop_sub = {}			  -- initialise table de statistiques
	local count = 0               -- compteur de sous-pages
	--[[chaque sous-pages du tuple copiée dans un set ; tri]]-- 
	for sp, nsub in pairs(sub_page) do table.insert(nsub_set, nsub.nsep) end
	table.sort(nsub_set)
	for i, v in ipairs(nsub_set) do
		if i == 1 then  -- IF ONLY ONE PAGE INTO ?
			count = count+1
		else
			u = nsub_set[i-1]
			if v == nsub_set[i-1] then
				count = count +1
			else
				prop_sub[u] = count -- niveau/nombre de sous-pages
				count = 1
			end end end
	maxnsub=table.maxn(nsub_set)   -- 
	last_nsub = nsub_set[maxnsub]
	prop_sub[last_nsub] = count    --
	local r = ';Nombre de sous-pages:\n'
	for u, count in pairs(prop_sub) do
		r = r.. '* Niveau -' .. u .. ' : ' .. count .. '\n' end
	return r
end


--[[
function group_old(ns_t, frame, label) -- Nouvelle version étape 3 
	local r = '; group() : Affiche uniquement les groupes de pages à la racine.\n'
	local t = sub_lost(ns_t, 'all')      -- lost + racines (all)
	t = ns_find_subpages(t, ns_t)        -- nombre de sous-pages
	local t_group = {}                   -- résultats
	local col = {'page', 'nsep', 'nsub'} --Colonnes à afficher
	for k, v in pairs(t) do              -- Filtre les groupes
		if v.nsub ~= nil and v.nsub > 0 then t_group[k] = t[k] end 
	end
	r = r .. st_print(t_group, col, '-i') -- imprime le tableau
	r = r .. t_foot(frame, label)         -- Ajoute le piede de page
	return r
end
function ns_groupe_old(t) --Reçoit une table de pages et retourne un jeu de trois tables dont celle des groupes. SIMPLIFIER avec ns_find_subpages, ns_split et/ou ns_merge (processus inverse) en vérifiant l'absence de sous-page orpheline...
	--local t_merged = ns_merge(t)  -- Sous fonction DESACTIVE
	local root_page = ns_root_only(t) --t_merged[1] -- racines DESACTIVE t_merge()
    local sub_page = ns_subpages_only(t) --t_merged[2]  --sous-pages DESACTIVE t_merge()
    local group_page = {}         -- uniquement les groupes
    local count_page = 0          -- compteur de pages racines
    for i, v in pairs(root_page) do -- itération des pages racines
    	count_page = count_page +1
    	local pattern = v.page ..'/' -- determine le prefixe
    	local count_sub = 0          -- compteur de sous-pages par groupe
    	for i, v in pairs(sub_page) do  -- pour chaque sous-page
    		mysub = mw.ustring.match(v.page, pattern) -- comparaison prefixe racine et sous-pages
    		if mysub ~= nil then              -- si le prefixe correspond (not false)
    			count_sub = count_sub +1      -- incrémente le compteur page suivante
			end end
		v.n_sub = count_sub
		root_page[i] = v
		if count_sub > 0 then group_page[i] = v end
    end
	t_grouped = {root_page, sub_page, group_page}
	return t_grouped 
end
]]--