Module:Nsm/Recherche

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

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


Le module Nsm/Recherche, est un sous-module du module principal Nsm. Reportez vous à l’aide du modèle {{Nsm}}.

Voir aussi
Projet:Laboratoire/Espaces de noms/Minute technique
Namespace monitor au Labo. d’idées MetaWiki
toollabs:fr-wikiversity-ns
Phab:diffusion/1906

local p            = require("Module:Nsm/Lib")       -- Bibliothèque NameSpace Monitor
local import       = require("Module:Nsm/Table/104") -- Tables ns Recherche 104
local import_talk  = require("Module:Nsm/Table/105") -- 
-- Variables
t_prop        = import.t_prop           -- table des propriétés ns
t_pages       = import.t_pages          -- table des pages
talk_prop     = import_talk.t_prop      -- Discussion propriétés
talk_pages    = import_talk.t_talkpages -- Discussion pages
lang          = t_prop.lang             -- Globale
label         = t_prop.label            -- Label de l'espace de nom
talk_label    = talk_prop.label         -- Label espace discussion
t_root  = ns_root_only(t_pages)   -- table des pages racines 
t_sub   = ns_subpages_only(t_pages)
pfix    = prefix(lang, label)     -- Prefix des titres
r_pages = split_redir(t_pages, '-r')    -- table des pages sans redirection ATTENTION local/global


-- Sous-fonctions
--[[
function compte(t)       -- LIB ORGANISER ! 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 rch_interface() -- Sous-fonction compile les trois tables, des pages d'interfaces (sans sous-page), FILTRER LES REDIRECTIONS, VERIFIER SOMME 
	local interfaces = dptr('', 'table')  -- Initialise avec interfaces département
	local lab        = p.page_in('Laboratoire de recherche')   -- Ajoute lab
	local projet     = p.page_in('Projets collaboratifs')      -- Ajoute projets
	for k, v in pairs(lab) do interfaces[k]    = lab[k] end    -- ajoute lab 
	for k, v in pairs(projet) do interfaces[k] = projet[k] end -- ajoute projet
	return interfaces 
end

function rch_indexed(subpages) --Liste les doc indexés, l'option 'subpages' ajoute les sous-pages.
	local indexed = p.docr_in_dptr('table') --p.docr_ref('table') -- p.docr_ref('table') -- initialise indexed avec doc dptr --format_ns_t(...)
	local lab  = p.labo('table')         -- laboratoires
	local projet = p.doc_projet('table') -- projets
	for k, v in pairs(lab) do indexed[k] = lab[k] end       -- ajoute doc lab  
	for k, v in pairs(projet) do indexed[k] = projet[k] end -- ajoute doc projet
	if subpages == 'subpages' then indexed = add_subpages(r_pages, indexed) end -- ajoute subpage
	return indexed
end
function format_ns_t(liste) -- LIB AJOUTER ?
	liste = unique_v(liste) -- verifie l'absence de doublons
	t = list_to_nstable(liste, r_pages) -- convertit la liste au format ns-t
	return t
end

-- Fonctions
function p.dptr(frame) -- Retourne la liste des départements ; 'all' pour ajouter les sous-pages.
	local r = dptr()
	if frame.args[1] == 'all' then r = dptr('all') end
	col = {'page', 'nsep'}
	return r
end
function dptr(opt, sortie) -- Imprime ou retourne la table des départements de recherche. 'all' permet d'nclure les sous-pages d'interface.
	local result   = {}
	local filtre   = prefix(lang, label, 'Département:') 
	local dptr_sub = ns_pages(t_pages, filtre) --r_pages ne fonctionne pas !
	local dptr     = ns_root_only(dptr_sub)
	if opt == 'all' then result = dptr_sub else result = dptr end
	col = {'page', 'nsep'}
	if sortie == 'table' then return result else return st_print(result, col, '-i') end
end

function unref()-- Compare la table des documents de recherche et celle des documents indéxés, retourne la liste des documents non indexés.
	local t = {}
	local base = p.rch_documents(frame, 'table')
	local indexed = rch_indexed('subpages')
	for k, v in pairs(base) do 
		local finded = false
		for ki, ref in pairs(indexed) do
			if v.page == ref.page then finded = true end end
		if finded == false then t[k] = base[k] end end
	return t
end

function p.non_indexed(frame) -- Retourne unref, unref in cat ou unaffected
	local t = {}
	local unref = unref()
	local incat = unref_filtre('in')
	local unaff = unref_filtre()
	if frame.args[1] == nil then t = unref end
	if frame.args[1] == 'incat' then t = incat end
	if frame.args[1] == 'unaffected' then t = unaff end
	local col = {'index', 'page', 'nsep', 'cible'}
	if frame.args['sortie'] == 'nombre' then return compte(t) else return st_print(t, col, '-i') end end

function unref_filtre(opt) --[[ RENOMMER ORGANISER Filtre les documents non indexés mais catégorisés dans la tables incat ( opt ='in'), les autres dans la tabel unaffected ; retourne la table unaffected par defaut]]--
	local unref = unref()
	local cated = p.rch_categorised('table') 
	local incat = {}
	local unaffected = {}
	local t = {}
	for k, v in pairs(unref) do
		local finded = false
		for k2, v2 in pairs(cated) do
			if v.page == v2.page then finded = true end	end
		if finded == false then unaffected[k] = unref[k] else incat[k] = unref[k] end end
	if opt == 'in' then t = incat else t = unaffected end
	return t 
end

--VERIFIER Projet:Laboratoire/Espaces de noms/Recherche/Index projets collaboratifs
function p.doc_projet(sortie) -- Retourne ou imprime la liste recursive des articles dans la catégorie "Projets collaboratifs"
	local docrp = doc_projet()
	docrp = format_ns_t(docrp) --supprime les doublons convertit au format ns_t
	docrp = no_interface_page(docrp)
	local col = {'page', 'nsep'}
	if sortie == 'table' then return docrp else return st_print(docrp, col, '-i') end
end
function doc_projet() -- Construit la liste recursive des articles dans la catégorie "Projets collaboratifs"
	local initial_list = {"fr:Catégorie:Projets collaboratifs", }
	local subcats = {}
	local subcats = ns_r_subcats(initial_list, subcats)
	local articles = ns_r_articles(subcats)
	return articles
end
function no_interface_page(dp) --Sous-fonction Rch - Reçoit la table des documents dans la catégorie projets collaboratifs. Supprime les pages d'interface projet. Retourne une table
	local ip = p.page_in('Projets collaboratifs') --table pages interface
	local r = {} -- table pour filtrer les documents sans pages d'interface
	for kd, doc in pairs(dp) do
		finded = false
		for ki, interface in pairs(ip) do 
			if doc.page == interface.page then finded = true end end
		if finded == false then r[kd] = dp[kd] end end
		local col = {'index', 'page', 'nsep'} --, 'nsep', 'cible'}
	return r
end

function p.rch_categorised(sortie) --Liste des documents de recherche dans la catégorie : Recherches par facultés via ns_r_subcats et ns_r_articles. Voir Projet:Laboratoire/Espaces de noms/Recherche/Catégorisé
	local cat_name = {"fr:Catégorie:Recherches par facultés", } -- NOM PWB
	local rlist = {} -- Liste pour subcats
	local rlist = ns_r_subcats(cat_name, rlist) -- Récupère les sous-catégories
	local articles = ns_r_articles(rlist) -- cherche les articles dans les subcats
	articles = format_ns_t(articles)      -- convertit au format ns_t 
	local col = {'page', 'nsep'}
	if sortie == 'table' then return articles else return st_print(articles, col) end
end
function p.interface(frame, sortie) -- Liste les pages d'interface. COMMENTER ajouter frame='all' pour la somme des trois tables. Verifier l'impact des redirections et la somme des trois listes. Voir Projet:Laboratoire/Espaces de noms/Recherche/Liste des départements de recherche
	local dptr   = dptr('', 'table') -- REVISé show=subpages remplace 'all'
	local lab    = p.page_in('Laboratoire de recherche') -- articles
	local projet = p.page_in('Projets collaboratifs')    -- articles
	local col = {'page', 'nsep', 'cible'} -- Déclare les colonnes à afficher
	if frame.args[1] == 'dptr'   then t = dptr end
	if frame.args[1] == 'lab'    then t = lab end
	if frame.args[1] == 'projet' then t = projet end
	if frame.args[1] == nil then t = rch_interface()end
	if frame.args['show'] == 'subpages' then t = add_subpages(r_pages, t) end
	if frame.args['sortie'] == 'nombre' then return compte(t) end
	if frame.args['sortie'] == 'table' then return t end
	if frame.args['sortie'] == nil then return st_print(t, col, '-i') end
	return st_print(t, col, '-i')
end
function p.index(frame) -- Données sur les documents de recherche indexés. Liste tous les documents indexés. Les arguments dptr, labo et projet permet de filtrer en fonction du type d'index. L'argument sortie = 'nombre' retourne le nombre des pages.
	local dptr   = p.docr_in_dptr('table') --p.docr_ref('table')--format_ns_t(...)
	local lab    = p.labo('table')
	local projet = p.doc_projet('table') 
	if frame.args[1] == 'dptr' then t = dptr end
	if frame.args[1] == 'lab' then t = lab end
	if frame.args[1] == 'projet' then t = projet end
	if frame.args[1] == nil then t = rch_indexed() end -- Par defaut liste tous les documents indexés
	if frame.args['show'] == 'subpages' then t = add_subpages(r_pages, t) 
	end
	local col = {'page', 'nsep', 'cible'}
	if frame.args['sortie'] == 'nombre' then return compte(t) end -- Fx
	if frame.args['sortie'] == 'table' then return t end
	if frame.args['sortie'] == nil then return st_print(t, col, '-i') end
end

function p.rch_documents(frame, sortie) -- Liste l'ensemble des documents de recherche, en soustrayant les redirections et pages d'interface
	local header = '; rch_documents() : Liste des documents après soustraction des redirections et pages d’interface.\n'
	local documents = {}               -- résultats
	local interfaces = rch_interface() -- pages interface
	for k1, v1 in pairs(r_pages) do    -- r_pages = sans redirection
		local doc = false                                        -- Cherche
		for k2, v2 in pairs(interfaces) do                       -- Compare
			if v1.page == v2.page then doc = true end end        -- Trouve
		if doc == false then documents[k1] = r_pages[k1] end end -- Sinon ajoute
	local col = {'page', 'nsep', 'cible'} 
	if sortie == 'table'  then return documents end
	if frame.args['sortie'] == 'nombre' then return compte(documents) end
	if frame.args['sortie'] == nil then return header .. st_print(documents, col, '-i') end
end

function p.labo(sortie) -- Reçoit la liste des documents de recherche référencés dans les laboratoires de recherche, retourne ou imprime table au format ns_t.
	local t_docr_lab = p.docr_in('lab')--{} -- Une liste simple
	t_docr_lab = unique_v(t_docr_lab)
	t_docr_lab = list_to_nstable(t_docr_lab, r_pages) --convertit ns_t
	local col = {'index','page', 'nsep'}
	if sortie == 'table' then return t_docr_lab else st_print(t_docr_lab, col, '-i') end
end

function p.dptr_vs_fac() --[[Associe Recherche:Département: et Faculté - determine les departements de recherche sans faculté homonyme]]--
	local dptr = dptr('','table') -- ATTENTION obligé placer argument vide CORRIGER
	local data_set = {}
	local filtre = prefix(lang, label, 'Département:') --concatene le prefixe
	local import_fac = require("Module:Nsm/Table/106")    -- immport table faculté
	local t_fac = import_fac.t_pages      -- table complète
	t_fac = ns_root_only(t_fac)           -- Uniquement les pages racines
    for k, v in pairs(dptr) do --IPAIRS NE FONCTIONNE PAS SEULEMENT PAIRS
	   	data_set[k] = v --?
	   	local cut = string.len(filtre)             -- taille du prefix
	   	local r_dpt_name = string.sub(v.page, cut) -- tronque le nom du dpt
		for kfac, vfac in pairs(t_fac) do          -- itération facultés
			isfac = string.find(vfac.page, r_dpt_name) -- cherche tronqué dans faculté
			if isfac ~= nil then
				v['faculte'] = '[['..vfac.page..']]' end end end 
	colonnes = {'page', 'faculte'}
	return st_print(data_set, colonnes, '-i')
end

-- CATEGORY
function p.articles(frame)         -- REVISER / CORRIGER le couple DEPLACER dans LIB
	local category = frame.args[1] -- convertit l'argument frame en option pour 
	local articles = p.page_in(category) -- la sous-fonction page_in qui appel de nouveau
	local col = {'index', 'page', 'nsep'}  -- articles() avec le frame convertit ???
	return st_print(articles, col, '-i')
end
-- CATEGORY
function p.page_in(category) -- Filtre les articles de la catégorie compris dans l'espace de nom. category_members(category) via articles(category)
	local t = articles(category) -- articles via category_members(category)
	local t_projet = {}          -- table des résultats
	for ka, article in pairs(t) do     -- pour chaque article de la catégorie
		for k, v in pairs(t_pages) do  -- chercher dans l'espace recherche
			if article == v.page then t_projet[k] = t_pages[k] end end end
	return t_projet -- retourner les pages de la cat dans l'espace
end


function p.fac_catr(t_fac, subcats) --Compare les titres des facultés et des catégories de recherche ; place les catégories dans la liste cat_set propre à la faculté ; retourne la table des pages de facultés
	local fac_string = {}           --liste des chaines faculté
	local pfix_fac =  'fr:Faculté:' --Attention import_fac.pfix
	local c = 0
	for k_fac, v_fac in pairs(t_fac) do -- pour chaque faculté
		c = c + 1
		cat_set = {} -- liste des catégories de recherche pour la faculté
		cut = string.len(pfix_fac) + 1        -- taille du prefixe plus un
		faculte = string.sub(v_fac.page, cut) -- tronque le préfixe
		faculte = string.lower(faculte)       -- prefixe minuscule
		v_fac['fac_string'] = faculte
		table.insert(fac_string, faculte)
		for k, v in pairs(subcats) do   -- CHAQUE Sous-catégorie dptr
			test = string.match(v, faculte) -- prefixe dans le label 
			if test ~= nil then             -- de la sous-categorie
				table.insert(cat_set, v)    -- place dans liste cat_set
				end	end
		v_fac['cat_set'] = cat_set  -- place la liste dans la tables pages faculté
	end
	return t_fac  
end

function p.recherche_fac(frame) -- Analyse les catégories de recherche, sans argument retourne la liste des faculté et les catégories de recherche par faculté associées. L'argument 'sans' affiche la liste de catégories de recherches sans faculté reconnue, n'importe quel autre argument pour afficher la liste des catégories de recherche. 
	local subcats = chk_subcat('Recherches par facultés')
	local import_fac = require("Module:Nsm/Table/106")
	local t_fac = import_fac.t_pages
	local t_root_fac = ns_root_only(t_fac) --ns_merge(t_fac, 'root')
	--local c=0
	local output_t = p.fac_catr(t_root_fac, subcats)
	local cat_no_fac = {}
	for k_sub, v_sub in pairs(subcats) do
		local is_fac = false
		for k_fac, v_fac in pairs(output_t) do 
			match_fac = string.match(v_sub, v_fac.fac_string)
			if match_fac ~= nil then is_fac = true end end
		if is_fac == false then table.insert(cat_no_fac, v_sub) end end
	local col = {'index', 'page'}
	if frame.args[1] == nil then 
		col = {'index', 'page', 'fac_string', 'cat_set'}
		header = 'Liste des facultés sans catégorie de recherche\n'
		r = header .. st_print(output_t, col, '-i')
	elseif frame.args[1] == 'sans' then
		header = 'Liste des catégories sans faculté reconnue\n'
		r = header .. st_print(cat_no_fac, col)
	else
		header = 'Liste des catégories de recherche\n'
		r = header .. st_print(subcats, col)
	end
	return r
end

function p.find_articles() --Affiche la présence de la page du dptr dans la catégorie  "Départements de recherche" voir Projet:Laboratoire/Espaces de noms/Recherche/Catégorie
	local t_dptr = dptr('', 'table') --RUSTINE
	local tab = find_cat(t_dptr, lang) -- appel la fonction
	return tab                       -- retourne le tableau
end
function p.find_subcats() --ORGANISER Affiche les départements de recherches et les catégories éponymes avec le nombre recursif d'articles - Projet:Laboratoire/Espaces de noms/Recherche/Catégorie faculté
	pfix = pfix .. 'Département:'
	local dptr = dptr('', 'table') --RUSTINE
	local tab = find_cat(dptr, pfix) -- appel la fonction
	return tab                       -- retourne le tableau
end

function p.chk_cat() -- Cas particulier pour cet espace la fx ne compare pas avec t_root mais avec la table "dptr". Voir librairies
	local dptr = dptr('', 'table') --RUSTINE
	local r = chk_cat('Départements de recherche', dptr) --table dpt recherche
	return r
end
 
-- departement_recherche(|travaux) option pour afficher/masquer la liste des documents 
-- Projet:Laboratoire/Espaces de noms/Recherche/Statistiques
function p.departement_recherche(frame)  -- Liste les documents de recherche
	data_set = {}                 -- par département de recherche
	for k, v in pairs(t_pages) do -- avec le nombre de documents liés
		if v.n_dptr ~= nil then	data_set[k] = t_pages[k] end end
	local col = {'page', 'n_dptr'}
	if frame.args[1] == 'travaux' then table.insert(col, 'l_dptr') end
	return st_print(data_set, col, '-i') -- Imprime un tableau standard
end
function p.docr_in(opt) -- REMPLACE p.docr(opt)
	local data_set, dptr_set, lab_set = {}, {}, {} -- Tous les Travaux de recherche référencés
	for i, v in pairs(r_pages) do -- consulte la table des pages SANS REDIR
		if v.l_dptr ~= nil then 
			for i, docr in pairs(v.l_dptr) do table.insert(dptr_set, docr) end end
		if v.l_lab ~= nil then 
			for i, docr in pairs(v.l_lab)  do table.insert(lab_set, docr) end end
	end
	if opt == 'dptr' then return dptr_set end
	if opt == 'lab'  then return lab_set  end
	data_set = dptr_set
	for k, v in pairs(lab_set) do table.insert(data_set, lab_set) end
	return data_set
end
-- Filtre les doublons et convertit la table au format nsm
function p.docr_in_dptr(sortie)   -- Convertit la liste au format ns_t ; imprime
	local data_set = p.docr_in('dptr')     -- recupère le jeu de données
	local data_set = format_ns_t(data_set) -- filre unique et convertit ns_t
	local colonnes = {'page', 'nsep'}
	if sortie == 'table' then return data_set else return st_print(data_set, colonnes) end
end

--ATTENTION MAJ partiellement désactivé éviter mélanger fx cat et fx sub. Les fx principales index() et interface() gèrent l'ajout des sous-pages pour chaque set de données dans ce module. Voir Projet:Laboratoire/Espaces de noms/Recherche/Résultat
function art_sub_in(cat)
	local t = p.page_in(cat) -- short name for category
	local sub_pages = chk_sub(t, t_pages) -- Cherche subpages
	for ks, vs in pairs(sub_pages) do table.insert(t, vs) end -- Ajoute subp
	return t
end
function p.art_sub_in_cat(frame, sortie) -- Ajoute les sous-pages aux articles filtrés par p.page_in
	local cat = frame.args[1] -- Nom court de la catégorie en argument
	local t = p.page_in(cat)  -- filtre les pages de l'espace dans la cat
	local sub_pages = chk_sub(t, t_pages) -- cherche sous-pages
	for ks, vs in pairs(sub_pages) do table.insert(t, vs) end -- Ajoute sub
	col = {'page', 'nsep'}
	if sortie == 'table' then return t else return st_print(t, col, '-i') end
end


--[[

function p.docr_ref(sortie)  --CORRIGER récupère la liste fournie par la fx docr_in('dptr') retourne une liste sans doublon des documents de recherche référencés dans les dept de recherche
	--local unique = {} -- filtre le resultat dans unique
	local data_set = p.docr_in('dptr')        -- recupère le jeu de données
	local unique = unique_v(data_set)         -- SUPPRIME LES DOUBLONS 
	unique = list_to_nstable(unique, r_pages)
	if sortie == 'table' then
		return unique -- ATTENTION FORMAT
	else
		colonnes = {'index', 'page', 'nsep'} -- ATTENTION 
		local r = st_print(unique, colonnes)
		return  r
	end
end




function p.docr(opt) -- liste les documents de recherche, retourne une liste (avec doublon) des travaux de recherche référencés (indexés) ; l'option permet de préciser la classe de document à analyser, 'dptr' ou 'lab'. Retourne une liste/table simple
	local data_set = {}           -- table pour les travaux de recherche référencés
	for i, v in pairs(r_pages) do -- consulte la table des pages SANS REDIR
		if v.l_doc ~= nil then    -- si liste de documents de recherche 
			if v.class_doc == opt  then         --SELECTIONNE dptr ou lab
				for i, doc in pairs(v.l_doc) do -- consulte la liste des travaux
					table.insert(data_set, doc) end	end --Incrément la liste
			if opt == nil then -- PAS d'OPTION
				for i, doc in pairs(v.l_doc) do -- consulte les listes dptr & labo
					table.insert(data_set, doc) end	end --Incrément la liste
			end end -- Incrément la liste
	return data_set --LISTE
end


]]--

return p