Forma: Sommastat

 local p = {}

răspuns local = {}
depanare locală = {}

local sort_code = {
[ '-?' ] = 'Data-sort-value = "- 0.4"',
[ '-0+'] = 'data-sort-value = "- 0.3"',
[ '-'] = 'date-sort-value = "- 0.2"',
[ '-0'] = 'data-sort-value = "- 0,1"',
[ '?' ] = 'Data-sort-value = "0,1"',
[ '0+]'] = 'data-sort-value = "0,2"'
}

funcție locală dump ( t , ...)
argumente locale = {...}
pentru _ , s în ipairs ( args ) do
table.insert ( t , s )
Sfârșit
Sfârșit

funcție locală cell_color_toggle (cell_color)
return (cell_color == '' și 'bgcolor = # f2f2f2') sau ''
Sfârșit

sumstring funcția locală (valoare)
- Primește un șir care conține o sumă a formularului:
- a1 + a2 + a3 ... + an unde fiecare ai este un număr precedat opțional de "-"
- și suma se întoarce
addendums local = mw. text . divizare (valoare, '+', adevărat)
suma locală = 0
pentru _ addendum ipairs (addendums) do
_, _, A = string.find (addendum, '^ (-?% D +)')
atunci dacă o sumă = sumă + ToNumber (a) se termină
Sfârșit
returnează suma
Sfârșit

- ================================================== ===============
- Clasa pentru a acumula sume
- ================================================== ===============
Suma locală = {}
Sumă. __index = Suma

Funcția sumă . nou (is_reti, Sum)
Întoarcere SetMetaTable ({
N = 0,
n_interrogativi = 0,
n_trattini = 0,
is_reti = is_reti sau false,
n_interrogativi_minus = 0,
n_zero_minus = 0,
n_zero_plus = 0,
n_zero_plus_minus = 0,
do_sum = (sum == zero) sau fals,
sumă = sumă sau 0,
end_plus = "
}, Suma)
Sfârșit

Funcția sumă : status ()
local sum_result
dacă eul. apoi do_sum
sum_result = ToNumber (self. Sum)
altceva
sum_result = self. sumă
Sfârșit
returnare table.concat ({
'N:' .. încearcă (auto. N)
'n_interrogativi:' .. tostring (self. n_interrogativi)
'n_trattini:' .. tostring (self. n_trattini)
'is_reti:' .. tostring (self. is_reti)
'n_interrogativi_minus:' .. tostring (self. n_interrogativi_minus)
'n_zero_minus:' .. tostring (self. n_zero_minus)
'n_zero_plus:' .. tostring (self. n_zero_plus)
'n_zero_plus_minus:' .. tostring (self. n_zero_plus_minus)
'do_sum:' .. tostring (self. do_sum)
'Sum:' .. sum_result,
'end_plus:' .. tostring (self. end_plus)
}, '<br />')
Sfârșit

Funcția sumă . __toString (auto)
dacă eul. n_trattini == self. N atunci
întoarce '-' .. sine. end_plus
altfel dacă eu. n_interrogativi == self. N atunci
întoarce '?' .. sinele. end_plus
altfel dacă eu. n_interrogativi_minus == self. N atunci
întoarce '-?' .. sinele. end_plus
altfel dacă eu. n_trattini + self. n_zero_minus == self. N atunci
returnează '-0' .. sine. end_plus
elseif (self. n_trattini + self. n_zero_minus + self. n_zero_plus + self. n_interrogativi_minus) == self. N atunci
returnează „-0+”
altfel dacă eu. apoi do_sum
dacă eul. n_interrogativi> 0 sau self. n_interrogativi_minus> 0 apoi auto. end_plus = '+' end
tostring return (self. Sum) .. self. end_plus
altceva
întoarce-te . sumă
Sfârșit
Sfârșit

Funcție sumă : adăugare (valoare)
sinele . N = sinele. N + 1
dacă String.match (corect, „% + $”) atunci auto. end_plus = '+' end
dacă eul. atunci este_reti
dacă valoarea == '?' atunci
sinele . n_interrogativi = self. n_interrogativi + 1
întoarcere
elseif valoare == '-?' atunci
sinele . n_interrogativi_minus = self. n_interrogativi_minus + 1
elseif valoare == '-' atunci
sinele . n_trattini = self. n_trattini + 1
întoarcere
elseif valoare == '-0' atunci
sinele . n_zero_minus = self. n_zero_minus + 1
întoarcere
elseif value == '-0+' atunci
sinele . n_zero_plus = sine. n_zero_plus + 1
întoarcere
Sfârșit
elseif valoare == '-' atunci
sinele . n_trattini = self. n_trattini + 1
întoarcere
elseif valoare == '?' atunci
sinele . n_interrogativi = self. n_interrogativi + 1
întoarcere
Sfârșit
dacă eul. apoi do_sum
sinele . Suma = sine. sum + (ToNumber (corect) sau sumstring (valoare))
Sfârșit
Sfârșit

SetMetaTable (Sum, {__call = function (_, ...) return Sum. New (...) end})
- ================================================== ===============
- declarația finală a clasei prin sumă
- ================================================== ===============

funcția p . sommastat (cadru)
- 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
if frame == mw . getCurrentFrame () atunci
origArgs = cadru : getParent (). argumente
altceva
origArgs = cadru . argumente
Sfârșit

Funcția locală nil_if_blank (s)
dacă e și s == „“ , apoi a reveni la sfârșitul zero
retur s
Sfârșit

local skip_amm_esp = (origArgs. C == 'nu') sau false
local data_cols = (skip_amm_esp și 2) sau 4
local pres = nil_if_blank (origArgs. pres)
Rețele locale = nil_if_blank (origArgs. Networks)
local adm = nil_if_blank (origArgs. amm )
local esp = nil_if_blank (origArgs. esp)
local cell_color = cell_color_toggle ( ")
dump (răspuns, ")
sume locale {= Sum (false, pres), Sum (true, rețele), Sum (false, amm), Sum (false, esp)}
local i = 0
local end_loop = false
în timp ce nu end_loop faceți
dacă i> 3 atunci sfârșitul pauzei
pentru j = 1, faceți date_cols
local CEL_VALUE origArgs = [i * 4 + j]
dacă CELL_VALUE == zero atunci
- dacă coloanele examinate nu sunt o serie completă de 2 sau 4 coloane, adăugați coloane goale
- pentru a menține alinierea datelor din tabel
end_loop = adevărat
cell_color = cell_color_toggle (cell_color)
dacă j == 1 atunci sfârșitul pauzei
pentru k = j, faceți date_cols
dump (răspuns, '<td', color_celulă, '> & nbsp; </ td>')
Sfârșit
pauză
altceva
CEL_VALUE = mw. text . decupare (CELL_VALUE)
dump (răspuns, '<td', cell_color, (sort_code [CELL_VALUE] or ''), '>', CELL_VALUE, '</ td>')
sume [j]: add (CELL_VALUE)
Sfârșit
Sfârșit
cell_color = cell_color_toggle (cell_color)
i = i + 1
Sfârșit
dacă sume [1]. N> 1 atunci
pentru j = 1, faceți date_cols
local CELL_VALUE = tostring (sume [j])
dump (răspuns, '<td', cell_color, (sort_code [CELL_VALUE] or ''), '>', '' '' ', CELL_VALUE,' '' '</ td> ")
- ieșire de depanare
--dump (răspuns, '<td', cell_color, (sort_code [cell_value] or ''), '>', "'' '", cell_value, "' ''" .. '<br />' .. sume [j]: status () .. '</td>')
Sfârșit
Sfârșit
returnare table.concat (răspuns)
Sfârșit

retur p