Wikipedia

Modulo:Criteri cancellazione immediata/sandbox: differenze tra le versioni

Naviga nella cronologia in modo interattivo
← Differenza precedente
Contenuto cancellato Contenuto aggiunto
aggiungo controllo
usa il modulo:Enum per le enumerazioni
 
(24 versioni intermedie di uno stesso utente non sono mostrate)
Riga 1:
--[[
* Modulo che implementa ili template {{CriteriCriterio cancellazione immediata}}. e
* {{Criteri cancellazione immediata}}.
]]
 
require('strict')
 
local-- cfgLegge = mw.loadJsonData('[[Modulo:Criteri cancellazione immediata/Configurazione/sandbox.json')]]
-- oppure [[Modulo:Criteri cancellazione immediata/sandbox/Configurazione.json]]
local getArgs = require('Module:Arguments').getArgs
local cfg = mw.loadJsonData(mw.getCurrentFrame():getTitle() .. '/Configurazione.json')
local Enum = require('Modulo:Enum')
 
-- =============================================================================
-- enum NamespaceType
-- =============================================================================
local NamespaceType = Enum:new('tipo ns', {
ANY = {
value = 'any'
},
EVEN = {
value = 'ns pari'
},
ODD = {
value = 'ns dispari'
}
})
 
function NamespaceType:findByValue(value)
return self:findBy('value', value)
end
 
-- =============================================================================
-- enum Namespace
-- =============================================================================
 
local Namespace = Enum:new('ns', {
DEFAULT = {
id = 'default',
type = NamespaceType.ANY,
name = 'default'
},
PRINCIPALE = {
id = 0,
type = NamespaceType.EVEN,
name = 'Principale'
}
})
 
for _, ns in pairs(mw.site.namespaces) do
if ns.id ~= 0 then
rawset(Namespace, ns.name:gsub(' ', '_'):upper(), {
id = ns.id,
type = ns.id % 2 == 0 and NamespaceType.EVEN or NamespaceType.ODD,
name = ns.name
})
end
end
 
function Namespace:findById(id)
return self:findBy('id', tonumber(id))
end
 
function Namespace:findByName(name)
return self:findBy('name', name)
end
 
-- =============================================================================
-- enum ListType
-- =============================================================================
 
local ListType = Enum:new('tipo elenco', {
DROPDOWN_LIST = {
arg = 'a discesa',
prefix = '**',
section = setmetatable({
[6] = '* Motivi comuni di cancellazione'
}, {
__index = function (t, key)
return '* Cancellazione immediata'
end
})
},
BULLETED_LIST = {
arg = 'puntato',
prefix = '*',
section = setmetatable({}, {
__index = function (t, key)
return ''
end
})
}
})
 
function ListType:findByArg(arg)
return self:findBy('arg', arg)
end
 
function ListType:getDefault()
return self.DROPDOWN_LIST
end
 
-- =============================================================================
-- enum TextType
-- =============================================================================
 
local TextType = Enum:new('tipo testo', {
SYSTEM_MESSAGE = {
arg = 'messaggio di sistema',
get = 'getSystemMessage',
set = 'setSystemMessage'
},
DEFINITION = {
arg = 'definizione',
get = 'getDefinition',
set = 'setDefinition'
}
})
 
function TextType:findByArg(arg)
return self:findBy('arg', arg)
end
 
function TextType:getDefault()
return self.SYSTEM_MESSAGE
end
 
-- =============================================================================
Riga 15 ⟶ 132:
 
-- Costruttore della classe Criterion
function Criterion:new(abbreviationcode)
local self = {}
setmetatable(self, { __index = Criterion })
 
self.abbreviationcode = abbreviationcode
self.current_ns = Namespace.DEFAULT
self.order = { default = 0 }
self.add_link = false
self.text = { singolare = { default = '' }, plurale = { default = '' } }
self.link = { default = string.format('[[WP:IMMEDIATA|%s]]', code) }
self.system_message = { default = '' }
self.definition = { default = '' }
self.validity = { default = true }
 
Riga 27 ⟶ 148:
end
 
function Criterion:getAbbreviationgetCode()
return self.abbreviationcode
end
 
function Criterion:getOrder(ns)
return self.order[nsself.current_ns.id] or self.order.default
end
 
function Criterion:getTextgetLink(ns, grammatical_number, add_link)
local text =return self.textlink[grammatical_number][nsself.current_ns.id] or self.text[grammatical_number]link.default
end
 
function Criterion:getSystemMessage()
if add_link then
text = return string.format('([[WP:IMMEDIATA|%s]]) %s', self:getAbbreviation(), text)
self.add_link and self:getLink() or self:getCode(),
end
self.system_message[self.current_ns.id] or self.system_message.default)
end
 
function Criterion:getDefinition()
return text
return string.format('(%s) %s',
self.add_link and self:getLink() or self:getCode(),
self.definition[self.current_ns.id] or self.definition.default)
end
 
function Criterion:isValid(ns)
if self.validity[self.current_ns.id] ~= nil then
local ns_type
return self.validity[self.current_ns.id]
 
elseif self.validity[self.current_ns.type.value] ~= nil then
if mw.site.namespaces[ns] then
return self.validity[self.current_ns.type.value]
ns_type = mw.site.namespaces[ns].id % 2 == 0 and 'ns pari' or 'ns dispari'
end
 
if self.validity[ns] ~= nil then
return self.validity[ns]
elseif self.validity[ns_type] ~= nil then
return self.validity[ns_type]
else
return self.validity.default
Riga 61 ⟶ 182:
end
 
function Criterion:setOrdersetCurrentNs(order, ns)
self.order[ns]current_ns = orderns
return self
end
 
function Criterion:setTextsetOrder(text, ns, grammatical_numberorder)
self.textorder[grammatical_number][nsself.current_ns.id] = textorder
return self
end
 
function Criterion:setValidsetAddLink(valid, nsadd_link)
self.validity[ns]add_link = validadd_link
return self
end
 
function Criterion:setLink(link)
self.link[self.current_ns.id] = link
return self
end
 
function Criterion:setSystemMessage(text)
self.system_message[self.current_ns.id] = text
return self
end
 
function Criterion:setDefinition(text)
self.definition[self.current_ns.id] = text
return self
end
 
function Criterion:setValid(valid)
self.validity[self.current_ns.id] = valid
return self
end
 
function Criterion:setValidForNsType(valid, ns_type)
self.validity[ns_type.value] = valid
return self
end
 
Riga 77 ⟶ 226:
-- =============================================================================
 
local function to_criterion(keycriterion_code, valuecriterion_cfg)
local criterion = Criterion:new(keycriterion_code)
 
for ns, props in pairs(criterion_cfg) do
ns = Namespace:findByName(ns)
 
if ns and type(props) == 'table' then
criterion:setCurrentNs(ns)
 
for ns, props in pairs(value) do
if type(props) == 'table' then
if type(props.ordine) == 'number' then
criterion:setOrder(props.ordine, ns)
end
 
if type(props.testolink) == 'tablestring' then
criterion:setLink(props.link)
if type(props.testo.singolare) == 'string' then
end
criterion:setText(props.testo.singolare, ns, 'singolare')
end
 
if type(props.testo.pluraletesti) == 'stringtable' then
for text_type, text in pairs(props.testi) do
criterion:setText(props.testo.plurale, ns, 'plurale')
text_type = TextType:findByArg(text_type)
 
if text_type then
criterion[text_type.set](criterion, text)
end
end
end
 
if ns == 'default'Namespace.DEFAULT then
if type(props['validità']) == 'table' then
iffor typens_type, valid in pairs(props['validità']['ns pari']) == 'boolean' thendo
ns_type = NamespaceType:findByValue(ns_type)
criterion:setValid(props['validità']['ns pari'], 'ns pari')
end
 
if ns_type and type(props['validità']['ns dispari']valid) == 'boolean' then
criterion:setValidsetValidForNsType(props['validità']['ns dispari']valid, 'ns dispari'ns_type)
end
end
end
elseif type(props['validità']) == 'boolean' then
criterion:setValid(props['validità'], ns)
end
end
Riga 115 ⟶ 272:
end
 
local function get_list_prefixcompare_criteria(list_typea, b)
if a:getOrder() == b:getOrder() then
local list_prefixes = {
return a:getCode() < b:getCode()
['elenco a discesa'] = '**',
else
['elenco numerato'] = '#',
return a:getOrder() < b:getOrder()
['elenco puntato'] = '*'
}
 
return list_prefixes['elenco ' .. list_type]
end
 
local function get_criterion(args)
for key, value in pairs(cfg) do
local criterion = to_criterion(key, value)
 
if criterion:getAbbreviation() == args.criterio and criterion:isValid(args.ns) then
return criterion:getText(args.ns, args['tipo testo'], args.link)
end
end
end
 
local function list_criteriaget_suppressed_criteria(argsarg)
local listsuppressed_criteria = ''setmetatable({}, {
__index = function (t, key)
local valid_criteria = {}
return false
 
for key, value in pairs(cfg) do
local criterion = to_criterion(key, value)
 
if criterion:isValid(args.ns) then
table.insert(valid_criteria, criterion)
end
end})
 
if arg then
local comp = function (a, b)
for criterion_code in string.gmatch(arg, '[%s,]*([^,]*[^%s,])') do
if a:getOrder(args.ns) == b:getOrder(args.ns) then
suppressed_criteria[criterion_code] = true
return a:getAbbreviation() < b:getAbbreviation()
else
return a:getOrder(args.ns) < b:getOrder(args.ns)
end
end
 
return suppressed_criteria
table.sort(valid_criteria, comp)
end
 
local function get_args(frame)
for _, criterion in ipairs(valid_criteria) do
local args = require('Module:Arguments').getArgs(frame, { parentOnly = true })
list = string.format('%s\n%s %s', list, get_list_prefix(args['tipo elenco']),
criterion:getText(args.ns, args['tipo testo'], args.link))
end
 
if args['tipo elenco'1] and args.criterio == 'a discesa'nil then
if args.nscriterio, args[1] == 'File'args[1], thennil
list = '* Motivi comuni di cancellazione' .. list
else
list = '* Cancellazione immediata' .. list
end
end
 
args.ns = Namespace:findByName(args.ns) or Namespace:findById(args.ns) or Namespace.DEFAULT
return mw.text.trim(list)
args['tipo elenco'] = ListType:findByArg(args['tipo elenco']) or ListType:getDefault()
args['tipo testo'] = TextType:findByArg(args['tipo testo']) or TextType:getDefault()
args.link = args.link ~= 'no' and true or false
args.ancore = (args.ancore == 'sì' or args.ancore == 'si') and true or false
args['escludi criteri'] = get_suppressed_criteria(args['escludi criteri'])
 
return args
end
 
Riga 179 ⟶ 319:
local p = {}
 
function p.mainget_default_value(frame)
local argsparam = getArgsmw.text.trim(frame, { parentOnly =.args[1] trueor }'')
 
if Enum[param] and Enum[param].getDefault and Enum[param]:getDefault().arg then
if args.ns == 'Principale' then
return string.format('"%s"', Enum[param]:getDefault().arg)
args.ns = ''
elseif args.ns == nil then
args.ns = 'default'
end
end
 
function p.list_possible_values(frame)
if args['tipo elenco'] == nil or get_list_prefix(args['tipo elenco']) == nil then
local param = mw.text.trim(frame.args[1] or '')
args['tipo elenco'] = 'a discesa'
local possible_values = {}
 
if Enum[param] then
for _, constant in pairs(Enum[param]) do
if constant.arg then
table.insert(possible_values, string.format('"%s"', constant.arg))
end
end
end
 
return table.concat(possible_values, ', ')
if args['tipo testo'] ~= 'singolare' and args['tipo testo'] ~= 'plurale' then
end
args['tipo testo'] = 'singolare'
 
function p.get_criterion(frame)
local args = get_args(frame)
local text_type = args['tipo testo']
local ns, criterion_code, add_link = args.ns, args.criterio, args.link
 
if criterion_code and cfg[criterion_code] then
local criterion = to_criterion(criterion_code, cfg[criterion_code])
 
criterion:setCurrentNs(ns):setAddLink(add_link)
 
if criterion:isValid() then
return criterion[text_type.get](criterion)
end
end
end
 
function p.list_criteria(frame)
args.link = args.link ~= 'no' and true or false
local args = get_args(frame)
local list_type, text_type = args['tipo elenco'], args['tipo testo']
local ns, add_anchor, add_link = args.ns, args.ancore, args.link
local suppressed_criteria = args['escludi criteri']
local list = list_type.section[ns.id]
local valid_criteria = {}
 
for criterion_code, criterion_cfg in pairs(cfg) do
if mw.site.namespaces[args.ns] == nil and args.ns ~= 'default' then
local criterion = to_criterion(criterion_code, criterion_cfg)
return
 
elseif args.criterio then
criterion:setCurrentNs(ns):setAddLink(add_link)
return get_criterion(args)
 
else
if criterion:isValid() and suppressed_criteria[criterion:getCode()] == false then
return list_criteria(args)
table.insert(valid_criteria, criterion)
end
end
 
table.sort(valid_criteria, compare_criteria)
 
for _, criterion in ipairs(valid_criteria) do
list = string.format('%s\n%s ', list, list_type.prefix)
 
if add_anchor then
list = string.format('%s<span id=%s></span>', list, criterion:getCode())
end
 
list = list .. criterion[text_type.get](criterion)
end
 
return mw.text.trim(list)
end
 
Estratto da "https://it.wikipedia.org/wiki/Modulo:Criteri_cancellazione_immediata/sandbox"