3 887
contributi
(separate annotations for str.match from those for str._match) |
m (una versione importata) |
||
Riga 1: | Riga 1: | ||
--[[ | --[[ | ||
Questo modulo serve a fornire l'accesso alle funzioni stringa base. | |||
La maggior parte delle funzioni di questo modulo possono essere invocate con | |||
parametri con nome, senza nome o con un misto di entrambi. Quando vengono usati | |||
parametri con nome il software di Mediawiki rimuoverà ogni spazio iniziale o finale | |||
dal parametro. A seconda dell'uso che si vuole fare della funzione può essere | |||
vantaggioso conservare oppure rimuovere questi spazi. | |||
Opzioni globali | |||
ignore_errors: | ignore_errors: se settato a 'true' o 1, ogni condizione di errore ritornerà una stringa vuota | ||
piuttosto che un messaggio di errore. | |||
error_category: | error_category: nel caso si verifichi un errore è il nome di una categoria da includere | ||
insieme al messaggio di errore. La categoria di default | |||
[Categoria:Errori del Module String]. (TODO:verificare) | |||
no_category: | no_category: Se settato a 'true' o 1, non verranno aggiunte categorie in caso di errore. | ||
Unit tests per questo modulo sono disponibili a Module:String/test. | |||
Diverse funzioni fanno uso di pattern Lua, questi sono una forma di espressione regolare, per | |||
maggiori informazioni vedi: | |||
* http://www.lua.org/manual/5.1/manual.html#5.4.1 | |||
* http://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual#Patterns | |||
* http://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual#Ustring_patterns | |||
]] | ]] | ||
Riga 28: | Riga 34: | ||
len | len | ||
Questa funzione ritorna la lunghezza di una stringa. | |||
Uso: | |||
{{#invoke:String|len| | {{#invoke:String|len|stringa|}} | ||
O | |||
{{#invoke:String|len|s= | {{#invoke:String|len|s=stringa}} | ||
Parametri | |||
s: | s: La stringa di cui ritornare la lunghezza | ||
Se invocata usando parametri nominati, Mediawiki rimuoverà automaticamente ogni spazio iniziale | |||
o finale dalla stringa. | |||
]] | ]] | ||
function str.len( frame ) | function str.len( frame ) | ||
local new_args = str._getParameters( frame.args, {'s'} ); | |||
local s = new_args['s'] or ''; | |||
return mw.ustring.len( s ) | |||
end | end | ||
Riga 50: | Riga 56: | ||
sub | sub | ||
Questa funzione ritorna la sottostringa di una stringa bersaglio, come indicato dagli indici | |||
Uso: | |||
{{#invoke:String|sub| | {{#invoke:String|sub|stringa_bersaglio|indice_iniziale|indice_finale}} | ||
O | |||
{{#invoke:String|sub|s= | {{#invoke:String|sub|s=stringa_bersaglio|i=indice_iniziale|j=indice_finale}} | ||
Parameters | Parameters | ||
s: | s: La stringa da cui estrarre una sottostringa | ||
i: | i: La posizione iniziale del primo carattere della sottostringa da ritornare, se non | ||
j: | specificato è 1. | ||
j: La posizione finale dell'ultimo carattere della sottostringa da ritornare, se non | |||
specificato corrisponde alla lunghezza della stringa_bersaglio (l'ultimo carattere). | |||
I caratteri della stringa sono numerati a partire da 1. Se i o j hanno un valore negativo allora | |||
contano la posizione contando dalla fine della stringa, -1 è l'ultimo carattere della stringa, | |||
-2 il penultimo, ecc... | |||
Se le posizioni sono al di fuori degli estremi della stringa viene ritornato un messaggio di | |||
errore. | |||
]] | ]] | ||
function str.sub( frame ) | function str.sub( frame ) | ||
local new_args = str._getParameters( frame.args, { 's', 'i', 'j' } ); | |||
local s = new_args['s'] or ''; | |||
local i = tonumber( new_args['i'] ) or 1; | |||
local j = tonumber( new_args['j'] ) or -1; | |||
local len = mw.ustring.len( s ); | |||
-- Convert negatives for range checking | |||
if i < 0 then | |||
i = len + i + 1; | |||
end | |||
if j < 0 then | |||
j = len + j + 1; | |||
end | |||
if i > len or j > len or i < 1 or j < 1 then | |||
return str._error( 'Indici fuori dagli estremi della stringa' ); | |||
end | |||
if j < i then | |||
return str._error( 'Indici in ordine sbagliato' ); | |||
end | |||
return mw.ustring.sub( s, i, j ) | |||
end | end | ||
--[[ | --[[ | ||
Questa funzione implementa tutte le caratteristiche di {{str sub}} e viene mantenuta per motivi | |||
di compatibilità con template più vecchi. | |||
]] | ]] | ||
function str.sublength( frame ) | function str.sublength( frame ) | ||
local i = tonumber( frame.args.i ) or 0 | |||
local len = tonumber( frame.args.len ) | |||
return mw.ustring.sub( frame.args.s, i + 1, len and ( i + len ) ) | |||
end | end | ||
--[[ | --[[ | ||
match | |||
Questa funzione ritorna dalla stringa bersaglio una sottostringa corrispondente a un pattern | |||
specificato. | |||
Uso: | |||
{{#invoke:String|match|source_string|pattern_string|start_index|match_number|plain_flag|nomatch_output}} | |||
O | |||
{{#invoke:String|match|s=source_string|pattern=pattern_string|start=start_index | |||
|match=match_number|plain=plain_flag|nomatch=nomatch_output}} | |||
Parametri | |||
s: | s: La stringa da cercare | ||
pattern: | pattern: Il pattern da cercare nella stringa | ||
start: | start: La posizione iniziale da cui iniziare la ricerca, se non specificato è 1. | ||
match: Se c'è ci sono corrispondenze multiple quale ritornare, 1 per la prima | |||
match: | corrispondenza, 2 per la seconda ecc.. Un valore negativo indica di contare | ||
all'indietro a partire dall'ultima corrispondenza, quindi match = -1 significa | |||
chiedere l'ultima corrispondenza. Se non specificato è 1 | |||
plain: Se vero specifica che il pattern deve essere considerato come una | |||
stringa normale, piuttosto che un pattern Lua. Se non specificata è falsa. | |||
plain: | nomatch: Il valore da ritornare se non ci sono corrispondenze, invece di ritornare | ||
un errore. | |||
nomatch: | |||
Se richiamata usando parametri nominati Mediawiki rimuoverà automaticamente tutti gli | |||
spazi iniziali e finali. In alcune circostanze questo può essere il comportamento | |||
desiderato, in altre si potrebbe volerli conservare. | |||
Se match_number o start_index sono al di fuori degli estremi della stringa s, allora | |||
la funzione ritorna un errore. Viene generato un errore anche se il non vengono trovate | |||
corrispondenze. Per sopprimere gli errori si può aggiungere il parametro ignore_errors=true, | |||
in questo caso in caso di errore verrò ritornata una stringa vuota. | |||
]] | ]] | ||
function str.match(frame) | |||
function str. | return str._match(frame.args) | ||
end | end | ||
--[[ | --[[ | ||
match | Entry point per chiamata diretta da un modulo | ||
]] | |||
function str._match( args ) | |||
local new_args = str._getParameters( args, {'s', 'pattern', 'start', 'match', 'plain', 'nomatch'} ); | |||
local s = new_args['s'] or ''; | |||
local start = tonumber( new_args['start'] ) or 1; | |||
local plain_flag = str._getBoolean( new_args['plain'] or false ); | |||
local pattern = new_args['pattern'] or ''; | |||
local match_index = math.floor( tonumber(new_args['match']) or 1 ); | |||
local nomatch = new_args['nomatch']; | |||
if s == '' then | |||
return nomatch or str._error( 'La stringa in cui cercare è vuota' ); | |||
end | |||
if pattern == '' then | |||
return nomatch or str._error( 'La stringa o pattern da cercare è vuota' ); | |||
end | |||
if math.abs(start) < 1 or math.abs(start) > mw.ustring.len( s ) then | |||
return nomatch or str._error( 'La posizione iniziale richiesta è fuori dagli estremi della stringa' ); | |||
end | |||
if match_index == 0 then | |||
return nomatch or str._error( 'Match index è nullo' ); | |||
end | |||
if plain_flag then | |||
pattern = str._escapePattern( pattern ); | |||
end | |||
local result | |||
if match_index == 1 then | |||
-- Il caso più semplice, trova la prima corrispondenza | |||
result = mw.ustring.match( s, pattern, start ) | |||
else | |||
if start > 1 then | |||
s = mw.ustring.sub( s, start ); | |||
end | |||
local iterator = mw.ustring.gmatch(s, pattern); | |||
if match_index > 0 then | |||
-- Ricerca in avanti | |||
for w in iterator do | |||
match_index = match_index - 1; | |||
if match_index == 0 then | |||
result = w; | |||
break; | |||
end | |||
end | |||
else | |||
-- Ricerca all'indietro deve estrarre tutte le corrispondenze | |||
local result_table = {}; | |||
local count = 1; | |||
for w in iterator do | |||
result_table[count] = w; | |||
count = count + 1; | |||
end | |||
result = result_table[ count + match_index ]; | |||
end | |||
end | |||
if result == nil then | |||
if nomatch == nil then | |||
return str._error( 'Corrispondenza non trovata' ); | |||
else | |||
return nomatch; | |||
end | |||
else | |||
return result; | |||
end | |||
end | end | ||
Riga 257: | Riga 226: | ||
pos | pos | ||
Questa funzione ritorna il carattere della stringa in posizione pos. | |||
Uso: | |||
{{#invoke:String|pos| | {{#invoke:String|pos|stringa_bersaglio|indice}} | ||
O | |||
{{#invoke:String|pos|target= | {{#invoke:String|pos|target=stringa_bersaglio|pos=indice}} | ||
Parametri | |||
target: | target: La stringa in cui cercare | ||
pos: | pos: La posizione del carattere da ritornare | ||
Se richiamata usando parametri nominati Mediawiki rimuoverà automaticamente tutti gli | |||
spazi iniziali e finali. In alcune circostanze questo può essere il comportamento | |||
desiderato, in altre si potrebbe volerli conservare. | |||
I caratteri della stringa sono numerati a partire da 1. Se pos è un valore negativo allora | |||
conta la posizione partendo dalla fine della stringa, -1 è l'ultimo carattere della stringa, | |||
-2 il penultimo, ecc... | |||
Se la posizione richiesta è 0 o al di fuori degli estremi della stringa viene ritornato | |||
un errore. | |||
]] | ]] | ||
function str.pos( frame ) | function str.pos( frame ) | ||
local new_args = str._getParameters( frame.args, {'target', 'pos'} ); | |||
local target_str = new_args['target'] or ''; | |||
local pos = tonumber( new_args['pos'] ) or 0; | |||
if pos == 0 or math.abs(pos) > mw.ustring.len( target_str ) then | |||
return str._error( 'Indice della stringa fuori dagli estremi' ); | |||
end | |||
return mw.ustring.sub( target_str, pos, pos ); | |||
end | end | ||
Riga 294: | Riga 263: | ||
str_find | str_find | ||
Questa funzione duplica il comportamento di {{str_find}}, incluso i suoi comportamenti | |||
irregolari. Questa funzione è fornita per motivi di compatibilità con i vecchi template, | |||
ma SI RACCOMANDA di non utilizzarla in nuovi template. Nello sviluppo di nuovo codice | |||
si raccomanda di usare la funzione "find". | |||
Parametri | |||
source: La stringa in cui cercare | |||
target: la stringa da cercare | |||
Ritorna la posizione nella stringa source del primo carattere in cui c'è è stata | |||
trovata la stringa target. I caratteri della stringa sono numerati a partire da 1. La funzione | |||
ritorna -1 se la stringa "target" non è contenuta in "source". | |||
Nota importante: Per compatibilità con il vecchio template se la stringa "target" è vuota o manca | |||
la funzione ritorna un valore di "1" | |||
]] | ]] | ||
function str.str_find( frame ) | function str.str_find( frame ) | ||
local new_args = str._getParameters( frame.args, {'source', 'target'} ); | |||
local source_str = new_args['source'] or ''; | |||
local target_str = new_args['target'] or ''; | |||
if target_str == '' then | |||
return 1; | |||
end | |||
local start = mw.ustring.find( source_str, target_str, 1, true ) | |||
if start == nil then | |||
start = -1 | |||
end | |||
return start | |||
end | end | ||
Riga 325: | Riga 299: | ||
find | find | ||
Questa funzione permette di cercare una stringa bersaglio o un pattern Lua all'interno di | |||
un'altra stringa. | |||
Uso: | |||
{{#invoke:String|find| | {{#invoke:String|find|stringa_sorgente|stringa_bersaglio|indice_iniziale|plain_flag}} | ||
O | |||
{{#invoke:String|find|source= | {{#invoke:String|find|source=stringa_sorgente|target=stringa_bersaglio|start=indice_iniziale|plain=plain_flag}} | ||
Parametri | |||
source: | source: La stringa in cui cercare | ||
target: | target: La stringa o pattern Lua da cercare | ||
start: | start: La posizione da cui iniziare la ricerca, se non specificato è 1 | ||
plain: | plain: Se è vero indica che la stringa target deve essere considerata come una | ||
testo normale e non come un pattern Lua, se non specificata è vera | |||
Se richiamata usando parametri nominati Mediawiki rimuoverà automaticamente tutti gli | |||
spazi iniziali e finali. In alcune circostanze questo può essere il comportamento | |||
desiderato, in altre si potrebbe volerli conservare. | |||
Questa funzione ritorna la prima posizione maggiore o uguale a "start" a partire dalla quale | |||
"target" si trova in "source". I caratteri della stringa sono numerati a partire da 1. | |||
Se "target" non viene trovato ritorna 0. Se "source" o "target" sono mancanti o vuoti ritorna 0. | |||
Questa funzione dovrebbe essere sicura per stringhe UTF-8. | |||
]] | ]] | ||
function str.find( frame ) | function str.find( frame ) | ||
local new_args = str._getParameters( frame.args, {'source', 'target', 'start', 'plain' } ); | |||
local source_str = new_args['source'] or ''; | |||
local pattern = new_args['target'] or ''; | |||
local start_pos = tonumber(new_args['start']) or 1; | |||
local plain = new_args['plain'] or true; | |||
if source_str == '' or pattern == '' then | |||
return 0; | |||
end | |||
plain = str._getBoolean( plain ); | |||
local start = mw.ustring.find( source_str, pattern, start_pos, plain ) | |||
if start == nil then | |||
start = 0 | |||
end | |||
return start | |||
end | end | ||
Riga 375: | Riga 348: | ||
replace | replace | ||
Questa funzione permette di rimpiazzare una stringa o pattern bersaglio con un'altra | |||
stringa. | |||
Uso: | |||
{{#invoke:String|replace| | {{#invoke:String|replace|stringa_sorgente|stringa_pattern|nuova_stringa|numero_di_sostituzioni|plain_flag}} | ||
O | |||
{{#invoke:String|replace|source= | {{#invoke:String|replace|source=stringa_sorgente|pattern=stringa_pattern|replace=nuova_stringa| | ||
count= | count=numero_di_sostituzioni|plain=plain_flag}} | ||
Parametri: | |||
source: | source: La stringa da cercare | ||
pattern: | pattern: La stringa o pattern Lua da trovare in source | ||
replace: | replace: Il testo di sostituzione | ||
count: | count: Il numero di volte in cui rimpiazzare la stringa, se non specificato tutte. | ||
plain: | plain: Se vero indica che il pattern deve essere considerato come testo normale e non | ||
come pattern Lua, il valore di default è vero | |||
]] | ]] | ||
function str.replace( frame ) | function str.replace( frame ) | ||
local new_args = str._getParameters( frame.args, {'source', 'pattern', 'replace', 'count', 'plain' } ); | |||
local source_str = new_args['source'] or ''; | |||
local pattern = new_args['pattern'] or ''; | |||
local replace = new_args['replace'] or ''; | |||
local count = tonumber( new_args['count'] ); | |||
local plain = new_args['plain'] or true; | |||
if source_str == '' or pattern == '' then | |||
return source_str; | |||
end | |||
plain = str._getBoolean( plain ); | |||
if plain then | |||
pattern = str._escapePattern( pattern ); | |||
replace = mw.ustring.gsub( replace, "%%", "%%%%" ); --Only need to escape replacement sequences. | |||
end | |||
local result; | |||
if count ~= nil then | |||
result = mw.ustring.gsub( source_str, pattern, replace, count ); | |||
else | |||
result = mw.ustring.gsub( source_str, pattern, replace ); | |||
end | |||
return result; | |||
end | end | ||
--[[ | --[[ | ||
Funzione per utilizzare string.rep in un template. | |||
]] | ]] | ||
function str.rep( frame ) | function str.rep( frame ) | ||
local repetitions = tonumber( frame.args[2] ) | |||
if not repetitions then | |||
if frame.args[2] == '' then -- se il secondo parametro è una stringa nulla ritorno una stringa nulla | |||
return '' | |||
else | |||
return str._error( 'la funzione rep si aspetta un secondo parametro con il numero di ripetizioni, ricevuto "' .. ( frame.args[2] or '' ) .. '"' ) | |||
end | |||
end | |||
return mw.ustring.rep( frame.args[1] or '', repetitions ) | |||
end | end | ||
--[[ | --[[ | ||
Funzione per decodificare una stringa codificata percentualmente. | |||
Richiama la funzione mw.uri.decode di scribunto, vedi | |||
https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual#mw.uri.decode | |||
]] | |||
function str.decode( frame ) | |||
local valid_enctype = { QUERY = true, WIKI = true, PATH = true} | |||
[ | local new_args = str._getParameters(frame.args, {'source', 'enctype'}) | ||
local source = new_args['source'] or '' | |||
local enc_type = new_args['enctype'] or 'QUERY' | |||
if not valid_enctype[enc_type] then | |||
enc_type = 'QUERY' | |||
end | |||
return mw.uri.decode(source, enc_type) | |||
end | |||
--[[ | |||
Funzione per semplificare stringhe con diacritici | |||
]] | |||
function str.collate( frame ) | |||
]] | local collation = { | ||
{ '[áàăắằẵẳâấầẫẩǎåǻäǟãȧǡąāảȁȃạặậḁⱥᶏᴂɐᶐɒ]' , 'a'}, | |||
{'[ÁÀĂẮẰẴẲÂẤẦẪẨǍÅÅǺÄǞÃȦǠĄĀẢȀȂẠẶẬḀȺᴁ]', 'A'}, | |||
{'[ḃḅḇbƀɓ]', 'b'}, | |||
{'[ḂḄḆɃ]', 'B'}, | |||
{'[ćĉčċçḉȼƈ]', 'c'}, | |||
{'[ĆĈČĊÇḈȻƇ]', 'C'}, | |||
{'[đḍḓḏðď]', 'd'}, | |||
{'[ĐḌḒḎÐĎ]', 'D'}, | |||
{'[éèèêếềễểěëẽėȩḝęēḗḕẻȅȇẹệḙḛǝ]', 'e'}, | |||
{'[ÉÈÈÊẾỀỄỂĚËẼĖȨḜĘĒḖḔẺȄȆẸỆḘḚƎ]', 'E'}, | |||
{'[ḟⅎ]', 'f'}, | |||
{'[ḞℲ]', 'F'}, | |||
{'[ǵğĝǧġģḡᵹɠ]', 'g'}, | |||
{'[ǴĞĜǦĠĢḠƓ]', 'G'}, | |||
{'[ĥȟḧḣḩħḥḫẖ]', 'h'}, | |||
{'[ĤȞḦḢḨĦḤḪ]', 'H'}, | |||
{'[íìĭîǐïḯĩįīỉȉȋịḭı]', 'i'}, | |||
{'[ÍÌĬÎǏÏḮĨĮĪỈȈȊỊḬİ]', 'I'}, | |||
{'[ĵǰ]', 'j'}, | |||
{'[Ĵ]', 'J'}, | |||
{'[ḱǩķ]', 'k'}, | |||
{'[ḰǨĶ]', 'K'}, | |||
{'[ĺľļłḷḹḽḻl·l·ŀƚⱡ]', 'l'}, | |||
{'[ĹĽĻŁḶḸḼḺL·L·ĿȽⱠ]', 'L'}, | |||
{'[ḿṁṃ]', 'm'}, | |||
{'[ḾṀṂ]', 'M'}, | |||
{'[ńǹňñṅņṇṋṉ]', 'n'}, | |||
{'[ŃǸŇÑṄŅṆṊṈ]', 'N'}, | |||
{'[óòŏôốồỗổǒöȫőõṍṏȭȯȱøǿǫǭōṓṑỏȍȏơớờỡởợọộ]', 'o'}, | |||
{'[ÓÒŎÔỐỒỖỔǑÖȪŐÕṌṎȬȮȰØǾǪǬŌṒṐỎȌȎƠỚỜỠỞỢỌỘ]', 'O'}, | |||
{'[ṕṗ]', 'p'}, | |||
{'[ṔṖ]', 'P'}, | |||
{'[ŕřṙŗȑȓṛṝṟ]', 'r'}, | |||
{'[ŔŘṘŖȐȒṚṜṞ]', 'R'}, | |||
{'[śṥŝšṧṡşṣṩș]', 's'}, | |||
{'[ŚṤŜŠṦṠŞṢṨȘ]', 'S'}, | |||
{'[ťṫẗţṭțṱṯ]', 't'}, | |||
{'[ŤṪŢṬȚṰṮ]', 'T'}, | |||
{'[úùŭûǔůüǘǜǚǖűũṹųūṻủȕȗưứừữửựụṳṷṵʉ]', 'u'}, | |||
{'[ÚÙŬÛǓŮÜǗǛǙǕŰŨṸŲŪṺỦȔȖƯỨỪỮỬỰỤṲṶṴɄ]', 'U'}, | |||
{'[ṽṿʋ]', 'v'}, | |||
{'[ṼṾƲ]', 'V'}, | |||
{'[ẃẁŵẘẅẇẉⱳ]', 'w'}, | |||
{'[ẂẀŴ̊ẄẆẈⱲ]', 'W'}, | |||
{'[ýỳŷẙÿỹẏȳỷỵɏƴ]', 'y'}, | |||
{'[ÝỲŶ̊ŸỸẎȲỶỴɎƳ]', 'Y'}, | |||
{'[źẑžżẓẕƶȥʐⱬ]', 'z'}, | |||
{'[ŹẐŽŻẒẔƵȤʐⱫ]', 'Z'}, | |||
} | |||
local new_args = str._getParameters(frame.args, {'source'}) | |||
local source = new_args['source'] or '' | |||
--local source = mw.ustring.toNFC(source) | |||
for _, el in ipairs(collation) do | |||
source = mw.ustring.gsub( source, el[1], el[2]) | |||
end | |||
return source | |||
end | end | ||
--[[ | --[[ | ||
Funzione per estrarre da un titolo la stringa adatta all'ordinamento alfabetico. | |||
]] | ]] | ||
function str. | |||
function str.titolo_alfa(frame) | |||
-- Evito "I", "A", "Die"... che darebbero molte false corrispondenze in lingue diverse | |||
local articoli = {"Il ", "Lo ", "La ", "L'", "Gli ", "Le ", "Un ", "Uno ", "Una ", "Un'", "The ", "An ", "Les ", "El ", "Los ", "Las ", "Der ", "Das "} | |||
local source = frame.args[1] | |||
if not source or source == '' then | |||
source = mw.title.getCurrentTitle().text | |||
end | |||
if not source or source == '' then | |||
return '' | |||
end | |||
source = mw.ustring.gsub(source, ' %(.*%)$', '') | |||
source = str.collate( { args = { source } } ) | |||
source = mw.ustring.gsub(source, "^['%(%.¡¿ ]*", '') | |||
for _,article in ipairs(articoli) do | |||
source = mw.ustring.gsub(source, "^(" .. article .. ")(.*)$", "%2, %1") | |||
end | |||
source = mw.ustring.gsub(source, '^%l', mw.ustring.upper) | |||
source = mw.text.trim(source) | |||
return source | |||
end | |||
-- ================================================================= | |||
-- Classe per gestire i parametri | |||
-- ================================================================= | |||
local Param = {} | |||
Param.__index = Param | |||
function Param.new(par_name, alt_name) | |||
if par_name ~= "$index" and not mw.ustring.find(par_name, '#') then par_name = par_name .. '#' end; | |||
return setmetatable({ | |||
name = par_name, | |||
base_name = mw.ustring.gsub(par_name, ' ?#', '', 1), | |||
alt = alt_name | |||
}, Param) | |||
end | |||
function Param:get_other_value(args, index) | |||
if self.name == '$index' then | |||
return tostring(index), true | |||
else | |||
return args[mw.ustring.gsub(self.name, '#', tostring(index), 1)] or '', false | |||
end | |||
end | |||
function Param:get_first_value(args, index, base_index) | |||
function value_or_nil (s) | |||
if s and s ~= '' then return s end | |||
return nil | |||
end | |||
if self.name == '$index' then | |||
return tostring(index), true | |||
end | |||
if index == base_index then | |||
return value_or_nil(args[mw.ustring.gsub(self.name, '#', tostring(index), 1)]) or | |||
value_or_nil(args[self.base_name]) or value_or_nil(args[self.alt]) or '', false | |||
else | |||
return value_or_nil(args[mw.ustring.gsub(self.name, '#', tostring(index), 1)]) or | |||
value_or_nil(args[self.alt]) or '', false | |||
end | |||
end | |||
setmetatable(Param, { __call = function(_, ...) return Param.new(...) end }) | |||
-- ================================================================= | |||
-- fine dichiarazione classe per parametro | |||
-- ================================================================= | |||
-- ================================================================= | |||
-- Classe per gestire il messaggio | |||
-- ================================================================= | |||
local Message = {} | |||
Message.__index = Message | |||
function Message.new(msg) | |||
-- converto parentesi graffe che sono state precedute da "\" | |||
msg = mw.ustring.gsub(msg, '\\{', '{') | |||
msg = mw.ustring.gsub(msg, '\\}', '}') | |||
local frame = mw.getCurrentFrame():getParent() or mw.getCurrentFrame() | |||
return setmetatable({ | |||
msg = msg, | |||
values = {}, | |||
frame = frame, | |||
}, Message) | |||
end | |||
function Message:reset_values() | |||
self.values = {} | |||
end | |||
function Message:add_value(value) | |||
self.values[#self.values+1] = value | |||
end | end | ||
function Message:text() | |||
return self.frame:preprocess(mw.message.newRawMessage(self.msg, self.values):plain()) | |||
end | |||
setmetatable(Message, { __call = function(_, ...) return Message.new(...) end }) | |||
-- ================================================================= | |||
-- fine dichiarazione classe per messaggio | |||
-- ================================================================= | |||
--[[ | --[[ | ||
Funzione per unire una o più liste di valori in una stringa. | |||
Uso: | |||
{{#invoke:String|arraytostring|par1=xxx|par2=xxx....|parn=xxxx|msg=msg|separator=|congiunzione=|pre=|post=|lista=}} | |||
Parametri: | |||
par1...parn: i nomi base dei parametri da inserire nel messsaggio, devono contenere il carattere '#' che precisa la | |||
posizione in cui inserire l'indice. Se viene valorizzato a '$index' avrà automaticamente il valore del | |||
contatore. | |||
msg: il messaggio (cioè la riga unitaria) in cui eventuali caratteri '{', '}' dovranno essere | |||
preceduti da '\', mentre una "|" dovrà essere inserita con il template {{!}}. | |||
I valori da sostituire sono da inserire come $n ($1 sarà sostituito dal | |||
valore di par1, $2 dal valore di par2, ecc...) | |||
separatore: La stringa da inserire tra ogni valore | |||
congiunzione: La stringa da inserire invece di separatore tra l'ultimo e il penultimo valore. Se | |||
non precisato viene usato il valore di separatore | |||
pre: eventuale stringa che precede l'unione delle stringhe | |||
post: eventuale stringa che segue l'unione delle stringhe | |||
indentazione: una stringa da ripetere cumulativamente per ogni messaggio (tipicamente ' ') | |||
lista: se valorizzata a: | |||
'puntata' imposta i parametri per una lista puntata | |||
'ordinata' imposta i parametri per una lista ordinata | |||
'infobox' imposta l'unione come una lista, eccetto che nel caso ci sia | |||
solo un elemento | |||
Se lista è valorizzata separatore/congiunzione/pre/post sono ignorati, salvo il caso di 'infobox' e la | |||
lista contenga solo un elemento. | |||
nmin = indice iniziale da cui partire a scandire i parametri (di default pari a 1) | |||
nmax = indice massimo a cui arrivare con i parametri (se non precisato illimitato) | |||
nobbligatori = l'indice minimo che deve essere valutato anche in presenza di buchi nella sequenza (comunque l'indice massimo | |||
che viene valutato è nmax) | |||
baseIndex = valore dell'indice che può essere sostituito da stringa nulla (default = 1) | |||
Esempi di chiamata: | |||
{{#invoke:string:arraytostring|par1=var#|separatore=,|congiunzione=#32;e#32;}} | |||
{{#invoke:string:arraytostring|par1=disegnatore #|par2=disegnatore # nota|msg = $1 <small>$2</small>|lista=infobox }} | |||
{{#invoke:string:arraytostring|par1=editore #|par2=etichetta #|par3=editore # nota| msg=$1 \{\{#if:$2{{!}}$2 <small>$3</small>\}\}|lista=infobox }} | |||
]] | ]] | ||
function str. | function str.arraytostring(frame) | ||
local base_args = frame.args | |||
local params = {} | |||
if not base_args then return str._error('Lista parametri vuota') end | |||
-- carico la lista dei parametri | |||
local index = 1 | |||
while true do | |||
local par_name = base_args['par' .. index] or (index == 1 and base_args['par']) or '' | |||
if par_name == '' then break end | |||
--carico eventuale nome alternativo per il primo parametro | |||
local alt_name = base_args['altpar' .. index] or (index == 1 and base_args['altpar']) or nil | |||
params[index] = Param(par_name, alt_name) | |||
index = index + 1 | |||
end | |||
--carico il messaggio | |||
local msg = base_args.msg or '$1' | |||
--if msg == '' then return str._error('Manca il messaggio da riprodurre.') end | |||
local message = Message(msg) | |||
elements = {} | |||
-- carico gli altri parametri di formattazione | |||
local Nmax = tonumber(base_args.Nmax) or tonumber(base_args.nmax) or 0 | |||
local base_index = tonumber(base_args.baseindex) or tonumber(base_args.baseIndex) or 1 | |||
local index = tonumber(base_args.Nmin) or tonumber(base_args.nmin) or base_index | |||
local Nobbligatori = tonumber(base_args.Nobbligatori) or tonumber(base_args.nobbligatori) or base_index-1 | |||
local indentazione = base_args.indentazione or nil | |||
local args = frame:getParent().args | |||
-- estraggo il primo valore | |||
local found = false | |||
for i, param in ipairs(params) do | |||
local v, is_index = param:get_first_value(args, index, base_index) | |||
if (not(is_index) or base_index<=Nobbligatori) and v ~= '' then found = true end | |||
message:add_value(mw.text.trim(v)) | |||
end | |||
if found then | |||
elements[#elements+1] = message:text() | |||
index = index + 1 | |||
end | |||
-- elaboro i valori successivi | |||
while true do | |||
if Nmax > 0 and index > Nmax then break end | |||
message:reset_values() | |||
found = false | |||
for i, param in ipairs(params) do | |||
local v, is_index = param:get_other_value(args, index) | |||
if (not(is_index) or index<=Nobbligatori) and v ~= '' then found = true end | |||
message:add_value(mw.text.trim(v)) | |||
end | |||
if found then | |||
elements[#elements+1] = message:text() | |||
elseif index >= Nobbligatori then | |||
break | |||
end | |||
index = index + 1 | |||
end | |||
if #elements == 0 then return '' end | |||
-- carico separatori, congiunzione, pre e postazione | |||
local pre, post, separatore, congiunzione, indent = '', '', '', '', '' | |||
local lista = base_args.lista or '' | |||
if lista == 'puntata' or (lista =='infobox' and #elements >1) then | |||
pre = '<UL><LI>' | |||
post = '</LI>\n</UL>' | |||
separatore = '</LI>\n<LI>' | |||
congiunzione = separatore | |||
elseif lista == 'ordinata' then | |||
pre = '<OL><LI>' | |||
post = '</LI>\n</OL>' | |||
separatore = '</LI>\n<LI>' | |||
congiunzione = separatore | |||
else | |||
pre = base_args.pre or '' | |||
post = base_args.post or '' | |||
separatore = base_args.separatore or '' | |||
congiunzione = base_args.congiunzione or separatore | |||
end | |||
if indentazione then | |||
local current_indentazione = indentazione | |||
for i, msg in ipairs(elements) do | |||
elements[i] = current_indentazione .. elements[i] | |||
current_indentazione = current_indentazione .. indentazione | |||
end | |||
end | |||
return pre .. mw.text.listToText(elements, separatore, congiunzione) .. post | |||
end | end | ||
--[[ | --[[ | ||
Funzione per unire una lista di valori in una stringa. | |||
Uso: | |||
{{#invoke:String|listtostring|par_number=xxx|msg=msg|separator=|congiunzione=|pre=|post=|lista=}} | |||
Parametri: | |||
par_number: il numero di parametri che compongono il messaggio | |||
msg: il messaggio (cioè la riga unitaria) in cui eventuali caratteri '{', '}' dovranno essere | |||
preceduti da '\', mentre una "|" dovrà essere inserita con il template {{!}}. | |||
I valori da sostituire sono da inserire come $n (nel primo messaggio $1 sarà sostituito dal parametro posizionale di | |||
posizione Nmin, $2 da Nmin+2, ecc...., nel secondo messaggio $1 sarà sostituito dal parametro posizionale Nmin+par_number, | |||
$2 da Nmin+par_number+2, ec....) | |||
valore di par1, $2 dal valore di par2, ecc...) | |||
separatore: La stringa da inserire tra ogni valore | |||
congiunzione: La stringa da inserire invece di separatore tra l'ultimo e il penultimo valore. Se | |||
non precisato viene usato il valore di separatore | |||
pre: eventuale stringa che precede l'unione delle stringhe | |||
post: eventuale stringa che segue l'unione delle stringhe | |||
lista: se valorizzata a: | |||
'puntata' imposta i parametri per una lista puntata | |||
'ordinata' imposta i aprametri per una lista ordinata | |||
'infobox' imposta l'unione come una lista, eccetto che nel caso ci sia | |||
solo un elemento | |||
Se lista è valorizzata separatore/congiunzione/pre/post sono ignorati, salvo il caso di 'infobox' e la | |||
lista contenga solo un elemento. | |||
nmax = indice massimo a cui arrivare con i parametri (se non precisato illimitato) | |||
nobbligatori = l'indice minimo che deve essere valutato anche in presenza di buchi nella sequenza (comunque l'indice massimo | |||
che viene valutato è nmax) | |||
baseIndex = valore del primo parametro posizionale da cui cominciare a leggere (default = 1) | |||
]] | ]] | ||
function str. | |||
function str.listtostring(frame) | |||
local base_args = frame.args | |||
local params = {} | |||
if not base_args then return str._error('Lista parametri vuota') end | |||
-- carico la lista dei parametri | |||
local base_index = tonumber(base_args.base_index) or 1 | |||
local par_number = tonumber(base_args.par_number) or 1 | |||
local Nmax = tonumber(base_args.nmax) or 0 | |||
local Nobbligatori = tonumber(base_args.nobbligatori) or base_index-1 | |||
--carico il messaggio | |||
local message = Message(base_args.msg or '$1') | |||
elements = {} | |||
-- carico gli altri parametri di formattazione | |||
local index = base_index | |||
local args = frame:getParent().args | |||
-- elaboro i valori successivi | |||
local found = true | |||
while true do | |||
if Nmax > 0 and index > Nmax then break end | |||
message:reset_values() | |||
found = false | |||
for i = index, index+par_number-1 do | |||
message:add_value(args[i] or '') | |||
if args[i] then | |||
found = true | |||
end | |||
end | |||
if found then | |||
elements[#elements+1] = message:text() | |||
elseif index > Nobbligatori then | |||
break | |||
end | |||
index = index + par_number | |||
end | |||
if #elements == 0 then return '' end | |||
-- carico separatori, congiunzione, pre e postazione | |||
local pre, post, separatore, congiunzione = '', '', '', '' | |||
local lista = base_args.lista or '' | |||
if lista == 'puntata' or (lista =='infobox' and #elements >1) then | |||
pre = '<UL><LI>' | |||
post = '</LI>\n</UL>' | |||
separatore = '</LI>\n<LI>' | |||
congiunzione = separatore | |||
elseif lista == 'ordinata' then | |||
pre = '<OL><LI>' | |||
post = '</LI>\n</OL>' | |||
separatore = '</LI>\n<LI>' | |||
congiunzione = separatore | |||
else | |||
pre = base_args.pre or '' | |||
post = base_args.post or '' | |||
separatore = base_args.separatore or '' | |||
congiunzione = base_args.congiunzione or separatore | |||
end | |||
return pre .. mw.text.listToText(elements, separatore, congiunzione) .. post | |||
end | end | ||
--[[ | --[[ | ||
Funzione di aiuto che popola la lista di argomenti, dato che l'utente può voler utilizzare sia | |||
parametri nominati che non nominati. Questo è rilevante perchè gli spazi iniziali iniziali | |||
e finali dei parametri nominati sono eliminati, mentre quelli dei parametri non nominati | |||
non lo sono. Secondo l'applicazione si potrebbe a volte conservare o rimuovere gli spazi. | |||
]] | ]] | ||
function str._getParameters( frame_args, arg_list ) | function str._getParameters( frame_args, arg_list ) | ||
local new_args = {}; | |||
local index = 1; | |||
local value; | |||
for i,arg in ipairs( arg_list ) do | |||
value = frame_args[arg] | |||
if value == nil then | |||
value = frame_args[index]; | |||
index = index + 1; | |||
end | |||
new_args[arg] = value; | |||
end | |||
return new_args; | |||
end | end | ||
--[[ | --[[ | ||
Funzione di appoggio per gestire i messaggi di errore. | |||
]] | ]] | ||
function str._error( error_str ) | function str._error( error_str ) | ||
local frame = mw.getCurrentFrame(); | |||
local error_category = frame.args.error_category or 'Errori riportati dal modulo String'; | |||
local ignore_errors = frame.args.ignore_errors or false; | |||
local no_category = frame.args.no_category or false; | |||
if str._getBoolean(ignore_errors) then | |||
return ''; | |||
end | |||
local error_str = '<strong class="error">Errore nel modulo String: ' .. error_str .. '</strong>'; | |||
if error_category ~= '' and not str._getBoolean( no_category ) then | |||
error_str = '[[Categoria:' .. error_category .. ']]' .. error_str; | |||
end | |||
return error_str; | |||
end | end | ||
--[[ | --[[ | ||
Funzione di appoggio per interpretare le stringhe come valori booleane | |||
]] | ]] | ||
function str._getBoolean( boolean_str ) | function str._getBoolean( boolean_str ) | ||
local boolean_value; | |||
if type( boolean_str ) == 'string' then | |||
boolean_str = boolean_str:lower(); | |||
if boolean_str == 'false' or boolean_str == 'no' or boolean_str == '0' | |||
or booleean_str == 'falso' or boolean_str == '' then | |||
boolean_value = false; | |||
else | |||
boolean_value = true; | |||
end | |||
elseif type( boolean_str ) == 'boolean' then | |||
boolean_value = boolean_str; | |||
else | |||
error('Nessun valore booleano trovato' ); | |||
end | |||
return boolean_value | |||
end | end | ||
--[[ | --[[ | ||
Funzione di appoggio per aggiungere un carattere di escape a tutti i caratteri speciali, | |||
così da trattare una stringa come testo normale e non come pattern di Lua. | |||
]] | ]] | ||
function str._escapePattern( pattern_str ) | function str._escapePattern( pattern_str ) | ||
return mw.ustring.gsub( pattern_str, "([%(%)%.%%%+%-%*%?%[%^%$%]])", "%%%1" ); | |||
end | end | ||
return str | return str | ||
-- Version history: | |||
-- 29/3/2013 traduzione iniziale da en:module:String versione 540627185 del 26 febbraio 2013 | |||
-- 07/05/2013 aggiunta funzione rep da en:module:String versione 552254999 del 26 aprile 2013 | |||
-- 19/08/2013 aggiunta funzione arraytostring |