Forma: Masă sport

 - Modul de construire a meselor pentru clasamente în sport
- Consultați documentația pentru detalii

require ( „Modul: fără globali” )

local p = {}

- Functie principala
funcția p . principal ( cadru )
- Declarați localnicii
local getArgs = require ( 'Modul: Argumente' ). getArgs
Args locale = getArgs ( cadru , { parentFirst = true })
local ii_start , ii_end , N_rows_res = 0
local text_field_result
note_existente locale = false
local t = {}
local t_footer = {}
local t_return = {}
local team_list = {}
local jj , jjj

- Ieșiți mai devreme dacă folosim transcluderea secțiunii pentru o altă secțiune
if ( Args [ 'transclusionection' ] și Args [ 'section' ])
iar Args [ 'transclusionection' ] ~ = Args [ 'section' ] atunci
intoarce ''
Sfârșit

- Editați linkurile, dacă vi se solicită
local baselink = cadru : getParent (): getTitle ()
dacă mw . titlu . getCurrentTitle (). text == bazelink apoi bazelink = " sfârșit
local template_name = Args [ 'template_name' ]
sau ( bazelink ~ = '' și ( ':' .. bazelink ))
sau ''

- Obțineți punctul de pornire personalizat pentru tabel (majoritatea vor începe în mod implicit la 1)
local top_pos = tonumber ( Args [ 'maximum_pos' ]) sau 1
- Obțineți punctul final personalizat pentru tabel (nelimitat dacă bottom_pos este <top_pos)
local bottom_pos = tonumber ( Args [ 'lower_pos' ]) sau 0
local N_teams = top_pos - 1 - Implicit la 0 la început, dar este necesar un număr mai mare pentru a omite anumite intrări

- Încărcați module
local yesno = require ( 'Modul: Yesno' )
- Încărcați stilul și (sub) modulele
local style_def = Args [ 'style' ] sau 'WDL'
- Din punct de vedere istoric, „fotbalul” există ca stil, acesta este transmis acum către WDL
dacă style_def == 'fotbal', atunci style_def = ' WDL ' se termină
local p_style = require ( 'Modul: Masă sport /' .. style_def )
local p_sub = require ( 'Modul: masa sportivă / sub' )
- comandabil în mod implicit
Args [ 'sortable_table' ] = Args [ 'sortable_table' ] sau ''

- Valoare aleatorie utilizată pentru unicitate
math.randomseed ( os.clock () * 10 ^ 8 )
rand_val local = math.random ()

- Declarați schema de culori
local result_col = {}
result_col = { green1 = '# BBF3BB' , green2 = '# CCF9CC' , green3 = '#DDFCDD' , green4 = '#EEFFEE' ,
blue1 = '# BBF3FF' , blue2 = '# CCF9FF' , blue3 = '#DDFCFF' , blue4 = '#EEFFFF' ,
galben1 = '#FFFFBB' , galben2 = '#FFFFCC' , galben3 = '#FFFFDD' , galben4 = '#FFFFEE' ,
red1 = '#FFBBBB', red2 = '#FFCCCC', red3 = '#FFDDDD', red4 = '#FFEEEE',
black1 = '#BBBBBB' , black2 = '#CCCCCC' , black3 = '#DDDDDD' , black4 = '#EEEEEE' ,
aur = '# F7F6A8' , argint = '# DCE5E5' , bronz = '# FFDAB9' ,
orange1 = '#FEDCBA' , orange2 = '# FEEAD5' ,
white1 = 'mostenire' , [ '' ] = 'mostenire'
}

- Afișați toate statisticile din tabel sau doar meciurile jucate și punctele
local full_table = adevărat
local pld_pts_val = string.lower ( Args [ 'only_pld_pts' ] sau 'no' )
local show_class_rules = yesno ( Args [ 'show_class_rules' ] sau 'yes' ) și adevărat sau fals
- Adevărat dacă par nu există, fals altfel
dacă da nu ( pld_pts_val ) atunci
full_table = false
elseif pld_pts_val == 'no_hide_class_rules' atunci
full_table = adevărat
show_class_rules = false
Sfârșit

- Declarați antetul coloanei de rezultate
local results_header = {}
results_header = { Q = 'Calificare' , QR = 'Calificare sau retrogradare' ,
P = „Promovare” , PQR = „Promovare, calificare sau retrogradare” ,
PR = „Promovare sau retrogradare” , PQ = „Promovare sau calificare” ,
R = „retrogradare” }
local results_defined = false - Verificați dacă acest lucru ar fi necesar
- Prefix posibil pentru câmpurile de rezultate
local respre = ( Args [ 'result_prefix' ] or '' ) .. '_'
respre = ( respre == '_' ) și '' sau respre
- Definiți acum linia pentru antetul coloanei (fie opțională, fie personalizată)
local local_res_header = results_header [ Args [ respre .. 'res_col_header' ]] sau Args [ respre .. 'res_col_header' ] sau 'Result'
- Verificați dacă include o notă
local res_head_note = Args [ 'note_header_res' ]
local res_head_note_text = "
dacă full_table și res_head_note atunci
note_exist = adevărat
res_head_note_text = frame : expandTemplate { title = 'efn' , args = { group = 'Table_notes' , res_head_note } }
Sfârșit
local results_header_txt = '! scope = "col" | ' .. local_res_header .. res_head_note_text .. ' \ n '

- Obțineți opțiunea de stare
local t_status = p_style . status ( Args )

- Sintaxă alternativă pentru lista echipelor
dacă Args [ 'team_order' ] și Args [ 'team_order' ] ~ = '' atunci
local tlist = mw . text . divizat ( Args [ 'team_order' ], '% s * [;,]% s *' )
pentru k, tname în ipairs (tlist) do
dacă tname ~ = " atunci
Args [ 'team' .. k ] = tname
Sfârșit
Sfârșit
Sfârșit

- Citiți numărul de echipe consecutive (ignorați intrările după ce ați omis un loc)
în timp ce Args [ 'echipa' .. N_teams + 1] ~ = nil și (bottom_pos <top_pos sau N_teams <bottom_pos) fac
N_teams = N_teams + 1
- Adăugați-l cu furie de două ori la parametrul team_list, o dată pentru actual
- clasament, al doilea pentru căutarea poziției în sub-tabele
- Acest lucru este posibil, deoarece Lua permite atât indici, cât și șiruri.
team_list [ N_teams ] = Args [ 'team' .. N_teams ] - prima intrare este echipa X
team_list [ Args [ 'team' .. N_teams ]] = N_teams - intrarea echipei X este poziția i
Sfârșit

- Afișează poziția
local position_col = yesno ( Args [ 'show_positions' ] sau 'yes' ) și adevărat sau fals

- Afișați grupuri sau notați
local group_col = yesno ( Args [ 'show_groups' ] sau 'no' ) și adevărat sau fals

- Afișați tabelul match_ sau nu
local match_table = yesno ( Args [ 'show_matches' ] sau 'no' ) și adevărat sau fals
local p_matches = match_table and require ( 'Modul: Rezultate sportive' )

- Etichetă sau notă de coloană de poziție personalizată
local pos_label = Args [ 'postitle' ] sau '<abbr title = "Position"> Pos </abbr>'
dacă position_col == false atunci pos_label = zero end

- Afișează starea sau nu
local show_status = yesno ( Args [ 'show_status' ] sau 'yes' ) și adevărat sau fals

- Scrieți anteturi de coloană
t_return = p_style . antet ( t , Args , p_sub , pos_label , group_col , full_table , results_header_txt )
dacă match_table atunci
- Adăugați un antet de coloană gol
t_return . count = t_return . numără + 1
table.insert ( t_return . tab_text , '! scope = "row" class = "unsortable" style = "background-color: white; border-top: white; border-bottom: white; line-width: 3pt;" | \ n ' )

- Adăugați restul antetului
t_return = p_matches . antet ( t_return , Args , p_sub , N_teams , team_list )
Sfârșit
t = t_return . tab_text
local N_cols = t_return . numara

- Determinați ce intrări intră în tabel
- Aflați ce echipă să arătați (dacă există)
local ii_show = team_list [ Args [ 'showteam' ] or nil ] - zero dacă inexistent
- Pozițiile de început și de final de afișat
local n_to_show = tonumber ( Args [ 'show_limit' ]) sau N_teams
- Verificați „valoarea legală”, dacă nu este legală (sau nedeclarată), apoi afișați-le pe toate
local check_n = (( n_to_show > = ( N_teams - top_pos + 1 )) sau ( n_to_show <= 1 ) sau ( n_to_show ~ = math.floor ( n_to_show )))
- De asemenea, verificați dacă există un ii_show valid
dacă check_n sau ( nu ii_show ) atunci
ii_start = top_pos
ii_end = N_teams
altceva
- Este un întreg corect între top_pos + 1 și N_teams-1
- Dacă este în mijloc, arătați același număr deasupra și dedesubt
- Dacă este în partea de sus sau de jos, arată numărul exact
- Câte să arate în lateral
local n_show_side = math.floor ( n_to_show / 2 )
if ( ii_show - top_pos + 1 ) <= n_show_side atunci
- Echipa de top
ii_start = top_pos
ii_end = top_pos + n_to_show - 1
elseif ii_show > = ( N_teams + 1 - n_show_side ) atunci
- Echipa de jos
ii_start = N_teams + 1 - n_to_show
ii_end = N_teams
altceva
- Caz normal
ii_start = ii_show - n_show_side
ii_end = ii_show + n_show_side
Sfârșit
Sfârșit

- Pentru coloana cu rezultate
local new_res_ii = ii_start
- Verificați în prealabil existența coloanei
pentru ii = ii_start , ii_end do
dacă Args [ respre .. 'rezultat' .. ii ] și Args [ respre .. 'text_' .. Args [ respre .. 'rezultat' .. ii ]] atunci results_defined = true end
Sfârșit
- Eliminați antetul rezultatelor dacă nu este utilizat
dacă full_table și nu results_defined atunci
- Mai întâi obțineți-l ca un șir, apoi folosiți șirul înlocuiți pentru a înlocui antetul cu șirul gol
local t_str = tostring (table.concat (t))
t_str = mw . ustring . gsub ( t_str , results_header_txt , '' )
N_cols = N_cols - 1 - Există de fapt cu o coloană mai puțin
t = {}
table.insert ( t , t_str )
Sfârșit

- Scrieți rânduri
team_name local , team_code_ii , team_code_jj , pos_num , group_txt , note_local
local note_string , note_local , note_local_num , note_id
local note_id_list = {}
local hth_id_list = {}
pentru ii = ii_start , ii_end do
- Întâi primește codul
team_code_ii = team_list [ ii ]
- Citiți acum valorile
pos_num = Args [ 'pos_' .. team_code_ii ] sau ii
group_txt = Args [ 'group_' .. team_code_ii ] sau ''
team_name = Args [ 'name_' .. team_code_ii ] sau team_code_ii
note_local = Args [ 'note_' .. team_code_ii ] sau zero

- Are nevoie de o etichetă de promovare / calificare / retrogradare
local result_local = Args [ respre .. 'result' .. ii ] sau zero
local bg_col = zero
- Obțineți culoarea de fundal locală
dacă result_local atunci
bg_col = result_col [ Args [ respre .. ' col_ ' .. result_local ]] sau Args [ respre .. ' col_ ' .. result_local ] sau 'mostenesc'
bg_col = 'background-color:' .. bg_col .. ';' - Etichetă stil complet
Sfârșit
dacă nu bg_col, atunci bg_col = 'fundal-culoare: transparent;' end - Devine implicit dacă este nedefinit

- Îndrăznește această linie sau nu
local ii_fw = ii == ii_show și 'font-weight: bold;' sau „font-weight: normal;”

- Verificați dacă există sau nu o notă, dacă este așa, pregătiți textul pentru aceasta
dacă note_local și full_table atunci
- Setați verificarea globală pentru note la adevărat
note_exist = adevărat
- Există acum 3 opțiuni pentru note
- 1) Este o notă completă
- 2) Este o trimitere la o altă notă (adică este doar un cod de echipă; de exemplu, nota_AAA = Text, nota_BBB = AAA) în care nota pentru BBB ar trebui să se lege la aceeași notă de subsol ca AAA, cu
- 2a) Cealaltă notă legată există în partea din tabel prezentată
- 2b) Partea notei nu există în partea din tabel prezentată
dacă nu Args [ 'note_' .. note_local ] atunci
- Opțiunea 1
- Acum definiți identificatorul pentru aceasta
note_id = '"table_note_' .. team_code_ii .. rand_val .. '"' - Adăugați capăt aleatoriu pentru ID-ul unic dacă sunt prezente mai multe tabele pe articol (care altfel ar putea partaja un ID)
note_id_list [ team_code_ii ] = note_id

- Apelați șablonul de refn
note_string = frame : expandTemplate { title = 'efn' , args = { group = 'Table_notes' , name = note_id , note_local } }
altceva
- Opțiunea 2
- Este opțiunea 2a în oricare dintre ele, dacă nota principală se află în sub-tabel
- sau o altă referință la nota respectivă se află în sub-tabel
- Practic atunci când fie a fost definit, fie legătura principală va fi în tabel
note_local_num = team_list [ note_local ]
dacă note_id_list [ note_local ] sau (( note_local_num > = ii_start ) și ( note_local_num <= ii_end )) atunci
- Opțiunea 2a
note_id = '"table_note_' .. note_local .. rand_val .. '"'
note_string = frame : extensionTag { name = 'ref' , args = { group = 'Table_notes' , name = note_id } }
altceva
- Opțiunea 2b
- Acum definiți identificatorul pentru aceasta
note_id = '"table_note_' .. note_local .. rand_val .. '"' - Adăugați un capăt aleatoriu pentru un ID unic
note_id_list [ note_local ] = note_id

- Apelați șablonul de refn
note_string = frame : expandTemplate { title = 'efn' , args = { group = 'Table_notes' , name = note_id , Args [ 'note_' .. note_local ]} }
Sfârșit
Sfârșit
altceva
note_string = " ;
Sfârșit

- Introduceți starea când este necesar
local status_string = "
local status_local = show_status and Args [ respre .. 'status_' .. team_code_ii ] sau zero
local status_let_first = true
local curr_letter
- Numai dacă este definit
dacă status_local atunci
- Ia-o scrisoare cu scrisoare
pentru jjj = 1 , mw . ustring . len ( status_local ) do
curr_letter = mw . ustring . superior ( mw . ustring . sub ( status_local , jjj , jjj ))
- Vezi dacă există
dacă t_status . cod [ curr_letter ] atunci
- În funcție de dacă este prima literă a not
dacă status_let_first atunci
status_string = curr_letter
t_status . numit [ curr_letter ] = adevărat
status_let_first = false
altceva
status_string = status_string .. ',' .. curr_letter
t_status . numit [ curr_letter ] = adevărat
Sfârșit
Sfârșit
Sfârșit
- Adăugați paranteze / liniuță și caractere aldine numai dacă există
dacă nu status_let_first atunci
dacă t_status . poziția == „înainte” atunci
status_string = '<span style = "font-weight: bold">' .. string.lower ( status_string ) .. '& ndash; </span>'
altceva
status_string = '<span style = "font-weight: bold"> (' .. status_string .. ') </span>'
Sfârșit
Sfârșit
Sfârșit

- Acum construiți rândurile
table.insert ( t , '| - \ n ' ) - Rând nou
dacă position_col atunci
table.insert ( t , '! scope = "row" style = "text-align: center;' .. ii_fw .. bg_col .. '" |' .. pos_num .. ' \ n ' ) - Numărul poziției
Sfârșit
dacă full_table și group_col atunci
table.insert ( t , '| style = "' .. ii_fw .. bg_col .. '" |' .. group_txt .. ' \ n ' ) - Numărul / numele grupului
Sfârșit
- Construiți ordinea șirului echipei pe baza poziției de stare
echipă_string local
dacă t_status . poziția == „înainte” atunci
team_string = status_string .. team_name .. note_string
altceva
team_string = team_name .. note_string .. status_string
Sfârșit
table.insert ( t , '| style = "text-align: left; white-space: nowrap;' .. ii_fw .. bg_col .. '" |' .. team_string .. ' \ n ' ) - Echipa (cu nota posibila)
- Apel la subfuncție
t_return = p_style . rând ( cadru , t , Args , p_sub , notes_exist , hth_id_list , full_table , rand_val , team_list , team_code_ii , ii_start , ii_end , ii_fw , bg_col , N_teams , ii , ii_show )
t = t_return . t
note_exist = t_return . note_exist
hth_id_list = t_return . hth_id_list

- Acum verificați ce trebuie adăugat în coloana cu rezultate
dacă full_table atunci
local res_jjj
dacă ii == new_res_ii atunci
- Mai întâi verificați câte rânduri aveți nevoie pentru acest lucru
N_rows_res = 1
jjj = ii + 1
result_local = Args [ respre .. 'result' .. ii ] sau ''
local cont_loop = adevărat
în timp ce ( jjj <= ii_end ) și cont_loop fac
if Args [ 'split' .. tostring ( jjj - 1 )] atunci
cont_loop = false
new_res_ii = jjj
altceva
res_jjj = Args [ respre .. 'rezultat' .. jjj ] sau ''
dacă result_local == res_jjj atunci
N_rows_res = N_rows_res + 1
altceva
cont_loop = false
new_res_ii = jjj
Sfârșit
Sfârșit
jjj = jjj + 1
Sfârșit
- Acum creați acest câmp (reutilizați ii_fw și bg_col)
- Gras (dacă este în raza de acțiune) sau nu
dacă ii_show și ( ii_show > = ii ) și ( ii_show <= ( ii + N_rows_res - 1 )) atunci
ii_fw = 'font-weight: bold;'
altceva
ii_fw = 'font-weight: normal;'
Sfârșit
- Obțineți culoarea de fundal
bg_col = zero
dacă Args [ respre .. 'rezultat' .. ii ] atunci
bg_col = result_col [ Args [ respre .. ' col_ ' .. result_local ]] sau Args [ respre .. ' col_ ' .. result_local ] sau 'mostenesc'
bg_col = 'background-color:' .. bg_col .. ';' - Etichetă stil complet
Sfârșit
dacă nu bg_col, atunci bg_col = 'fundal-culoare: transparent;' end - Devine implicit dacă este nedefinit
- Verificați dacă există note
local note_res_string , note_ref , note_text = " , " " , "
dacă Args [ 'note_res_' .. result_local ] atunci
note_exist = adevărat
local note_res_local = Args [ 'note_res_' .. result_local ]

- Împărțiți nota_res_local într-un tabel dacă toate intrările sunt valide
multiref local = 1
local note_res_local_table = mw . text . împărțiți ( note_res_local , '% s *,% s *' )
if ( # note_res_local_table > 1 ) atunci
pentru k , note_res_loc în ipairs ( note_res_local_table ) faceți
multiref = multiref * ( Args [ 'note_res_' .. note_res_loc ] și 1 sau 0 )
Sfârșit
altceva
multiref = 0
Sfârșit

- Împărțirea a eșuat, deci creați o singură tabelă de intrare cu hth_local în interior
dacă multiref < 1 atunci
note_res_local_table = { note_res_local }
Sfârșit

pentru k , note_res_local în ipairs ( note_res_local_table ) faceți
dacă nu Args [ 'note_res_' .. note_res_local ] atunci
- Nu indică o altă notă de rezultat
note_ref = respre .. 'res_' .. result_local
note_id = '"table_note_res_' .. result_local .. rand_val .. '"' - Identificator
note_text = note_res_local
altceva
- Indică o altă notă de rezultat
note_ref = respre .. 'res_' .. note_res_local
note_id = '"table_note_res_' .. note_res_local .. rand_val .. '"' - Identificator
note_text = Args [ 'note_res_' .. note_res_local ]
Sfârșit
- Verificați dacă este deja tipărit
dacă nu note_id_list [ note_ref ] atunci
- Printeaza-l
note_id_list [ note_ref ] = note_id
note_res_string = note_res_string .. cadru : expandTemplate { title = 'efn' , args = { group = 'Table_notes' , name = note_id , note_text } }
altceva
- Consultați-l
note_res_string = note_res_string .. frame : extensionTag { name = 'ref' , args = { group = 'Table_notes' , name = note_id } }
Sfârșit
Sfârșit
Sfârșit
- Obțineți text
local text_result = Args [ respre .. 'text_' .. result_local ] or ''
dacă text_result : match ( 'fbmulticomp' ) atunci
ii_fw = 'umplutură: 0;' .. ii_fw
dacă text_result : match ( 'fbmulticompefn' ) atunci
note_exist = adevărat
Sfârșit
Sfârșit
text_field_result = '| style = " 'ii_fw .. .. .. bg_col'" rowspan = " '.. tostring (N_rows_res) ..' '|' .. text_result .. note_res_string .. ' \ n '
- Vedeți dacă este necesar (numai când este gol pentru toate intrările)
dacă rezultate_definite, atunci tabel.inserare ( t , text_câmp_rezultat ) se termină
Sfârșit
Sfârșit

- Introduceți rândul de potrivire, dacă este necesar
dacă match_table atunci
- Adăugați o celulă goală
table.insert ( t , '| style = "background-color: white; border-top: white; border-bottom: white;" | \ n ' )

- Acum includeți o notă pentru a se potrivi rezultatele, dacă este necesar
pentru jj = top_pos , N_teams o fac
team_code_jj = team_list [ jj ]
dacă ii == jj atunci
- Nimic
altceva
local match_note = Args [ 'match_' .. team_code_ii .. '_' .. team_code_jj .. '_note' ]
dacă match_note atunci
note_exist = adevărat
- Numai când există
- Prima verificare a existenței referinței pentru notă
dacă nu ( Args [ 'note_' .. match_note ] sau Args [ 'match_' .. match_note .. '_note' ]) atunci
- Este intrarea
note_id = '"table_note_' .. team_code_ii .. '_' .. team_code_jj .. rand_val .. '"' - Adăugați capăt aleatoriu pentru ID unic dacă sunt prezente mai multe tabele pe articol (care altfel ar putea partaja un ID)
note_id_list [ team_code_ii .. '_' .. team_code_jj ] = note_id

note_string = frame : expandTemplate { title = 'efn' , args = { group = 'Table_notes' , name = note_id , match_note } }
altceva
- Verifică existența în altă parte
note_local_num = team_list [ match_note ] sau ii_end + 1
dacă note_id_list [ match_note ] sau (( note_local_num > = ii_start ) și ( note_local_num <= ii_end )) atunci
- Exista
note_id = '"table_note_' .. match_note .. rand_val .. '"' - Identificator
note_string = frame : extensionTag { name = 'ref' , args = { group = 'Table_notes' , name = note_id } }
altceva
- Acum definiți identificatorul pentru aceasta
note_id = '"table_note_' .. match_note .. rand_val .. '"' - Adăugați un capăt aleatoriu pentru un ID unic
note_id_list [ match_note ] = note_id
- Apelați șablonul de refn
note_string = frame : expandTemplate { title = 'efn' , args = { group = 'Table_notes' , name = note_id , Args [ 'note_' .. match_note ]} }
Sfârșit
Sfârșit

- Acum adăugați acest lucru la șirul de rezultat al meciului
Args [ 'match_' .. team_code_ii .. '_' .. team_code_jj ] = ( Args [ 'match_' .. team_code_ii .. '_' .. team_code_jj ] or '' ) .. note_string
Sfârșit
Sfârșit
Sfârșit

- Adăugați restul rândului de meci
t = p_matches . rând ( t , Args , N_teams , team_list , ii , ii_show )
Sfârșit

- Acum, dacă este necesar, introduceți o împărțire (linie continuă pentru a indica împărțirea în clasament, dar numai atunci când nu este la ultima poziție afișată)
dacă Args [ 'split' .. ii ] și ( ii < ii_end ) atunci
- Dimensiunea de bază pe N_cols (are nevoie de 2 * N_cols |)
table.insert ( t , '| - style = "background-color:' .. result_col [ 'black1' ] .. '; înălțimea liniei: 3pt;" \ n ' )
table.insert ( t , string.rep ( '|' , 2 * N_cols ) .. ' \ n ' )
Sfârșit
Sfârșit

- Închide masa
table.insert ( t , '|} \ n ' )

- Obțineți informații pentru subsol
actualizare locală = Args [ 'update' ] sau ''
local start_date = Args [ 'start_date' ] sau ''
sursă locală = Args [ 'sursă' ] sau ''
local class_rules = Args [ 'class_rules' ] sau zero

- Creați text de subsol
- Actualizarea datei
local matches_text = Args [ 'matches_text' ] sau ''
if string.lower ( update ) == 'complete' atunci
- Nu face nimic
elseif update == '' atunci
- Parametru gol
table.insert ( t_footer , 'Actualizat la' .. matches_text .. '.' )
elseif string.lower ( update ) == 'viitor' atunci
- Data viitoare de începere
table.insert (t_footer, 'Data începerii:' .. start_date .. '')
altceva
table.insert ( t_footer , 'Actualizat la' .. matches_text .. '.' )
Sfârșit

- Stiri subsol sau nu
footer_break local = yesno ( Args [ 'stack_footer' ] or 'no' ) și adevărat sau fals

- Variabilă pentru spargere de linie
local stack_string = '<br>'

dacă footer_break și ( not ( string.lower ( update ) == 'complet' ))) atunci table.insert ( t_footer , stack_string ) end

table.insert ( t_footer , 'Sursă:' .. sursă )
dacă class_rules și full_table și show_class_rules atunci
table.insert ( t_footer , '<br/> Reguli pentru ex aequo:' .. class_rules )
Sfârșit

- Acum pentru statutul numit
local status_exist = false
local status_string = "
local curr_letter
pentru jjj = 1 , mw . ustring . len ( t_status . letters ) do
curr_letter = mw . ustring . upper ( mw . ustring . sub ( t_status . letters , jjj , jjj ))
dacă t_status . numit [ curr_letter ] atunci
if ( footer_break și status_exist ) atunci
status_string = status_string .. stack_string
Sfârșit
dacă t_status . poziția == „înainte” atunci
status_string = status_string .. '<span style = "font-weight: bold">' .. string.lower ( curr_letter ) .. '& ndash; </span>' .. t_status . cod [ curr_letter ] .. '; '
altceva
status_string = status_string .. '<span style = "font-weight: bold"> (' .. curr_letter .. ') </span>' .. t_status . cod [ curr_letter ] .. '; '
Sfârșit
status_exist = adevărat
Sfârșit
Sfârșit
- Acum, încheiați-l cu un punct (dacă conține intrări, trebuie eliminat „;”)
dacă status_exist atunci
status_string = '<br/>' .. mw . ustring . sub ( status_string , 1 , mw . ustring . len ( status_string ) - 2 ) .. '.'
table.insert ( t_footer , status_string )
Sfârșit

- Adăugați note (dacă este cazul)
dacă note_există atunci
table.insert ( t_footer , '<br> Notă:' )
- Ca text de dimensiune reflist
t_footer = '<div class = "reflist">' .. table.concat ( t_footer ) .. '</div>'
t_footer = t_footer .. frame : expandTemplate { title = 'notelist' , args = { group = 'lower-alpha' } }
altceva
- Ca text de dimensiune reflist
t_footer = '<div class = "reflist">' .. table.concat ( t_footer ) .. '</div>'
Sfârșit

- Adăugați subsol la tabelul de text principal
table.insert ( t , t_footer )

- Rescrieți linkuri de ancorare
pentru k = 1 , # t face
if t [ k ]: match ( '% [% [# [^% [%]] *% |' ) atunci
t [ k ] = mw . ustring . gsub ( t [ k ], '(% [% [) (# [^% [%]] *% |)' , '% 1' .. bazelink .. '% 2' )
Sfârșit
Sfârșit

return table.concat ( t )
Sfârșit

retur p