Wikipedia

Modulo:Interprogetto/sandbox: differenze tra le versioni

Naviga nella cronologia in modo interattivo
← Differenza precedente
Contenuto cancellato Contenuto aggiunto
Moroboshi (discussione | contributi)
75 152 modifiche
Nessun oggetto della modifica
use require('strict') instead of require('Module:No globals')
 
(69 versioni intermedie di 3 utenti non mostrate)
Riga 1:
-- Modulo per implementare le funzionalità di template:Interprogetto
require('Module:No globalsstrict')
local p = {} -- per l'esportazione delle funzioni del modulo
 
local cfg = {}
local cfg = mw.loadData( 'Modulo:Interprogetto/Configurazione' );
local root = mw.html.create('') -- radice del markup html
local debug = {} -- per debug
local categories = {} -- categorie di errore da aggiungere
local errors_msg = {} -- messaggi di errore da aggiungere
 
-- per non usare numeri "magici" nel codice
local function dump(t, ...)
local argscategory_namespace_number = {...}14
 
for _, s in ipairs(args) do
-- ============================================================================================================
table.insert(t, s)
-- Ritorna la stringa se è definita e diversa da stringa vuota, altrimenti nil
end
-- ============================================================================================================
local function is_defined(s)
if s and s ~= '' then
return s
else
return nil
end
end
 
-- ============================================================================================================
-- Aggiunge uno spazio alla stringa se non termina per "'" (apostrofo)
-- ============================================================================================================
local function add_space(s)
if not is_defined(s) then
--ritorna uno spazio se l'ultimo carattere non è un accento
if s == nil then return '' end
if elseif mw.ustring.sub(s, -1) == "'" then
return s
else
return s .. ' '
end
end
 
-- ============================================================================================================
-- Aggiunge la categoria "category" alla lista di categorie da aggiungere alla voce
-- ritorna la stringa se è definita e diversa da stringa nulla, altrimenti nil
-- ============================================================================================================
local function is_definedadd_category(scategory)
if s and s ~= ''category then return s end
categories[category] = true
return nil
end
end
 
-- ============================================================================================================
-- Aggiunge categoryil messaggio di errore "error_msg" alla lista di categoriemessaggi dadi aggiungereerrore allada vocevisualizzare.
-- Se viene precisata una categoria di errore la aggiunge alle categorie in cui inserire la voce,
-- altrimenti inserisce la categoria di errore standard
-- ============================================================================================================
local function add_categoryadd_error(error_msg, category)
if category ~= nilerror_msg then
errors_msg[#errors_msg+1] = error_msg
categories[category] = true
if category then
end
add_category(category)
else
add_category('Errori di compilazione del template Interprogetto')
end
end
end
 
-- ============================================================================================================
-- AggiungeRitorna un messaggiocollegamento di erroredefault alladato listail nome di messaggiun progetto, nil in caso di erroreerrori
-- ============================================================================================================
local function add_errorget_default_collegamento(error_msgkey_progetto, fullpagename)
if cfg.parameters[key_progetto] then
if errors_msg ~= nil then
if cfg.parameters[key_progetto]['collegamento_non_esistente'] then
errors_msg[#errors_msg+1] = error_msg
add_error(cfg.parameters[key_progetto]['collegamento_non_esistente'])
add_category('Errori di compilazione del template Interprogetto')
return nil
end
elseif cfg.parameters[key_progetto].collegamento_default_minuscolo then
return mw.ustring.gsub(fullpagename, '^%u', string.lower)
else
return fullpagename
end
else
return nil
end
end
 
-- ============================================================================================================
-- Ordina una tabella in funzione della chiave "ordine" degli elementi della tabella
-- Ritorna true se la voce è una pagina di disambiguazione
-- controllando se il valore della proprietà P31 (wikidata property "Istance of", https://www.wikidata.org/wiki/Property:P31)
--- è uguale a "4167410" (wikidata item 'Wikimedia disambiguation page': https://www.wikidata.org/wiki/Q4167410)
-- ============================================================================================================
local function check_is_disambiguasort_by_ordine(entityt1, t2)
if t1.ordine < t2.ordine or t1.ordine == t2.ordine and t1.lingua < t2.lingua then
local istance_of = 'P31' --
return true
if entity and entity.claims and entity.claims[istance_of]
end
and entity.claims[istance_of][1]
and entity.claims[istance_of][1].mainsnak
and entity.claims[istance_of][1].mainsnak.datavalue
and entity.claims[istance_of][1].mainsnak.datavalue.type == 'wikibase-entityid'
and entity.claims[istance_of][1].mainsnak.datavalue.value
and entity.claims[istance_of][1].mainsnak.datavalue.value['entity-type'] == 'item'
and entity.claims[istance_of][1].mainsnak.datavalue.value['numeric-id'] == 4167410 then
return true
end
return false
end
 
-- ============================================================================================================
-- Classe per gestire la raccolta di informazioni da Wikidata
-- Ritorna una lista di progetti linkati da wikidata e un elenco di eventuali badge
-- controllando i progetti elencati in cfg.automatic_link
-- ============================================================================================================
local Wikidata_entity = {}
local function get_wikidata_links(entity)
 
local wikidata_links = {}
function Wikidata_entity:new(ignore_wikidata)
local badge_links = {}
-- Carica i dati da Wikidata se esistono
if entity == nil then return wikidata_links, badge_links end
local self = {}
for key_progetto, progetto in pairs(cfg.automatic_link) do
if not ignore_wikidata then
if entity.sitelinks and entity.sitelinks[progetto.interwiki] then
self.entity = mw.wikibase.getEntityObject()
wikidata_links[key_progetto] = entity.sitelinks[progetto.interwiki].title
end
if entity.sitelinks[progetto.interwiki].badges then
setmetatable(self, { __index = Wikidata_entity,
local badge_list = {}
__tostring = function(t) return self:__tostring() end })
for _, badge_quality in ipairs(entity.sitelinks[progetto.interwiki].badges) do
self.collegamenti = {}
if cfg.badges[badge_quality] then
self.badge = {}
badge_list[#badge_list+1] = cfg.badges[badge_quality]
self.from_property_category = {}
end
self.article_link = {}
end
self.lingua = {}
if #badge_list > 0 then
if self.entity then
table.sort(badge_list, sort_by_ordine)
self.etichetta = self.entity:getLabel('it')
badge_links[key_progetto] = table.concat(badge_list, ' ')
-- Imposta il corsivo se la pagina su Wikidata ha la proprietà P31 ("Istance of", [[wikidata:Property:P31]])
end
-- con valore corrispondente a un'opera, come definito in cfg.check_opera
end
self.corsivo = self:hasPropertyValue('P31', cfg.check_opera)
elseif progetto.property_category and entity.claims then
-- Considera disambigua se la pagina su Wikidata ha la proprietà P31 ("Istance of", [[wikidata:Property:P31]])
local property_id =progetto.property_category
-- con valore 4167410 ("Wikimedia disambiguation page", [[wikidata:Q4167410]])
if entity.claims[property_id]
self.disambigua = self:hasPropertyValue('P31', '4167410')
and entity.claims[property_id][1]
-- Controlla se la voce è relativa a una categoria
and entity.claims[property_id][1].mainsnak
self.is_category = self:hasPropertyValue('P31', '4167836')
and entity.claims[property_id][1].mainsnak.datavalue
self:loadCollegamenti()
and entity.claims[property_id][1].mainsnak.datavalue.type == 'string' then
end
wikidata_links[key_progetto] = 'Category:' .. entity.claims[property_id][1].mainsnak.datavalue.value
return self
end
end
 
end
function Wikidata_entity:getClaim(property_id)
return wikidata_links, badge_links
if self.entity.claims and
self.entity.claims[property_id] and
self.entity.claims[property_id][1].mainsnak.datavalue and
self.entity.claims[property_id][1].mainsnak.datavalue.type == 'string' then
return self.entity.claims[property_id][1].mainsnak.datavalue.value
else
return nil
end
end
 
function Wikidata_entity:getInterwiki(project, property_language)
local interwiki = { project }
if property_language and self.entity.claims and self.entity.claims[property_language] then
project = project:sub(3)
for _, claim in ipairs(self.entity.claims[property_language]) do
if claim.mainsnak.datavalue.type == 'wikibase-entityid' then
local entityId = 'Q' .. claim.mainsnak.datavalue.value['numeric-id']
if entityId ~= 'Q652' then
local claims = mw.wikibase.getBestStatements(entityId, 'P424')
local language_code = claims[1] and claims[1].mainsnak.datavalue.value
if language_code then
if project == 'wikisource' and language_code == 'grc' then
language_code = 'el'
end
table.insert(interwiki, language_code .. project)
self.lingua[language_code .. project] = language_code
end
end
end
end
end
return interwiki
end
 
-- ============================================================================================================
-- Carica collegamenti e badge da Wikidata controllando i progetti elencati in cfg.automatic_link
-- Ritorna un collegamento di default dato il nome progetto
-- ============================================================================================================
function Wikidata_entity:loadCollegamenti()
local function get_default_collegamento(key_progetto, fullpagename)
for key_progetto, progetto in pairs(cfg.automatic_link) do
if cfg.parameters[key_progetto] then
-- Carica i collegamenti di un progetto solo se non disambigua o tipo di progetto abilitato in disambigua
if cfg.parameters[key_progetto]['collegamento_non_esistente'] then
if not self.disambigua or add_error(cfg.parameters[key_progetto]['collegamento_non_esistente']).abilita_in_disambigua then
for i, interwiki in ipairs(self:getInterwiki(progetto.interwiki, progetto.property_language)) do
return ''
local sitelink = self.entity:getSitelink(interwiki)
elseif cfg.parameters[key_progetto]['collegamento_default_minuscolo'] then
-- Dà sempre precedenza al sitelink se è una categoria
return mw.ustring.gsub(fullpagename, "^%u", string.lower)
if sitelink and mw.ustring.find(sitelink, '^Category:') then
else
-- 'false' disabilita la consultazione della proprietà
return fullpagename
self.from_property_category[key_progetto] = false
end
end
local claim
return ''
if progetto.property_category and self.from_property_category[key_progetto] ~= false then
claim = self:getClaim(progetto.property_category)
if claim then
self.collegamenti[key_progetto] = 'Category:' .. claim
self.from_property_category[key_progetto] = true
end
end
if sitelink then
if self.from_property_category[key_progetto] then
self.article_link[key_progetto] = sitelink
elseif i > 1 then
local lingua = self.lingua[interwiki]
key_progetto = string.format('%s_%s', key_progetto, lingua)
self.lingua[key_progetto] = lingua
self.collegamenti[key_progetto] = string.format('%s:%s', lingua, sitelink)
else
self.collegamenti[key_progetto] = sitelink
end
if i == 1 and self.entity.sitelinks[interwiki].badges then
local badge_class = {}
local badge_title = {}
for _, badge_quality in ipairs(self.entity.sitelinks[interwiki].badges) do
if cfg.badges[badge_quality] then
badge_class[#badge_class+1] = cfg.badges[badge_quality].class
badge_title[#badge_title+1] = cfg.badges[badge_quality].title
end
end
self.badge[key_progetto] = {}
self.badge[key_progetto].class = table.concat(badge_class, ' ' )
self.badge[key_progetto].title = table.concat(badge_title, ', ' )
end
elseif not self.is_category and progetto.property_gallery and not self.from_property_category[key_progetto] then
claim = self:getClaim(progetto.property_gallery)
self.collegamenti[key_progetto] = claim
end
end
end
end
end
 
-- ============================================================================================================
-- Verifica se una determinata proprietà ha uno dei valori specificati nella lista "values".
-- Riadattata da "hasPropertyValue" su [[wikiquote:it:Modulo:Interprogetto]] a sua volta
-- riadattata da "instanceof(arg)" su [[wikisource:it:Modulo:Autore]]
-- ============================================================================================================
function Wikidata_entity:hasPropertyValue(propertyId, values)
if self.entity.claims and self.entity.claims[propertyId] then
for _, claim in ipairs(self.entity.claims[propertyId]) do
if claim.mainsnak.datavalue and claim.mainsnak.datavalue.value then
local datavalue = claim.mainsnak.datavalue
if datavalue.type == 'wikibase-entityid' and
datavalue.value['entity-type'] == 'item' and
(type(values) == 'table' and values[tostring(datavalue.value['numeric-id'])]) or
values == tostring(datavalue.value['numeric-id']) then
return true
end
end
end
end
return false
end
-- ============================================================================================================
-- Fine definizione della classe Wikidata_entity
-- ============================================================================================================
 
-- ============================================================================================================
-- Classe per gestire i collegamenti interprogetto
-- ============================================================================================================
local Collegamento = {}
 
function Collegamento:new(key_progetto, args, badge_linksentity, default)
-- Crea un collegamento a un progetto, riceve il nome del progetto, gli argomenti da usare per determinare
-- i valori dei vari parametri del collegamento. Si appoggia alla tabella esterna cfg.parameters per i
-- valori di default del collegamentoprogetto e all'arrayalla tabella globale defaultsdefault per i valorvalori di default generali
 
local self = {}
setmetatable(self, { __index = Collegamento,
__tostring = function(t) return self:__tostring() end })
local default_progetto = cfg.parameters[key_progetto:match('^[^_]+')]
if default_progetto == nil then return nil end
-- Progetto non riconosciuto
self.ordine = default_progetto.ordine
return nil
self.key_progetto = key_progetto
end
self.badge_leftbar = badge_links[key_progetto] or ''
self.collegamento = args[key_progetto]
if not is_defined(self.collegamento) then
self.etichetta = is_defined(args[key_progetto .. '_etichetta']) or (default_progetto.etichetta_lower and default.etichetta_lower) or default.etichetta
-- Collegamento non definito correttamente
self.oggetto = args[key_progetto .. '_oggetto'] or default.oggetto or default_progetto.oggetto
return nil
if default_progetto.preposizione then
else
self.preposizione = args[key_progetto .. '_preposizione'] or default.preposizione or default_progetto.preposizione
self.default_progetto = default_progetto
else
self.ordine = default_progetto.ordine
self.preposizione = ''
self.badge_leftbar = {}
end
self.badge_leftbar.class = (entity.badge[key_progetto] and entity.badge[key_progetto].class) or ''
if key_progetto=='notizia' and is_defined(args.data) then
self.badge_leftbar.title = (entity.badge[key_progetto] and entity.badge[key_progetto].title) or ''
self.testo_dopo = table.concat({' <small>', args.data, '</small>'})
self.etichetta = is_defined(args[key_progetto .. '_etichetta']) or (default_progetto.etichetta_lower and default.etichetta_lower) or default.etichetta
else
-- elabora l'oggetto per i testi completi su wikisource quando il collegamento è ricavato da wikidata e il parametro testo_preposizione è compilato
self.testo_dopo = default_progetto.testo_dopo
local alias_s_oggetto = key_progetto == 's' and args.testo_preposizione and not args.orig_s and not args.s_preposizione and cfg.parameters['testo'].oggetto
end
if default_progetto self.linguaoggetto and= args[key_progetto .. '_lingua_oggetto'] thenor alias_s_oggetto or default.oggetto or default_progetto.oggetto
if default.frase_unificata or default_progetto.preposizione then
self.lingua = ' in lingua ' .. args[key_progetto ..'_lingua']
-- consulta il parametro testo_preposizione se il collegamento a wikisource non è manuale
else
local alias_s_preposizione = key_progetto == 's' and not args.orig_s and args.testo_preposizione
self.lingua = ''
self.preposizione = args[key_progetto .. '_preposizione'] or alias_s_preposizione or default.preposizione or default_progetto.preposizione
end
else
return self
self.preposizione = ''
end
if default.frase_unificata then
self.testo_prima = ''
self.testo_dopo = ''
else
self.testo_prima = default_progetto.testo_prima
self.testo_dopo = default_progetto.testo_dopo
end
if key_progetto == 'notizia' and is_defined(args.data) then
self.testo_dopo = ' <small>' .. args.data .. '</small>'
end
local lingua = key_progetto == 's_el' and 'lingua greca' or
entity.lingua[key_progetto] and require('Modulo:Linguaggi').get_voce(entity.lingua[key_progetto]) or
args[key_progetto .. '_lingua'] and 'lingua ' .. args[key_progetto .. '_lingua']
if default_progetto.lingua and lingua then
self.lingua = ' in ' .. lingua
else
self.lingua = ''
end
return self
end
end
 
function Collegamento:Link()
local default_progetto = self.default_progetto
if cfg.parameters[self.key_progetto].link == 'Link' then return self:Link_text() end
if default_progetto.link == 'Link' then
if cfg.parameters[self.key_progetto].link == 'LinkWithLanguage' then return self:Link_language() end
return self:Link_text()
if cfg.parameters[self.key_progetto].link == 'LinkRicette' then return self:Link_ricette() end
elseif default_progetto.link == 'LinkWithLanguage' then
if cfg.parameters[self.key_progetto].link == 'LinkIncubator' then return self:Link_incubator() end
return self:Link_language()
add_error('Errore interno modulo Interprogetto:'.. self.key_progetto)
elseif default_progetto.link == 'LinkRicette' then
return ''
return self:Link_ricette()
elseif default_progetto.link == 'LinkIncubator' then
return self:Link_incubator()
end
add_error('Errore interno modulo Interprogetto')
return ''
end
 
function Collegamento:Link_lb()
local default_progetto = self.default_progetto
if cfg.parameters[self.key_progetto].link == 'Link' then return self:Link_text_lb() end
if default_progetto.link == 'Link' then
if cfg.parameters[self.key_progetto].link == 'LinkWithLanguage' then return self:Link_language_lb() end
return self:Link_text_lb()
if cfg.parameters[self.key_progetto].link == 'LinkRicette' then return self:Link_ricette_lb() end
elseif default_progetto.link == 'LinkWithLanguage' then
if cfg.parameters[self.key_progetto].link == 'LinkIncubator' then return self:Link_incubator_lb() end
return self:Link_language_lb()
add_error('Errore interno modulo Interprogetto:' .. self.key_progetto)
elseif default_progetto.link == 'LinkRicette' then
return ''
return self:Link_text_lb()
elseif default_progetto.link == 'LinkIncubator' then
return self:Link_incubator_lb()
end
add_error('Errore interno modulo Interprogetto')
return ''
end
 
function Collegamento:Link_text()
local default_progetto = cfg.parameters[self.key_progetto]default_progetto
return "* [[File:", default_progetto.icona, "|link=", default_progetto.prefix, "|", default_progetto.dimensione_icona, "|Collabora a ",
return mw.message.newRawMessage("* [[File:$1|link=$2|$3|Collabora a $4]] '''[[$6|$6]]''' contiene $7 $8 $9$10'''[[$11$12|$13]]'''$14",
{ default_progetto.iconanome_progetto, "]] [[", default_progetto.prefix, default_progetto.dimensione_icona"|", default_progetto.nome_progetto, "]] contiene ",
self.oggetto, self.lingua, " ", add_space(self.preposizione), self.testo_prima, "'''[[", default_progetto.prefix,
-- 1 2 3 4
self.collegamento, "|", self.etichetta, "]]'''", self.testo_dopo
default_progetto.prefix, default_progetto.nome_progetto,
-- 5 6
self.oggetto, self.lingua, add_space(self.preposizione), default_progetto.testo_prima,
-- 7 8 9 10
default_progetto.prefix , self.collegamento, self.etichetta , self.testo_dopo }):plain()
-- 11 12 13 14
end
 
function Collegamento:Link_text_lb()
local default_progetto = cfg.parameters[self.key_progetto]default_progetto
return mw.message.newRawMessage("[[$1$2|$3]]", {default_progetto.prefix, self.collegamento, "|", default_progetto.nome_leftbar or default_progetto.nome_progetto}):plain(), "]]"
end
 
function Collegamento:Link_ricette()
local default_progetto = cfg.parameters[self.key_progetto]default_progetto
return "* [[File:", default_progetto.icona, "|link=", default_progetto.prefix, "|", default_progetto.dimensione_icona,
return mw.message.newRawMessage("* [[File:$1|link=$2|$3|Collabora a $4]] Il ''[[b:Libro di cucina|Libro di cucina]]'' di '''[[b:|Wikibooks]]''' contiene [[$5$6|ricette]] relative a questo argomento.",
"|Collabora a ", default_progetto.nome_progetto, "]] Il ''[[b:Libro di cucina|Libro di cucina]]'' di [[b:|Wikibooks]] contiene '''[[",
{ default_progetto.icona, default_progetto.prefix, default_progetto.dimensione_icona, default_progetto.nome_progetto, default_progetto.prefix, self.collegamento} ):plain()
default_progetto.prefix, self.collegamento, "|ricette]]''' relative a questo argomento"
end
 
function Collegamento:Link_language()
local default_progetto = cfg.parameters[self.key_progetto]default_progetto
local main_page_link = tostring(mw.uri.fullUrl(default_progetto.prefix .. self.collegamento, {uselang='it'}))
return "* [[File:", default_progetto.icona, "|link=", main_page_link, "|", default_progetto.dimensione_icona, "|Collabora a ",
return mw.message.newRawMessage("* [[File:$1|link=$2|$3|Collabora a $4]] '''<span class=\"plainlinks\">[$5 $6]</span>''' contiene $7 $8$9'''<span class=\"plainlinks\">[$10 $11]</span>'''$12",
default_progetto.nome_progetto, "]] <span { default_progetto.iconaclass=\"plainlinks\">[", main_page_link, default_progetto.dimensione_icona" ", default_progetto.nome_progetto,
"]</span> contiene ", self.oggetto, " ", add_space(self.preposizione), self.testo_prima,
--1 2 3 4
"'''<span class=\"plainlinks\">[", tostring(mw.uri.fullUrl(default_progetto.prefix .. self.collegamento, {uselang='it'})),
main_page_link, default_progetto.nome_progetto, self.oggetto, add_space(self.preposizione),
" ", self.etichetta, "]</span>'''", self.testo_dopo
-- 5 -6 -7 8
default_progetto.testo_prima, tostring(mw.uri.fullUrl(default_progetto.prefix, self.collegamento, {uselang='it'})),
--9 10
self.etichetta, self.testo_dopo} ):plain()
--11 12-
end
 
function Collegamento:Link_language_lb()
local default_progetto = cfg.parameters[self.key_progetto]default_progetto
return mw.message.newRawMessage("<span class=\"plainlinks\" title=\"$1", default_progetto.prefix , self.collegamento, "\">[$2 $3]</span>",
self.etichetta, tostring(mw.uri.fullUrl(default_progetto.prefix .. self.collegamento, {uselang='it'})), " ",
default_progetto.nome_leftbar or default_progetto.nome_progetto):plain(), "]</span>"
end
 
function Collegamento:Link_incubator()
local default_progetto = cfg.parameters[self.key_progetto]default_progetto
local oggetto = self.oggetto
if not cfg.prefix_incubator[oggetto] then oggetto='wikipedia' end
oggetto = default_progetto.oggetto
local collegamento = tostring(mw.uri.fullUrl(table.concat({'incubator:', prefix_incubator[oggetto],
end
'/', self.collegamento}), {uselang='it'}))
local collegamento = local main_page_incubator=tostring(mw.uri.fullUrl(table.concat({':incubator:Main_Page/it', {uselang='it'}))cfg.prefix_incubator[oggetto],
'/', self.collegamento}), {uselang='it'}))
local main_page_progetto = ''
local main_page_incubator = tostring(mw.uri.fullUrl('incubator:Incubator:Main Page/it', {uselang='it'}))
if oggetto == 'wikipedia' then
local main_page_progetto = '[[Wikipedia]]'
if oggetto == 'wikipedia' then
else
main_page_progetto = '[[Wikipedia]]'
else
main_page_progetto = table.concat({'[[', oggetto, ':it:|', oggetto:gsub("'^%l"', string.upper), ']]'})
end
return "* [[File:", default_progetto.icona, "|link=", main_page_incubator, "|", default_progetto.dimensione_icona,
return mw.message.newRawMessage("* [[File:$1|link=$2|$3|Collabora a Incubator '''<span class=\"plainlinks\">[$4 Incubator]</span>''' contiene un test su $5 $6<span class=\"plainlinks\">[$8 $9]</span>",
"|Collabora a Incubator]] <span class=\"plainlinks\">[", main_page_incubator, " Incubator]</span> contiene un test su ",
{default_progetto.icona, main_page_incubator, default_progetto.dimensione_icona, main_page_incubator, main_page_progetto,
main_page_progetto, self.lingua, " ", add_space(self.preposizione), "'''<span class=\"plainlinks\">[", collegamento, " ", self.etichetta, }):plain()"]</span>'''"
end
 
function Collegamento:Link_incubator_lb()
local oggettodefault_progetto = cfg.parameters[self.oggettokey_progetto]
local oggetto = self.oggetto
if not cfg.prefix_incubator[oggetto] then oggetto='wikipedia' end
if not local collegamento = tostring(mwcfg.uri.fullUrl(table.concat({'incubator:', prefix_incubator[oggetto], then
oggetto = default_progetto.oggetto
'/', self.collegamento}), {uselang='it'}))
end
return mw.message.newRawMessage("<span class=\"plainlinks\" title=\"$1\">[$2 Incubator]<span>", {self.etichetta, collegamento}):plain()
local collegamento = tostring(mw.uri.fullUrl(table.concat({'incubator:', cfg.prefix_incubator[oggetto],
'/', self.collegamento}), {uselang='it'}))
return mw.message.newRawMessage("<span class=\"plainlinks\" title=\"$1\">[$2 Incubator]</span>", {self.etichetta, collegamento}):plain()
end
-- ===============================================================================================
-- Fine definizione della classe
-- ===============================================================================================
 
-- ============================================================================================================
-- Fine definizione della classe Collegamento
-- Funzione per ordinare una tabella in funzione della chiave "ordine" degli elementi della tabella
-- ============================================================================================================
local function sort_by_ordine(t1, t2)
if t1.ordine < t2.ordine then
return true
end
end
 
-- ============================================================================================================
-- Scandisce la tabella progetti e produce il codice html per l'elenco dei collegamenti nella barra di sinistra
-- Imposta il tag div id="interProject" (vedi accessorio [[MediaWiki:Gadget-InterProject.js]])
-- ============================================================================================================
local function RenderLeftBar(progetti)
local leftbar = mw.html.create('ul')
-- Crea la barra di sinistra con i link interprogetto
for _, progetto in ipairs(progetti) do
-- costruisce le righe per la barra di sinistra come un elenco puntato
leftbar
-- Apertura del tag div id="interProject" (vedi [[Commons:MediaWiki:InterProject.js]] incluso da [[Mediawiki:Common.js]])
:tag('li')
 
:attr('title', progetto.badge_leftbar.title)
local leftbar = mw.html.create('div'):attr('title', 'Collegamenti verso gli altri progetti Wikimedia')
:addClass(progetto.badge_leftbar.class)
for _,progetto in ipairs(progetti) do
:wikitext(progetto:Link_lb())
leftbar:newline()
if progetto.default_progetto.nome_leftbar then
leftbar:wikitext('<li class=\"', progetto.badge_leftbar, '\">')
leftbar:wikitext('<br />(', progetto:Link_lb(.default_progetto.nome_progetto, ')')
end
if cfg.parameters[progetto.key_progetto].nome_leftbar then
end
leftbar:wikitext('<br />(', cfg.parameters[progetto.key_progetto].nome_leftbar, ')')
root
end
:tag('div')
leftbar:wikitext('</li>')
:attr('id', 'interProject')
end
:cssText('display: none')
root:tag('div')
:node(leftbar)
:attr('id', 'interProject')
:cssText('display: none; clear: both; border-width: 2px 0; border-style: dotted; border-color: #AAAAAA; margin-top: 2em')
:tag('p')
:attr('id', 'sisterProjects')
:cssText('background-color: #efefef; font-weight: bold; margin: 0 0 -0.2em')
:tag('span')
:wikitext('Altri progetti')
:done()
:done()
:node(leftbar)
end
 
-- ============================================================================================================
 
-- Scandisce la tabella progetti e produce il codice html per l'elenco puntato dei collegamenti interprogetto
-- ============================================================================================================
local function RenderLinksInText(progetti)
for _, progetto in ipairs(progetti) do
-- Scandisce la tabella progetti e produce il codice html per l'elenco puntato
root:newline()
for _,progetto in ipairs(progetti) do
root:wikitext(progetto:Link())
root:newline()
end
root:wikitext(progetto:Link())
end
end
 
-- ============================================================================================================
-- Confronta i collegamenti manuali con quelli automatici e genera le categorie di classificazione nei casi di:
-- - Presenza di link manuale e assenza di link su wikidata
-- - Differenza tra link manuale e link su wikidata
-- - Differenza tra link manuale a categoria e e categoria su wikidata
-- - Presenza di link manuale a categoria e a catagoria su wikidta
-- ============================================================================================================
local function check_with_wikidata(key_progetto, entity, collegamento)
if collegamento == nil then return end -- se non c'è un collegamento manuale ritorna immediatamente
local entity_collegamento = entity.collegamenti[key_progetto]
-- si assicura che il collegamento manuale inizi con la 'C' maiuscola se è una categoria
local collegamento_normalizzato = mw.ustring.gsub(collegamento, '^category:', 'Category:')
local collegamento_is_category = mw.ustring.find(collegamento_normalizzato, '^Category:')
-- Check se il collegamento manuale è una categoria, se il tipo di progetto prevede una proprietà a parte
-- per le categorie e se la sua consultazione non è stata disabilitata
if collegamento_is_category and cfg.automatic_link[key_progetto].property_category and entity.from_property_category[key_progetto] ~= false then
-- se esiste un collegamento su wikidata dalla proprietà per la categoria la confronta con quello manuale
if entity.from_property_category[key_progetto] then
if entity_collegamento ~= collegamento_normalizzato then
add_category(cfg.automatic_link[key_progetto].category_wikidata_category_diff)
end
-- se non esiste un collegamento manuale su wikidata lo marca come assente
else
add_category(cfg.automatic_link[key_progetto].category_wikidata_category_missing)
end
else
local article_link
-- recupera il collegamento automatico alla voce (può essere in entity.article_link[key_progetto] o
-- in entity.collegamento[key_progetto] a seconda del sitelink e della proprietà per le categorie)
if entity.from_property_category[key_progetto] then
article_link = entity.article_link[key_progetto]
else
article_link = entity_collegamento
end
-- Se ha recuperato un valore per article_link lo confronta con quello normalizzato
-- altrimenti aggiunge il tracking di collegamento mancante in wikidata
if article_link then
if article_link ~= collegamento_normalizzato then
add_category(cfg.automatic_link[key_progetto].category_wikidata_diff)
end
else
add_category(cfg.automatic_link[key_progetto].category_wikidata_missing)
end
end
end
 
-- ============================================================================================================
-- Funzione principale richiamata dal template Interprogetto
-- ============================================================================================================
function p.interprogetto(frame)
 
 
local origArgs
-- se chiamata da una sandbox carica la configurazione della sandbox
-- Se chiamata mediante #invoke, usa gli argomenti passati al template invocante.
--if nil ~= string.find (frame:getTitle(), 'sandbox', 1, true) then
-- Altrimenti a scopo di test assume che gli argomenti siano passati direttamente
cfg = mw.loadData('Module:Interprogetto/Configurazione/sandbox')
if frame == mw.getCurrentFrame() then
--else
origArgs = frame:getParent().args
--cfg = mw.loadData('Module:Interprogetto/Configurazione')
else
--end
origArgs = frame.args
local origArgs
end
-- ========================================================================================================
local default = {} -- tabella con i parametri di default valorizzati
-- Se chiamata mediante #invoke, usa gli argomenti passati al template invocante.
-- Carico i parametri
-- Altrimenti a scopo di test assume che gli argomenti siano passati direttamente
local current_page = mw.title.getCurrentTitle()
-- ========================================================================================================
local current_namespace = current_page.namespace
if frame == mw.getCurrentFrame() then
local current_pagename = current_page.text
origArgs = frame:getParent().args
-- Per i namespace uso il nome canonico (inglese) per non avere differenze tra progetti:
else
-- esempio: Utente/User, Categoria/Category, ma anche Wikiquote/Wikipedia (Project), ecc.
origArgs = frame
if current_namespace ~= 0 then
end
default.current_fullpagename = mw.site.namespaces[current_namespace].canonicalName .. ':' .. current_pagename
-- Tabella con i parametri di default valorizzati
else
local default = {}
default.current_fullpagename = current_pagename
-- ========================================================================================================
end
-- Carica il nome della pagina corrente
-- carico i dati da wikidata se esistono
-- ========================================================================================================
local entity = nil
local current_page = mw.title.getCurrentTitle()
if mw.wikibase then
local current_namespace = current_page.namespace
entity = mw.wikibase.getEntityObject()
local current_pagename = current_page.text
end
-- Per i namespace usa il nome canonico (inglese) per non avere differenze tra progetti:
-- Calcolo l'etichetta di default per i collegamenti, in ordine di priorità:
-- esempio: Utente/User, Categoria/Category, ma anche Wikiquote/Wikipedia (Project), ecc.
-- 1) Se è definita l'etichetta in lingua italiana su wikidata uso questa (elimiando un eventuale 'Categoria:' di fronte alla voce)
if current_namespace ~= 0 then
--2) Altrimenti uso il nome della pagina corrente, eliminando eventuale disambigue in coda alla voce
default.current_fullpagename = mw.site.namespaces[current_namespace].canonicalName .. ':' .. current_pagename
-- e definisco etichetta_lower come il nome della voce con iniziale minuscola
else
--
default.current_fullpagename = current_pagename
if is_defined(origArgs.etichetta) then
end
default.etichetta = origArgs.etichetta
-- ========================================================================================================
else
-- Carica i dati da Wikidata nell'oggetto "entity"
if entity and entity.labels and entity.labels.it and entity.labels.it.value ~= '' then
-- ========================================================================================================
default.etichetta = mw.ustring.gsub(entity.labels.it.value, '^Categoria:', '') -- Elimino un eventuale "Categoria:" in fronte del nome
local ignore_wikidata = false
else
local nowikidata = origArgs.nowikidata and origArgs.nowikidata:lower()
default.etichetta = mw.ustring.gsub(current_pagename, ' %(.*%)$', '') -- Elimino un'eventuale disambigua dal nome
if nowikidata == 's' or nowikidata == 'sì' or if current_namespacenowikidata == 0'si' then
ignore_wikidata = true
default.etichetta_lower = mw.ustring.gsub(default.etichetta, "^%l", string.lower)
end
end
local entity = Wikidata_entity:new(ignore_wikidata)
end
-- ========================================================================================================
end
-- Calcola l'etichetta di default per i collegamenti, in ordine di priorità:
-- se etichetta_lower non è definito lo rendo uguale ad etichetta
-- 1) Se è definita l'etichetta in lingua italiana su Wikidata usa questa (eliminando un eventuale
default.etichetta_lower = default.etichetta_lower or default.etichetta
-- "Categoria:" di fronte alla voce)
local is_disambigua = check_is_disambigua(entity)
-- 2) Altrimenti usa il nome della pagina corrente, eliminando un'eventuale disambigua in coda alla voce,
if current_namespace ~= 14 then
-- e definisce etichetta_lower come il nome della voce con iniziale minuscola.
default.preposizione = origArgs.preposizione
-- Se la voce è segnalata come opera su Wikidata allora l'etichetta è in corsivo (senza iniziale minuscola)
default.oggetto = origArgs.oggetto
-- ========================================================================================================
else
if is_defined(origArgs.etichetta) then
default.preposizione = preposizione or "sull'argomento"
default.oggettoetichetta = oggetto or "una categoria"origArgs.etichetta
else
end
if entity.etichetta then
local notizia_presente = false
-- Elimina un eventuale "Categoria:" in fronte del nome
-- Copio i parametri in una nuova tabella, creando una coppia progetto/collegamento per i parametri posizionali
default.etichetta = mw.ustring.gsub(entity.etichetta, '^Categoria:', '')
-- e controllando per parametri duplicati e nomi di progetto non conosciuti
else
local newArgs = {}
-- Elimina un'eventuale disambigua dal nome
for key, value in pairs(origArgs) do
default.etichetta = mw.ustring.gsub(current_pagename, ' %(.*%)$', '')
if tonumber(key) then
if current_namespace == 0 then
local key_progetto = mw.text.trim(value)
default.etichetta_lower = mw.ustring.gsub(default.etichetta, '^%u', string.lower)
if cfg.parameters[key_progetto] then
end
if origArgs[key_progetto] then
end
add_error('Collegamento a "' .. value .. '" inserito sia come parametro posizionale che nominale')
if entity.corsivo then
else
default.etichetta = '<span style=\"font-style:italic;\">' .. default.etichetta .. '</span>'
newArgs[key_progetto] = get_default_collegamento(key_progetto, default.current_fullpagename)
default.etichetta_lower = default.etichetta
end
end
else
end
if key == 1 and key_progetto == 'nolink' then
-- ========================================================================================================
newArgs[1] = 'nolink'
-- Calcola preposizione e oggetto di default, modificandoli se il namespace quello delle categorie
else
-- ========================================================================================================
add_error('Il parametro "' .. value .. '" non corrisponde a nessun progetto riconosciuto dal template')
if current_namespace ~= category_namespace_number then
end
default.preposizione = origArgs.preposizione
end
default.oggetto = origArgs.oggetto
else
else
newArgs[key] = value
default.preposizione = origArgs.preposizione or "sull'argomento"
end
default.oggetto = origArgs.oggetto or "una categoria"
end
default.frase_unificata = true
-- carico i links e i badge proposti da wikidata
end
local wikidata_links = {}
-- ========================================================================================================
local badge_links = {}
-- Copia i parametri in una nuova tabella, creando coppie progetto/collegamento per i parametri posizionali
if entity and not(is_disambigua) then
-- e controllando per parametri duplicati e nomi di progetto non conosciuti
wikidata_links, badge_links = get_wikidata_links(entity)
-- ========================================================================================================
end
local newArgs = {}
-- Controllo se i collegamenti inseriti manualmente sono presenti in wikidata
local nolink = false
for key_progetto, collegamento in pairs(newArgs) do
newArgs.orig_s = origArgs.s
if cfg.parameters[key_progetto] ~= nil and wikidata_links[key_progetto] == nil then
for key, value in pairs(origArgs) do
add_category(cfg.automatic_link['category_wikidata_missing'])
if tonumber(key) then
end
local key_progetto = mw.text.trim(value)
end
if cfg.parameters[key_progetto] then
-- Aggiungo i collegamenti da wikidata alla tabella se non già presenti
if origArgs[key_progetto] then
-- TODO: controllo per collegamenti su wikidata diversi da quelli manuali ?
add_error('Collegamento a \"' .. value .. '\" inserito sia come parametro posizionale che nominale')
for key_progetto, collegamento in pairs(wikidata_links) do
else
if newArgs[key_progetto]==nil and not (cfg.automatic_link[key_progetto]['alias'] and newArgs[cfg.automatic_link[key_progetto]['alias']]) then
if key_progetto == 's' then newArgs.orig_s = newArgs[key_progetto] = collegamentoend
newArgs[key_progetto] = get_default_collegamento(key_progetto, default.current_fullpagename)
end
end
else
-- Costruisco una lista di progetti da visualizzare e la ordino
if key == 1 and key_progetto == 'nolink' then
local progetti = {}
nolink = true
for key_progetto, collegamento in pairs(newArgs) do
else
if cfg.parameters[key_progetto] then
add_error('Il parametro \"' .. value .. '\" non corrisponde a nessun progetto riconosciuto dal template')
-- Salto i link a wikidata per le voci in ns0 eccetto che per la Pagina principale
end
if not(key_progetto == 'wikidata') or current_namespace ~= 0 or current_pagename == 'Pagina principale' then
end
-- Se è disambigua registro solo i valori per i link al wikizionario
else
if cfg.parameters[key_progetto]['abilita_in_disambigua'] or not(is_disambigua) then
newArgs[key] = value
progetti[#progetti+1] = Collegamento:new(key_progetto, newArgs, badge_links, default)
end
end
end
end
-- ========================================================================================================
end
-- Controlla i collegamenti inseriti manualmente integrandoli eventualmente con quelli presenti in Wikidata.
end
-- Salta questo passo se c'è un collegamento a "notizia" dato che in questo caso deve essere unico e quindi
root = mw.html.create('')
-- non deve aggiungere i collegamenti da Wikidata. Inoltre, in caso di "disambigua", salta i progetti non
if newArgs['notizia'] then -- gestisco il parametro "notizia" a parte
-- abilitati in disambigua che in ogni caso non devono essere aggiunti
if #progetti>1 then
-- ========================================================================================================
add_error('Errore: il parametro "notizia" se presente deve essere unico')
if not newArgs.notizia then
else
-- ====================================================================================================
root:wikitext('* [[File:', progetti.icona[1], '|link=', progetti.prefix[1], '|',
-- Controlla il collegamento compilato manualmente e quello caricato da Wikidata
progetti.dimensione_icona[1],'|Collabora a ', progetti.nome_progetto[1],
-- ====================================================================================================
"]]", " Articolo su '''[[", progetti.prefix[1], progetti.nome_progetto[1], '|',
for key_progetto, collegamento in pairs(newArgs) do
progetti.nome_progetto[1], "]]''': ", "'''[[", progetti.prefix[1],
if cfg.parameters[key_progetto] and cfg.automatic_link[key_progetto] and entity.entity then
progetti.collegamento[1], '|', progetti.collegamento[1], "]]'''", progetti.testo_dopo[1] )
if not entity.disambigua or cfg.parameters[key_progetto].abilita_in_disambigua then
end
check_with_wikidata(key_progetto, entity, collegamento)
else
end
table.sort(progetti, sort_by_ordine)
end
RenderLeftBar(progetti)
end
if not(newArgs[1]) or mw.text.trim(newArgs[1])~= 'nolink' then
-- ====================================================================================================
RenderLinksInText(progetti)
-- Aggiunge il collegamento da Wikidata se non è presente quello compilato manualmente o se rinvia a
end
-- un progetto in lingua non italiana che non è registrato nella configurazione e non va sovrascritto
end
-- ====================================================================================================
if #progetti == 0 then
for key_progetto, collegamento in pairs(entity.collegamenti) do
add_category('Template interprogetto vuoti')
if not cfg.automatic_link[key_progetto] or not (newArgs[key_progetto] or newArgs[cfg.automatic_link[key_progetto].alias]) then
end
newArgs[key_progetto] = collegamento
for category,_ in pairs(categories) do
-- Segnala che il collegamento è stato aggiunto da Wikidata
root:wikitext('[[Categoria:' .. category .. ']]')
add_category(cfg.automatic_link[key_progetto:match('^[^_]+')].category_wikidata)
end
end
if #errors_msg > 0 then
end
if #progetti > 0 then
end
root:wikitext('\n')
-- ========================================================================================================
end
-- Sulla base della lista di argomenti ripulita costruisce la lista dei collegamenti da inserire
root:wikitext('<strong class="error">' .. table.concat(errors_msg, '; ') .. '</strong>')
-- ========================================================================================================
end
local progetti = {}
return tostring(root)
local collegamento_found = false
for key_progetto, collegamento in pairs(newArgs) do
if cfg.parameters[key_progetto] or entity.collegamenti[key_progetto] then
-- Salta i collegamenti a Wikidata per le voci nel namespace principale eccetto che per la Pagina principale
if key_progetto ~= 'wikidata' or current_namespace ~= 0 or current_pagename == 'Pagina principale' then
local progetto = Collegamento:new(key_progetto, newArgs, entity, default)
if progetto then
collegamento_found = true
-- Se è disambigua registra solo i valori per i progetti abilitati in disambigua
if not entity.disambigua or cfg.parameters[key_progetto] and cfg.parameters[key_progetto].abilita_in_disambigua then
progetti[#progetti+1] = progetto
end
end
end
end
end
table.sort(progetti, sort_by_ordine)
-- ========================================================================================================
-- Genera il codice html
-- ========================================================================================================
if entity.disambigua and #progetti == 0 and collegamento_found then
add_error('Collegamenti non visualizzabili perché la voce è una disambigua su Wikidata',
'Errori di compilazione del template Interprogetto - collegamenti in disambigua')
elseif #progetti == 0 then
--add_error('Template interprogetto vuoto e senza dati da recuperare da Wikidata', 'Errori di compilazione del template Interprogetto - template vuoto')
add_error('', 'Errori di compilazione del template Interprogetto - template vuoto')
else
local nobarra = origArgs.nobarra and origArgs.nobarra:lower()
if nobarra ~= 's' and nobarra ~= 'sì' and nobarra ~= 'si' then
RenderLeftBar(progetti)
end
if not nolink then
RenderLinksInText(progetti)
end
end
-- =================================================================================================================================
-- Nei namespace ammessi inserisce le categorie di segnalazione di errori/avvisi
-- =================================================================================================================================
if cfg.whitelist_category[current_namespace] then
for category, _ in pairs(categories) do
root:wikitext('[[Categoria:' .. category .. ']]')
end
end
-- =================================================================================================================================
-- Aggiunge i messaggi di errore
-- =================================================================================================================================
if #errors_msg > 0 then
if #progetti > 0 then
root:wikitext('\n')
end
root:wikitext('<strong class=\"error\">' .. table.concat(errors_msg, '; ') .. '</strong>')
end
return tostring(root)
end
 
Estratto da "https://it.wikipedia.org/wiki/Modulo:Interprogetto/sandbox"