Modul: Limbi

Instructiuni de folosire
Acesta este un modul scris în Lua . Următoarele instrucțiuni sunt incluse în sub- modulul: Limba / om ( schimbări · istorie )
Sandbox: Formă: Limbi / sandbox ( modificări · istoric ) · Test: Modul: Limbi / test ( modificat · Istoric · Executare )

Formați Lua pentru a implementa funcțiile șablonului {{ Nomelingua }}, {{ languages }} și șabloanelor asociate acestora și pentru a oferi aceeași funcționalitate altor module Lua fără a fi nevoie să depindeți de apelurile către același șablon.

Funcții

Pentru module Lua

Modulul pune la dispoziție unele funcții pentru alte module Lua, pentru a le utiliza trebuie mai întâi să încărcați modulul cu instrucțiunea: local lg = require( "Modulo:Linguaggi" );

Funcțiile vor fi disponibile ca lg. nomefunzione nume de lg. nomefunzione ( lg este doar un exemplu de nume, îl puteți alege pe cel pe care îl preferați atâta timp cât apelați funcțiile în mod consecvent, de exemplu puteți utiliza local lingue = require( "Modulo:Linguaggi" ); în acest caz funcțiile va fi numit ca lingua. nomefunzione

esiste( code ): returnează true dacă codul se potrivește cu o limbă, false caz contrar
get_nome( code , maiuscolo , default ): returnează perechea numele limbii corespunzătoare codului și codul normalizat (de exemplu , în cazul în care codul este „Engleză“ se întoarce ( în limba engleză, en). Dacă majuscule este adevărat prima literă a numelui returnat este capitalizată. În cazul în care nu găsește o limbă corespunzătoare codului returnează valoarea implicită dacă aceasta este definită, în caz contrar returnează șirul nul '' și valoarea codului trecut inițial.
get_voce( code ): returnează numele vocii dedicate limbii corespunzătoare codului . Dacă modulul nu găsește intrarea, returnează șirul nul ''
lingue( lista_di_lingue ): returnează limbile corespunzătoare listei_de_ limbi formatate conform șablonului {{ limbi }}. Dacă trebuie să treceți un șir mai degrabă decât o listă, transformați-l într-o listă, de exemplu apelând funcția prin lg.lingue( { stringa } ) șirului între paranteze: lg.lingue( { stringa } )

Pentru șabloane

Modulul include, de asemenea, funcții pentru implementarea directă a unor șabloane, la care se face referire la sintaxa de utilizare:

lingue( frame ): pe lângă faptul că acționează ca o interfață directă pentru alte module Lua, implementează și modulul {{ Languages }}
nomecompleto( frame ): implementează caracteristicile {{ numele limbii }}
nome( frame ): implementează caracteristicile {{ nume limbă / nume }}
voce( frame ): implementează funcțiile {{ nume de limbă / voce }}

Documentație

tabella: invocat dintr-o pagină wiki cu {{#Invoke:Linguaggi|tabella}} returnează un tabel cu toate codurile și numele și linkurile către paginile limbilor recunoscute.

Note tehnice

Datele utilizate sunt încărcate în modulul modulului: Limbi / Configurare , care conține două tabele, primul dintr-un alias de limbă care asociază un cod standard (în general codul de limbă ISO_639-3 ) fiecărui cod recunoscut pentru o limbă. Al doilea care asociază fiecărui cod standard numele limbii și pagina acesteia de pe it.wiki.

Pentru a adăuga un nou alias pentru o limbă deja recunoscută de modul, trebuie doar să adăugați o linie în format în tabelul language_config.alias

 [ "alias" ] = "standard_code" ',

unde alias este aliasul de inserat și code_standard este codul standard care trebuie deja inserat în tabelul language_config.codici .

Pentru a insera o nouă limbă, trebuie doar să adăugați o linie în format în tabelul language_config.codici :

 [ "standard_code" ] = { "language_name" , "article" },

unde standard_code este codul standard utilizat de program (utilizați în ordine de preferință codul ISO 639-1 (două litere) în caz contrar ISO 639-2 (trei litere), dacă nu există nici unul, folosiți un alt cod, atâta timp cât nu este un cod ISO 639-1 sau ISO 639-2 dedicat unei alte limbi), numele limbii numele limbii așa cum ar trebui să fie afișat pe videoclip și articolul articolului numele articolului Wikipedia dedicat limbii. Pentru a introduce coduri de limbă alternativă, consultați instrucțiunile din paragraful de mai sus.

Vă rugăm să rețineți: codurile de limbă și pseudonimele trebuie introduse cu litere mici sau nu vor fi recunoscute.

 limba locala = {}
local getArgs = require ( 'Modul: Argumente' ). getArgs

- Fișier de configurare care conține două tabele:
- lg.alias: pentru a normaliza aliasurile la un singur cod
- lg.codici: acel cod dat returnează o matrice care conține
- numele limbii și link către articolul de pe it.wiki dedicat limbii
local lg = mw . loadData ( „Modul: Limbi / Configurare” );

- returnează numele intrării corespunzătoare „codului”. Dacă „cod” nu se potrivește cu niciunul
- limba inserată în tabel returnează un șir nul
limbajul funcțional . get_voce ( cod )
dacă codul == zero, apoi returnați ” sfârșit
cod local = mw . ustring . mai mic ( cod )
dacă lg . alias [ cod ] apoi cod = lg . alias [ cod ] sfârșit
limba locală = lg . coduri [ cod ]
dacă limba atunci
returnează limba [ 2 ]
Sfârșit
intoarce ''
Sfârșit

- returnează adevărat dacă „codul” se potrivește cu o limbă, fals în caz contrar
limbajul funcțional . există ( cod )
dacă cod == nul sau cod == ”, atunci returnează sfârșitul fals
dacă lg . alias [ cod ] apoi cod = lg . alias [ cod ] sfârșit
dacă lg . coduri [ cod ] apoi returnează sfârșitul adevărat
returnează fals
Sfârșit

- Returnează numele limbii standard corespunzător „codului” și codului normalizat
- la cea a tabelului de coduri.
- Dacă „cod” nu corespunde niciunei limbi inserate în tabel, returnează valoarea implicită
- sau șir nul dacă acest lucru nu este indicat și codul necesar. Dacă capitalul este adevărat
- numele este returnat odată cu prima literă mare.
limbajul funcțional . get_name ( cod , majuscule , implicit )
nume local = implicit sau "
dacă cod ~ = nul și cod ~ = " atunci
cod = mw . ustring . mai mic ( cod )
dacă lg . alias [ cod ] apoi cod = lg . alias [ cod ] sfârșit
- elimină a doua parte din codurile de tip IT-IT
cod = mw . ustring . gsub ( cod , '(% l +)% -. *' , '% 1' )
limba locală = lg . coduri [ cod ]
dacă limba atunci nume = limba [ 1 ] sfârșește
Sfârșit
dacă mai mare atunci
nume = mw . ustring . gsub ( nume , '^% l' , mw . ustring . upper )
Sfârșit
returnează numele , codul
Sfârșit

- funcție de interfață pentru șablon: numele limbii / voce
limbajul funcțional . element ( cadru )
cod local = cadru . args [ 1 ]
dacă cod == nul sau cod == ” atunci
intoarce ''
Sfârșit
returnează limba . get_voce ( cod )
Sfârșit

- funcția de interfață pentru șablon: numele / numele limbii
limbajul funcțional . nume ( cadru )
majuscule locale = false
cod local = cadru . args [ 1 ] sau ''
implicit local = ( cadru . args [ 2 ] == 'v' și '' ) sau cod
dacă cadru . args [ 'M' ] ~ = zero și cadru . args [ 'M' ] ~ = '' atunci
majuscule = adevărat
Sfârșit
returnează limba . get_name ( cod , majuscule , implicit ), _

Sfârșit

- funcția de interfață pentru șablon: numele limbii
limbajul funcțional . nume complet ( cadru )
cod local = cadru . args [ 1 ]
dacă cod == nul sau cod == ” atunci
intoarce ''
Sfârșit
majuscule locale = false
dacă cadru . args [ 'M' ] ~ = zero și cadru . args [ 'M' ] ~ = '' atunci
majuscule = adevărat
Sfârșit
item local = limba . get_voce ( cod )
nume local = limba . get_name ( cod , majuscule , cod )
dacă numele == "" și intrarea ~ = "" atunci
dacă mai mare atunci
nume = mw . ustring . gsub ( intrare , „^% l” , mw . ustring . upper )
altceva
nume = element
Sfârșit
Sfârșit
dacă intrarea == "" atunci
returnează numele
altceva
return table.concat ({ '[[' , entry , "|" , name , "]]" })
Sfârșit
Sfârșit

- funcția de interfață pentru șablon: Limbi, dacă și parametrul este trecut
--use_code (indiferent de valoarea sa), apoi textul afișat între paranteze
- este normalizat la acel standard al limbii, mai degrabă decât să fie acela
--trecut
- În plus, poate primi dacă parametrul return_error este adevărat returnează în cazul
- codurile lingvistice nu au fost găsite în tabel, un tabel suplimentar cu coduri greșite
--return_error este bifat numai dacă funcția este apelată de la un modul Lua
- dacă este apelat dintr-un șablon, acesta este întotdeauna fals
limbajul funcțional . limbi ( cadru )
listă de limbi locale = { }
- Dacă sunteți apelat prin #invoke, utilizați argumentele transmise șablonului de invocare.
- În caz contrar, în scopuri de testare, presupuneți că argumentele sunt transmise direct
argumente locale
local return_error = false
listă de erori locale = {}
if frame == mw . getCurrentFrame () atunci
args = cadru : getParent (). argumente
altceva
args = cadru
return_error = args [ 'return_error' ] sau false
Sfârșit
limba locală , normalized_code , code_to_show

local yet_processed = {}
pentru _ , cod în ipairs ( args ) do
limba , normalized_code = limba . get_name ( cod )
normalized_code = mw . ustring . superior ( normalized_code )
dacă nu este încă_procesat [ normalized_code ] atunci
dacă limba ~ = "" atunci
lingua_list [ # lingue_list + 1 ] = '<abbr title = "' .. language .. '">' .. code_normalized .. "</abbr>"
yet_processed [ normalized_code ] = adevărat
altceva
languages_list [ # languages_list + 1 ] = cod
dacă return_error, atunci error_list [ # error_list + 1 ] = cod final
Sfârșit
Sfârșit
Sfârșit
răspuns local
dacă # limbi_listă > 0 atunci
reply = '(<span style = "font-weight: bolder; font-size: 80%">' .. table.concat ( languages_list , ", & nbsp;" ) .. "</span>)"
altceva
reply = "
Sfârșit
răspuns = răspuns
dacă # eroare_listă > 0 atunci
returnează răspuns , listă de erori
altceva
returnează răspunsul
Sfârșit
Sfârșit

- ================================================== ======
- Returnează șirul txt inserat într-o etichetă <span> cu indicat
- codul de limbă al textului (limba_cod) și sensul
- citire (stânga sau dreapta).
- Parametrul „italic” vă permite să indicați dacă textul
- trebuie să fie cursiv, are trei valori:
- - d: consultați tabelele de configurare pentru limba
- - s: cursiv forțat activ
- - n: forța cursivă este dezactivată (este valoarea implicită)
- ================================================== ======
limbajul funcțional . _lang_text ( args )
local txt = args . txt sau args [ 2 ]
dacă nu txt, apoi întoarceți '' end
local language_code = args . lang sau args [ 1 ]
local direction = "ltr"
dacă language_code atunci
language_code = mw . ustring . inferior ( language_code )
language_code = lg . alias [ language_code ] sau language_code
scris local = lg . scrie [ language_code ]
dacă scrii atunci
direcție = scriere [ 1 ]
dacă # scris > 1 atunci language_code = scris [ 2 ] sfârșit
Sfârșit
Sfârșit
local set_italic = args . cursiva sau "n"
dacă set_italic ~ = "n" atunci
italic local = false
dacă set_italic : lower () == 's' atunci
italic = adevărat
elseif language_code și lg . coduri [ language_code ] atunci
italic = nu lg . coduri [ language_code ] [ 3 ]
altceva
italic = adevărat
Sfârșit	  
dacă cursiv atunci
if txt [ 1 ] == "'" then txt = "<nowiki />" .. txt end
if txt [ # txt ] == "'" then txt = txt .. "<nowiwiki />" end
txt = mw . ustring . format ( "''% s ''" , txt )
Sfârșit
Sfârșit
local span = mw . html . create ( 'span' ): wikitext ( txt ): addClass ( args . class )
dacă lg . coduri [ language_code ] atunci
span
: attr ( 'dir' , direcție )
: attr ( 'lang' , language_code )
: attr ( 'xml: lang' , language_code )
Sfârșit			
întoarcere înapoi ( span )
Sfârșit

- ================================================== ======
- Funcția de interfață pentru _lang_testo
- apelabil în șabloane
- ================================================== ======
limbajul funcțional . lang_text ( cadru )
argumente locale = getArgs ( cadru )
returnează limba . _lang_text ( args )
Sfârșit

- Returnează un tabel cu toate codurile recunoscute de modul
limbajul funcțional . masa ( cadru )

- generează un tabel de coduri -> listă alias și un tabel de coduri pentru a-l sorta
local alias_table = {}
local codes_sorted = {}
pentru cod, _ în perechi (lg. coduri) fac
alias_table [ code ] = { "'' '" .. cod .. "' ''" }
codes_sorted [ # codes_sorted + 1 ] = cod
Sfârșit
pentru alias , codificați în perechi ( lg . alias ) faceți
dacă alias_table [ code ] atunci table.insert ( alias_table [ code ], alias ) se termină
Sfârșit
table.sort ( codes_sorted )

local root = mw . html . create ( 'tabel' )
rădăcină
: addClass ( ' sortabil wikitable ' )
: etichetă ( 'tr' )
: tag ( 'th' ): wikitext ( 'Coduri' ): done ()
: tag ( 'th' ): wikitext ( '[[template: LanguageName / name]]' ): done ()
: tag ( 'th' ): wikitext ( '[[template: Language name / voice]]' ): done ()
: tag ( 'th' ): wikitext ( '[[template: Languages]]' )

pentru _ , cod în ipairs ( codes_sorted ) do
local code_string = table.concat ( alias_table [ code ], "," )
nume local , intrare = limba . get_name ( cod ), limba . get_voce ( cod )
if item ~ = '' then item = '[[' .. item .. ']]' end
rădăcină
: etichetă ( 'tr' )
: tag ( 'td' ): wikitext ( code_string ): done ()
: tag ( 'td' ): wikitext ( nume ): done ()
: tag ( 'td' ): wikitext ( voce ): done ()
: tag ( 'td' ): css ( 'text-align' , 'center' ): wikitext ( language . languages ({ code }))
Sfârșit
întoarceți tostring ( rădăcină )
Sfârșit

- Returnează un tabel de aliasuri în format alias; cod
limbajul funcțional . alias_table ( cadru )

local root = mw . html . create ( 'tabel' )
rădăcină
: addClass ( ' sortabil wikitable ' )
: etichetă ( 'tr' )
: tag ( 'th' ): wikitext ( 'Alias' ): done ()
: tag ( 'th' ): wikitext ( 'code' ): done ()
pentru alias , codificați în perechi ( lg . alias ) faceți
rădăcină
: etichetă ( 'tr' )
: tag ( 'td' ): wikitext ( alias ): done ()
: tag ( 'td' ): wikitext ( cod )
Sfârșit
întoarceți tostring ( rădăcină )
Sfârșit

- Returnează un tabel de coduri în cod; nume; format de intrare
limbajul funcțional . tabel_cod ( cadru )

local root = mw . html . create ( 'tabel' )
rădăcină
: addClass ( ' sortabil wikitable ' )
: etichetă ( 'tr' )
: tag ( 'th' ): wikitext ( 'Code' ): done ()
: tag ( 'th' ): wikitext ( 'Name' ): done ()
: tag ( 'th' ): wikitext ( 'Voice' ): done ()
pentru cod , valoarea în perechi ( coduri lg . ) faceți
rădăcină
: etichetă ( 'tr' )
: tag ( 'td' ): wikitext ( cod ): done ()
: tag ( 'td' ): wikitext ( valoare [ 1 ]): done ()
: tag ( 'td' ): wikitext ( valoare [ 2 ])
Sfârșit
întoarceți tostring ( rădăcină )
Sfârșit

- returnează o listă albă a tuturor codurilor recunoscute pentru utilizarea botului în python
limbajul funcțional . lista albă ( cadru )
rânduri locale = { 'WHITELIST_LINGUE = set ([' }
- generează un tabel de coduri -> listă alias și un tabel de coduri pentru a-l sorta
coduri locale = {}
pentru cod, _ în perechi (lg. coduri) fac
codes [ # codes + 1 ] = cod
Sfârșit
pentru alias , _ în perechi ( lg . alias ) do
codes [ # alias + 1 ] = alias
Sfârșit
table.sort ( coduri )
pentru _ , cod în ipairs ( coduri ) do
rânduri [ # rânduri + 1 ] = "'" .. cod .. "',"
Sfârșit
rânduri [ # rânduri + 1 ] = "])"
return table.concat ( rânduri , ' \ n ' )
Sfârșit

returnează limba