Etichette: Modifica da mobile Modifica da web per mobile |
|
| 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: se settato a 'true' o 1, ogni condizione di errore ritornerà una stringa vuota
| |
| piuttosto che un messaggio di errore.
| |
|
| |
| 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: 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
| |
|
| |
| ]]
| |
|
| |
| local str = {}
| |
|
| |
| --[[
| |
| len
| |
|
| |
| Questa funzione ritorna la lunghezza di una stringa.
| |
|
| |
| Uso:
| |
| {{#invoke:String|len|stringa|}}
| |
| O
| |
| {{#invoke:String|len|s=stringa}}
| |
|
| |
| Parametri
| |
| 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 )
| |
| local new_args = str._getParameters( frame.args, {'s'} );
| |
| local s = new_args['s'] or '';
| |
| return mw.ustring.len( s )
| |
| end
| |
|
| |
| --[[
| |
| sub
| |
|
| |
| Questa funzione ritorna la sottostringa di una stringa bersaglio, come indicato dagli indici
| |
|
| |
| Uso:
| |
| {{#invoke:String|sub|stringa_bersaglio|indice_iniziale|indice_finale}}
| |
| O
| |
| {{#invoke:String|sub|s=stringa_bersaglio|i=indice_iniziale|j=indice_finale}}
| |
|
| |
| Parameters
| |
| s: La stringa da cui estrarre una sottostringa
| |
| i: La posizione iniziale del primo carattere della sottostringa da ritornare, se non
| |
| 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 )
| |
| 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
| |
|
| |
| --[[
| |
| Questa funzione implementa tutte le caratteristiche di {{str sub}} e viene mantenuta per motivi
| |
| di compatibilità con template più vecchi.
| |
| ]]
| |
| 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
| |
|
| |
| --[[
| |
| 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: La stringa da cercare
| |
| pattern: Il pattern da cercare nella stringa
| |
| 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
| |
| 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.
| |
| nomatch: Il valore da ritornare se non ci sono corrispondenze, invece di ritornare
| |
| un errore.
| |
|
| |
| 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)
| |
| return str._match(frame.args)
| |
| end
| |
|
| |
| --[[
| |
| 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
| |
|
| |
| --[[
| |
| pos
| |
|
| |
| Questa funzione ritorna il carattere della stringa in posizione pos.
| |
|
| |
| Uso:
| |
| {{#invoke:String|pos|stringa_bersaglio|indice}}
| |
| O
| |
| {{#invoke:String|pos|target=stringa_bersaglio|pos=indice}}
| |
|
| |
| Parametri
| |
| target: La stringa in cui cercare
| |
| 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 )
| |
| 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
| |
|
| |
| --[[
| |
| 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 )
| |
| 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
| |
|
| |
| --[[
| |
| find
| |
|
| |
| Questa funzione permette di cercare una stringa bersaglio o un pattern Lua all'interno di
| |
| un'altra stringa.
| |
|
| |
| Uso:
| |
| {{#invoke:String|find|stringa_sorgente|stringa_bersaglio|indice_iniziale|plain_flag}}
| |
| O
| |
| {{#invoke:String|find|source=stringa_sorgente|target=stringa_bersaglio|start=indice_iniziale|plain=plain_flag}}
| |
|
| |
| Parametri
| |
| source: La stringa in cui cercare
| |
| target: La stringa o pattern Lua da cercare
| |
| start: La posizione da cui iniziare la ricerca, se non specificato è 1
| |
| 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 )
| |
| 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
| |
|
| |
| --[[
| |
| replace
| |
|
| |
| Questa funzione permette di rimpiazzare una stringa o pattern bersaglio con un'altra
| |
| stringa.
| |
|
| |
| Uso:
| |
| {{#invoke:String|replace|stringa_sorgente|stringa_pattern|nuova_stringa|numero_di_sostituzioni|plain_flag}}
| |
| O
| |
| {{#invoke:String|replace|source=stringa_sorgente|pattern=stringa_pattern|replace=nuova_stringa|
| |
| count=numero_di_sostituzioni|plain=plain_flag}}
| |
|
| |
| Parametri:
| |
| source: La stringa da cercare
| |
| pattern: La stringa o pattern Lua da trovare in source
| |
| replace: Il testo di sostituzione
| |
| count: Il numero di volte in cui rimpiazzare la stringa, se non specificato tutte.
| |
| 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 )
| |
| 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
| |
|
| |
| --[[
| |
| Funzione per utilizzare string.rep in un template.
| |
| ]]
| |
|
| |
| 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
| |
|
| |
| --[[
| |
| 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
| |
|
| |
| --[[
| |
| Funzione per estrarre da un titolo la stringa adatta all'ordinamento alfabetico.
| |
| ]]
| |
|
| |
| 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 or ''
| |
| }, 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
| |
|
| |
| 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.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 ''
| |
| 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(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(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
| |
|
| |
| --[[
| |
| 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.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
| |
|
| |
| --[[
| |
| 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 )
| |
| 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
| |
|
| |
| --[[
| |
| Funzione di appoggio per gestire i messaggi di errore.
| |
| ]]
| |
| 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
| |
|
| |
| --[[
| |
| Funzione di appoggio per interpretare le stringhe come valori booleane
| |
| ]]
| |
| 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
| |
|
| |
| --[[
| |
| 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 )
| |
| return mw.ustring.gsub( pattern_str, "([%(%)%.%%%+%-%*%?%[%^%$%]])", "%%%1" );
| |
| end
| |
|
| |
| 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
| |