Mòdul:Multilang module tools
Documentació del mòdul [ mostra ] [ modifica el codi ] [ mostra l'historial ] [ refresca ]
A continuació es mostra la documentació transclosa de la subpàgina /ús. [salta a la caixa de codi]
Read:
local p = {}
--Version 2020-07-10
local SA = require "Module:SimpleArgs"
local SD = require "Module:SimpleDebug"
local WD = require "Module:Wikidades"
----------------------------------------
p.prior_key = ''
function p.ChkFunc (func_name, params)
--Used in debug of a function, where:
--params is a parameter table, where each item is {name, value, type}
--the type can be any of the following in the table and integer ("i") or non-empty string ("x")
--adding "r", then the parameter is required.
local types = {
["b"] = 'boolean',
["f"] = 'function',
["n"] = 'number',
["s"] = 'string', --string with a values or not
["t"] = 'table',
}
for i, par in ipairs(params) do
local req = false
if (par[1] == '') or (par[3] == '') then
error ('Incomplete call to ChkFunc in #'..i..' parameter of '..func_name)
end
if string.len (par[3]) == 2 then
par[3] = string.sub (par[3], 1, 1)
req = true
end
local typ = par[3]
local function mess_begin ()
return 'In a call to "'..func_name..'" parameter #'..i..' (= "'..par[1]..'")'
end
if typ == 'a' then --any
if req and (par[2] == nil) then
error (mess_begin ()..' must have a value', 0)
end
elseif typ == 'k' then -- a key = string with a value
local key = par[2]
if (key == nil) or (key == '') or (type(key) ~= 'string') then
if p.prior_key == '' then
error (mess_begin()..', not set (or correctly typed) a key, perhaps, the call from first key') --Don't translate, for debug
else
error (mess_begin()..', not set (or correctly typed) a key after the key "'..p.prior_key..'", or, perhaps, the call from the first key') --Don't translate, for debug
end
else
p.prior_key = key
end
elseif typ == 'x' then -- a string with a value
if par[2] == nil then
if req then
error (mess_begin ()..' must have a string', 0)
end
elseif par[2] == "" then
error (mess_begin ()..' must have a non-empty string', 0)
end
else
if typ == 'i' then
typ = 'n'
end
local t = types[typ]
local function error_mes (mes)
error (mess_begin ()..' must be a '..t..', but '..mes, 0)
end
if req and (par[2] == nil) then
error_mes ('not found a value')
elseif par[2] ~= nil then
if type(par[2]) ~= t then
SD.vtos (par[2])
error_mes ('found '..SD.s)
elseif par[3] == 'i' then
if par[2] ~= math.floor(par[2]) then
t = 'integer number'
error_mes ('found '..par[2])
end
end
end
end
end
end -- ChkFunc
----------------------------------------
local RS = {
DuplicateArgs = 'DuplicateArgs',
}
local i18n = {
[RS.DuplicateArgs]= "Duplicate parameters:",
}
i18n = SA.loadI18n ('Multilang module tools', i18n)
p.arg = {
demo = 'demo',
item = 'item',
lang = 'lang',
}
function p.DemoItemLang()
return {p.arg.demo, p.arg.item, p.arg.lang}
end
p.k = { --labels to define translatable strings
Args = 'Args', --arguments or parameters
Labels = 'Labels', --text to display usually
MsgError = 'MsgError', --warning or information or error messages contains the next
Msgs = 'Msgs', --warning or information messages
Errors = 'Errors', --error messages
}
SA.OKEmptyVal = false -- Empty values ("") = nil.
----------------------------------------
--Language functions
----------------------------------------
p.lang = nil -- Used for demos for other languages.
p.compare_lang = 'en'
p.LangIsRTL = nil
local LangsDifDirect = false
local WDirect = 'ltr'
function p.SetLang (args)
local lang_now = args[p.arg.lang]
if lang_now ~= nil then
SA.lang_to_use = SA.get_lang (lang_now)
end
end --SetLang
function p.LangsDifWriteDirect ()
return LangsDifDirect
end
function p.WriteDirect ()
return WDirect
end
local function _IsRTL (lang)
return mw.getLanguage(lang):getDir() == 'rtl'
end
function p.IsRTL (frame)
local args, NArgs = SA.GetArgs (frame)
local lang = SA.RStr_Par (args, 1)
return _IsRTL (lang)
end --IsRTL
function p.IniLang (frame, args)
p.lang = SA.Str_Par (args, p.arg.lang)
local CurrLang = mw.language.getContentLanguage().code
if p.lang == nil or (p.lang == CurrLang) then
p.LangIsRTL = _IsRTL (CurrLang)
elseif (p.lang ~= nil) and (p.lang ~= CurrLang) then
p.LangIsRTL = _IsRTL (p.lang)
local ContentLangIsRTL = _IsRTL (CurrLang)
if p.LangIsRTL then
WDirect = 'rtl'
end
LangsDifDirect = p.LangIsRTL ~= ContentLangIsRTL
end
end --IniLang
----------------------------------------
local error_t = {}
local dupli_args = {}
----------------------------------------
function p.SendErrors (errors)
if errors ~= nil then
for _, i in ipairs(errors) do
table.insert (error_t, i)
end
end
end --SendErrors
function p.CheckParams (args, ArgsPoss, OtherArgs, SetArgs, ArgNamesIn1)
local errors, dupli
if SetArgs then
local ArgsPoss2 = {}
for i, v in ipairs(ArgsPoss) do
if ArgsPoss[i][p.k.Args] == nil then
SD.vtos (ArgsPoss)
error ('Expected table without "'..p.k.Args..'":</br>'..SD.s)
end
table.insert (ArgsPoss2, ArgsPoss[i][p.k.Args])
end
errors, dupli = SA.CheckParamsM (args, ArgsPoss2, OtherArgs, ArgNamesIn1)
else
errors, dupli = SA.CheckParamsM (args, ArgsPoss, OtherArgs, ArgNamesIn1)
end
if SA.Error.handle then
p.SendErrors (errors)
if dupli ~= nil then
for _, i in ipairs(dupli) do
table.insert (dupli_args, i)
end
end
end
end --CheckParams
----------------------------------------
function p.MN (ModuleName)
return '[[Module:'..ModuleName..']]'
end
function p.MNi18n (ModuleName)
return p.MN (ModuleName..'/i18n')
end
function p.MNi (ModuleName)
return p.MN (ModuleName..'/items')
end
----------------------------------------
local function exists_in_tab_main (ModuleName, key, tab_main, what)
if tab_main[key] == nil then
error ('Not found "'..key..'" in items table (of '..p.MN(ModuleName)..'), as '..what, 0) --for debug, don't translate
end
end --exists_in_tab_main
local function correct_tab_main (ModuleName, key, tab_main, n, for_what)
if (n == 1) and (type(tab_main[key]) == 'table') then
SD.vtos (tab_main[key])
error ('Invalid items table (from '..p.MN(ModuleName)..') for key "'..key..'". No tables allowed'..for_what..' (now = '..SD.s..')', 0)
elseif (n == 2) and (type(tab_main[key]) ~= 'table') then
error ('Invalid items table (from '..p.MN(ModuleName)..') for key "'..key..'". Table is required'..for_what..' (only = '..tab_main[key]..')', 0)
end
end --correct_tab_main
local function exists_in_tab_main_1_to_1or2 (ModuleName, key, tab_main, tab_lang, n) --for debug, don't translate
local for_what = ' for a label or message!'
exists_in_tab_main (ModuleName, key, tab_main, 'label or message key')
if type(tab_lang[key]) == 'table' then
SD.vtos (tab_lang[key])
error ('Invalid items table (from '..p.MNi18n(ModuleName)..') for key '..key..'. No tables allowed'..for_what..' (now = '..SD.s..')', 0)
else
correct_tab_main (ModuleName, key, tab_main, n, for_what)
end
end --exists_in_tab_main_1_to_1or2
local function exists_in_tab_main_1or2 (ModuleName, key, tab_main, n) --for debug, don't translate
exists_in_tab_main (ModuleName, key, tab_main, 'parameter key')
end
local function tableMergeReplace (ModuleName, tab_main, tab_lang)
for k, v in pairs(tab_lang) do
exists_in_tab_main_1_to_1or2 (ModuleName, k, tab_main, tab_lang, 1)
if v ~= '' then
tab_main[k] = v
end
end
return tab_main
end --tableMergeReplace
local function tableMergeReplace1 (ModuleName, tab_main, tab_lang)
for k, v in pairs(tab_lang) do
exists_in_tab_main_1_to_1or2 (ModuleName, k, tab_main, tab_lang, 2)
if v ~= '' then
tab_main[k][1] = v
end
end
return tab_main
end --tableMergeReplace1
local function tableMergeAppend (ModuleName, tab_main, tab_lang)
for k, v in pairs(tab_lang) do
exists_in_tab_main_1or2 (ModuleName, k, tab_main, 1)
if v == '' then
else
found = {}
local tab = {}
if type(v) == "table" then
tab = v
for kk, vv in ipairs(v) do
found[vv] = 0
end
else
table.insert (tab, v)
found[v] = 0
end
local n = tab_main[k]
function perhapsAdd (s)
if found[s] == nil then
found[s] = 0
table.insert (tab, s)
end
end
if type(n) == "table" then
for _,vv in pairs(n) do
perhapsAdd (vv)
end
else
perhapsAdd (n)
end
tab_main[k] = tab
end
end
return tab_main
end --tableMergeAppend
local function tableMergeAppend1 (ModuleName, tab_main, tab_lang)
for k, v in pairs(tab_lang) do
exists_in_tab_main_1or2 (ModuleName, k, tab_main, 2)
if v == '' then
else
local found = {}
local tab = {}
if type(v) == "table" then
tab = v
for kk, vv in ipairs(v) do
found[vv] = 0
end
else
table.insert (tab, v)
found[v] = 0
end
local n = tab_main[k][1]
local function perhapsAdd (s)
if found[s] == nil then
found[s] = 0
table.insert (tab, s)
end
end
if type(n) == "table" then
for _,vv in pairs(n) do
perhapsAdd (vv)
end
else
perhapsAdd (n)
end
tab_main[k][1] = tab
end
end
return tab_main
end --tableMergeAppend1
function p.tableMerge (ModuleName, tab_main, tab_lang, TargetFirst)
if p.lang == nil then
local z1 = SA.deep_copy_table (tab_main)
local z2 = SA.deep_copy_table (tab_lang)
if z1[p.k.Args][SA.HasChild] then
for x, v in pairs(tab_lang[p.k.Args]) do
if x ~= SA.HasChild then
if TargetFirst == true then
z1[p.k.Args][x] = tableMergeAppend1 (ModuleName, z1[p.k.Args][x], z2[p.k.Args][x])
else
z1[p.k.Args][x] = tableMergeAppend (ModuleName, z1[p.k.Args][x], z2[p.k.Args][x])
end
end
end
else
if TargetFirst == true then
z1[p.k.Args] = tableMergeAppend1 (ModuleName, z1[p.k.Args], z2[p.k.Args])
else
z1[p.k.Args] = tableMergeAppend (ModuleName, z1[p.k.Args], z2[p.k.Args])
end
end
for _, wd in pairs(p.k) do --Labels, Msgs and Errors
if wd ~= p.k.Args then
if (z1[wd] ~= nil) and (z2[wd] ~= nil) then
if wd == p.k.MsgError then
for _, v in pairs(tab_lang[p.k.MsgError]) do
z1[p.k.MsgError][v] = tableMergeReplace (ModuleName, z1[p.k.MsgError][v], z2[p.k.MsgError][v])
end
end
z1[wd] = tableMergeReplace (ModuleName, z1[wd], z2[wd])
--[[]
if (wd == p.k.Labels) and (TargetFirst == true) then
z1[wd] = tableMergeReplace1 (ModuleName, z1[wd], z2[wd])
else
z1[wd] = tableMergeReplace (ModuleName, z1[wd], z2[wd])
end
--]]
end
end
end
return z1
else
return tab_main
end
end --tableMerge
function p.SetAttribToArgs (tab, tab_lims)
local tab2
local function GetArgType (key)
if key == nil then
return nil
end
if tab2 ~= nil then
for iv, v in ipairs(tab2) do
if v[1] == key then
table.remove (tab2, iv)
return v[2]
end
end
end
return p.IT.s
end --GetArgType
local function For1(tab_h)
local Args = {}
for j, k in pairs(tab_h) do
local item = {k}
table.insert (item, GetArgType(j))
Args[j] = item
end
return Args
end
local new_tab = {}
if tab[p.k.Args][SA.HasChild] == nil then
tab2 = SA.deep_copy_table (tab_lims)
local Args = For1(tab[p.k.Args])
new_tab[p.k.Args] = Args
else
local Args = {}
for j, k in pairs(tab[p.k.Args]) do
if j == SA.HasChild then
Args[SA.HasChild] = true -- = Args[j] = k
else
tab2 = SA.deep_copy_table (tab_lims[j])
Args[j] = For1(k)
end
end
new_tab[p.k.Args] = Args
end
new_tab[p.k.Labels] = tab[p.k.Labels]
new_tab[p.k.Msgs] = tab[p.k.Msgs]
new_tab[p.k.Errors] = tab[p.k.Errors]
return new_tab
end --SetAttribToArgs
function p.SetAttribToArgsGr (tab, tab_lims)
--Warning: not to be confused with "Multilang infotable tools.SetAttribToArgsGr"
local new_tab = {}
for j, k in pairs(tab) do
new_tab[j] = p.SetAttribToArgs (tab[j], tab_lims[j])
end
return new_tab
end --SetAttribToArgsGr
----------------------------------------
local function CheckKeyInTab (tab, key) --Only for debug
if tab[p.k.Labels] == nil then
error ('Table not has "'..p.k.Labels..'"')
elseif tab[p.k.Labels][key] == nil then
error ('Not found in table "'..p.k.Labels..'" the key "'..key..'"')
end
end --CheckKeyInTab
function p.GetLabelL (tab, key, lang)
p.ChkFunc ("GetLabelL", {{"tab",tab,"tr"},{"key",key,"k"},{"lang",lang,"s"},})
CheckKeyInTab (tab, key)
key = SA.CheckIsStr (tab[p.k.Labels][key], key)
if string.sub(key,1,1) == '_' then --uses properties (_Pn) or qualifiers (_Qn) from Wikidata to define labels
key = string.sub(key,2)
return WD.getLabel({key, ['lang']=lang}), key
else
return key, ''
end
end --GetLabelL
function p.GetLabel (tab, key)
return p.GetLabelL (tab, key, p.lang)
end
function p.GetLabelX (mod_abbrev, key, tab_main, tab_lang)
local wd_main, lnk = p.GetLabelL (tab_main, key, p.compare_lang)
local wd_lang = tab_lang[p.k.Labels][key]
return mod_abbrev, key, wd_main, wd_lang, lnk
end --GetLabelX
function p.GetLabelL3 (tab, key, lang)
p.ChkFunc ("GetLabelL3", {{"tab",tab,"tr"},{"key",key,"k"},{"lang",lang,"s"},})
local val = tab[p.k.Labels][key]
if val == nil then
return '', ''
else
key = SA.CheckIsStr (tab[p.k.Labels][key], key)
if string.sub(key,1,1) == '_' then --uses properties (_Pn) or qualifiers (_Qn) from Wikidata to define labels
key = string.sub(key,2)
return WD.getLabel({key, ['lang']=lang}), key
else
return key, ''
end
end
end --GetLabelL3
function p.GetLabelL2 (wd_main_l, key)
local key = SA.CheckIsStr (wd_main_l, key)
if string.sub(key,1,1) == '_' then --uses properties (_Pn) or qualifiers (_Qn) from Wikidata to define labels
key = string.sub(key,2)
return WD.getLabel({key, ['lang']=SA.lang_to_use}), key
else
return key, ''
end
end --GetLabelL2
function p.GetMsgErrorX (option, mod_abbrev, key, tab_main, tab_lang)
p.ChkFunc ("GetMsgErrorX", {{"option",option,"xr"},{"mod_abbrev",mod_abbrev,"xr"},
{"key",key,"k"},{"tab_main",tab_main,"tr"},{"tab_lang",tab_lang,"tr"},})
local wd_main = tab_main[option][key]
local wd_lang = tab_lang[option][key]
return mod_abbrev, wd_main, wd_lang
end --GetMsgError
----------------------------------------
function p.IsReserv (key)
p.ChkFunc ("IsReserv", {{"key",key,"xr"},})
return string.sub (key, 1, 3) == 'rs_'
end
function p.GetRequired (key, tab)
if tab ~= nil then
for _, v in ipairs(tab) do
if v == key then
return true
end
end
end
return false
end --GetRequired
function p.GetRequiredGrp (grp, key, tab)
return p.GetRequired (key, tab[grp])
end
p.IT = { --argument types
s = 's', --string
i = 'i', --integer
ipos = 'i+', --positive integer
n = 'n', --number
npos = 'n+', --positive number
d = 'd', --date
b = 'b', --boolean
sz = 'sz', --size
a = 'a', --array
}
local function AlreadyExists (tab, key)
--It cheks if a "key" already exist in tab['Args']
for _, v in pairs(tab[p.k.Args]) do
if type(v[1]) == 'table' then
for _, j in ipairs(v[1]) do
if j == key then
return true
end
end
elseif v[1] == key then
return true
end
end
return false
end --AlreadyExists
function p.split_item_type_req_vals (item_type_req)
if item_type_req == nil then
return p.IT.s, false, nil
else
local item_type = item_type_req
local values = nil
if type(item_type) == 'table' then --when item_type = {'a', {'AM',PM'}} or {'i', {1,10}}
values = item_type[2]
item_type = item_type[1]
end
if item_type == nil then
SD.vtos (item_type_req)
error (SD.s)
end
local required = string.sub (item_type,-1) == 'r'
if required then
item_type = string.sub (item_type, 1, string.len(item_type)-1)
end
return item_type, required, values
end
end --split_item_type_req_vals
function p.split_item_type_req_vals2 (lims, key)
if lims == nil then
return p.IT.s, false, nil
else
return p.split_item_type_req_vals (lims[key])
end
end --split_item_type_req_vals2
function p.split_item_type_req_vals_forList (item_type_req)
local item_type, required, values = p.split_item_type_req_vals (item_type_req)
if values ~= nil then
local sep
if item_type == p.IT.a then
sep = ', '
else
sep = '-'
end
values = '<small>('..table.concat (values, sep)..')</small>'
end
return item_type, required, values
end --split_item_type_req_vals_forList
function p.item_type_req_vals_prep (item_type_req)
local item_type, required, values = p.split_item_type_req_vals_forList (item_type_req)
return p.IT_required_vals (item_type, required, values)
end
function p.split_item_type_req (item_type_req)
local item_type = item_type_req
if type(item_type) == 'table' then --when item_type = {'a', {'AM',PM'}} or {'i', {1,10}}
item_type = item_type[1]
end
local required = string.sub (item_type,-1) == 'r'
if required then
item_type = string.sub (item_type, 1, string.len(item_type)-1)
end
return item_type, required
end --split_item_type_req
function p.InvalidType (type_req)
--It cheks if "type_req" is valid
--if i.g. type_req=='i+r' first it gets 'i+', and second it checks if 'i+' is in "p.IT"
type_req = p.split_item_type_req (type_req)
for _, i in pairs(p.IT) do
if i == type_req then
return false -- = is valid type
end
end
return true
end --InvalidType
function p.ParamVal (args, ParId, arg_type, required, DefVal, params)
--it read a parameter "ParId" (i.g. {'name1',Name1}) of an "arg_type" (according "p.IT") and "required"
--if the parameter isn't found a defaul values is returned
--if there is an error, it is added to the "error_t"
local val = nil
if required == true then
if (arg_type == p.IT.s) or (arg_type == p.IT.d) then
val = SA.RStr_Par (args, ParId)
elseif arg_type == p.IT.i then
if params == nil then
val = SA.RInt_Par (args, ParId)
else
val = SA.RInt_Par (args, ParId, params[1], params[2])
end
elseif arg_type == p.IT.ipos then
val = SA.RPosInt_Par (args, ParId)
elseif arg_type == p.IT.n then
if params == nil then
val = SA.RNum_Par (args, ParId)
else
val = SA.RNum_Par (args, ParId, params[1], params[2])
end
elseif arg_type == p.IT.npos then
val = SA.RPosNum_Par (args, ParId)
elseif arg_type == p.IT.b then
val = SA.RBool_Par (args, ParId)
elseif arg_type == p.IT.sz then
val = SA.RSize_Par (args, ParId)
elseif arg_type == p.IT.a then
val = SA.RStrChkTab_Par (args, ParId, params)
end
else
if (arg_type == p.IT.s) or (arg_type == p.IT.d) then
val = SA.Str_Par (args, ParId, DefVal)
elseif arg_type == p.IT.i then
if params == nil then
val = SA.Int_Par (args, ParId)
else
val = SA.Int_Par (args, ParId, nil, params[1], params[2])
end
elseif arg_type == p.IT.ipos then
val = SA.PosInt_Par (args, ParId, DefVal)
elseif arg_type == p.IT.n then
if params == nil then
val = SA.Num_Par (args, ParId, DefVal)
else
val = SA.Num_Par (args, ParId, nil, params[1], params[2])
end
elseif arg_type == p.IT.npos then
val = SA.PosNum_Par (args, ParId, DefVal)
elseif arg_type == p.IT.b then
val = SA.Bool_Par (args, ParId, DefVal)
elseif arg_type == p.IT.sz then
val = SA.Size_Par (args, ParId, DefVal)
elseif arg_type == p.IT.a then
val = SA.StrChkTab_Par (args, ParId, params)
end
end
if SA.Error.yes then
table.insert (error_t, SA.GetAndClearError())
end
return val
end --ParamVal
function p.ErrorMsgs (frame, args, tab)
--if (exists parameter errors) and (in Show Preview mode of infotable)
--it prepare the messages to display them at infobox table
local res_2 = nil
if ((#error_t > 0) or (#dupli_args > 0)) and (frame:preprocess( "{{REVISIONID}}" ) == "") then
local error_str = table.concat (error_t, '</br>')
local dupli_str = ''
if #dupli_args > 0 then
dupli_str = i18n[RS.DuplicateArgs]..' '..table.concat (dupli_args, ', ')
end
local res = {}
if error_str ~= '' then
table.insert (res, error_str)
end
if dupli_str ~= '' then
table.insert (res, dupli_str)
end
res_2 = table.concat (res, '</br>')
end
return res_2, #error_t > 0, #dupli_args > 0
end --ErrorMsgs
----------------------------------------
-- List options and functions
----------------------------------------
local AT_TD = { --TemplateData strings according argument types
[p.IT.s] = 'line',
[p.IT.n] = 'number',
[p.IT.d] = 'date',
[p.IT.b] = 'boolean',
}
p.AT_Read = { --Displayed argument types
[p.IT.s] = 'string',
[p.IT.i] = 'integer',
[p.IT.ipos] = 'positive integer',
[p.IT.n] = 'number',
[p.IT.npos] = 'positive number',
[p.IT.d] = 'date (=string)',
[p.IT.b] = 'boolean',
[p.IT.sz] = 'size',
[p.IT.a] = 'array',
}
local function ConvToTemplateDate (arg)
-- return a valid type for TemplateData
if (arg == p.IT.i) or (arg == p.IT.ipos) or (arg == p.IT.npos) then
return p.IT.n
elseif (arg == p.IT.sz) or (arg == p.IT.a) then
return p.IT.s
else
return arg
end
end --ConvToTemplateDate
local all_items = "allitems"
p.LOpt = { --Display list options, id p.l
list = 'list',
params = 'params',
template = 'template', --TemplateData
labels = 'labels',
msgs = 'msgs',
errors = 'errors',
}
p.with_pos_col = false --if true displays a position column.
p.uses_QP_for_labels = false --if true displays in labels list a column with Qualifiers or Properties of Wikidata for labels
p.with_arg_prop = false --if true displays in labels list a last columns with used properties of Wikidata for load the values.
function p.all_items_opt (args, opt)
return SA.StrChkTab_Par (args, all_items, opt)
end
p.tab_items = {}
local arg_types_used = {}
p.mod_used = {} --modules used, each item: {id, name}
local mod_used_in_class = {} --modules used in arguments or label lists
function p.add_used (tab, wd)
if wd ~= '' then
local found = false
for _, i in ipairs(tab) do
if i == wd then
found = true
break
end
end
if not found then
table.insert (tab, wd)
end
end
return tab
end --p.add_used
function p.add_mod_used (abbrev, name)
table.insert (p.mod_used, {abbrev, name})
end
function p.add_arg_types_used (item_type)
arg_types_used = p.add_used (arg_types_used, item_type)
end
function p.add_mod_used_in_class (item_type)
mod_used_in_class = p.add_used (mod_used_in_class, item_type)
end
local function perhaps_mod_used ()
local function lnk (m)
return ' [[Module:'..m[2]..'/i18n]]'
end
if #p.mod_used > 0 then
local S = 'You can change the localizated text in:'
if #p.mod_used == 1 then
S = S..lnk (p.mod_used[1])
else
S = S..'<ul>'
for _, m in ipairs(p.mod_used) do
found = false
for _, m2 in ipairs(mod_used_in_class) do
if m[1] == m2 then
found = true
break
end
end
if found then
S = S..'<li>'..m[1]..':'..lnk(m)..'</li>'
end
end
S = S..'</ul>'
end
table.insert (p.tab_items, S)
end
end --perhaps_mod_used
function p.begin_headers ()
local ini = ''
if #p.mod_used > 1 then
ini = '<th>M.</th>'
end
if p.with_pos_col then
ini = ini..'<th>P.</th>'
end
return ini..'<th>Key</th>'
end --p.begin_headers
function p.append_mod_item (mod_abbrev, res)
if #p.mod_used > 1 then
return '<td>'..mod_abbrev..'</td>'..res
else
return res
end
end --p.append_mod_item
function p.ins_tab_row (S)
table.insert (p.tab_items, '<tr>'..S..'</tr>')
end
local pos_for_item = 1
function p.add_pos (res)
if p.with_pos_col then
res = '<td>'..pos_for_item..'</td>'
end
pos_for_item = pos_for_item + 1
return res
end --p.add_pos
local function begin_foot (in_labels)
table.insert (p.tab_items, '</table>')
res = {}
if #p.mod_used > 1 then
table.insert (res, 'M.: Abbreviation of the used module/s')
end
if p.with_pos_col then
table.insert (res, 'P.: Position according to the appearance order in the infobox')
end
if in_labels and p.uses_QP_for_labels then
table.insert (res, 'WD: Wikidata')
end
if #res > 0 then
table.insert (p.tab_items, table.concat (res, '. ')..'</br>')
end
end --begin_foot
local has_required = false
function p.IT_required_vals (item_type, required, vals)
if (item_type ~= '') and required then
item_type = item_type..'-R'
has_required = true
end
if SA.HasValue (vals) then
item_type = item_type..' '..vals
end
return item_type
end --p.IT_required_vals
function p.IsHeader (key)
p.ChkFunc ("IsHeader", {{"key",key,"xr"},})
if string.find (key,'hd_') == 1 then
return true
else
return false
end
end --IsHeader
function p.PerhapsDsplKeyMode (key)
if p.IsHeader (key) then
return '<b>'..key..'</b>'
else
return key
end
end --PerhapsDsplKeyMode
local tab = '	'
local function add_arg_item (option, mod_abbrev, key, wd_main, wd_lang, prop, item_type_req)
if p.IsReserv (key) then return end
if key == nil then
error ('Not set key') --for debug
end
if wd_main == nil then
error ('Not wd_main for key = "'..key..'"') --for debug
end
if wd_lang == nil then
wd_lang = ''
end
local item_type, required, vals = p.split_item_type_req_vals_forList (item_type_req)
if option == p.LOpt.params then
local function concat_wd (A)
if type(A) == 'table' then
for i, j in pairs(A) do
if type(j) == 'table' then
SD.vtos (j)
error ('Error in table design and key = "'..key..'":'..SD.s..' must be a string') --for debug
end
end
A = table.concat (A, ', ')
end
if A == nil then
error ('Not set variable for key = "'..key..'"') --for debug
end
return A
end
p.add_mod_used_in_class (mod_abbrev)
local row = ''
row = p.add_pos (row)
row = row..'<td>'..p.PerhapsDsplKeyMode(key)..'</td><td>'..concat_wd(wd_main)..'</td><td>'..concat_wd(wd_lang)..'</td>'
if p.with_arg_prop then
if SA.HasValue (prop) then
if prop == true then
row = row..'<td>true</td><td></td>'
elseif prop == false then
row = row..'<td>false</td><td></td>'
elseif type(prop) == 'table' then
local props = prop["property"]
if props == nil then
--Prop contains a pattern to format a manual value
row = row..'<td></td><td></td>'
else
local sep = ''
if string.find(props, ' OR ') then
sep = ' OR '
props = mw.text.split (props,sep)
sep = '<small>'..sep..'</small>'
elseif string.find(props, '/') then
sep = '/'
props = mw.text.split (props,sep)
end
if type(props) == 'table' then
local trans = {}
for k, w in ipairs(props) do
props[k] = '[[:wikidata:Property:'..w..'|'..w..']]'
local wd = WD.getLabel({w, ['lang']=p.lang})
if wd ~= nil then
table.insert (trans, wd)
end
end
row = row..'<td><span style="font-size:50%">WD </span>'..table.concat(props,sep)..'</td><td>'..table.concat(trans,', ')..'</td>'
else
local wd = WD.getLabel({props, ['lang']=p.lang})
row = row..'<td><span style="font-size:50%">WD </span>'..props..'</td><td>'..wd..'</td>'
end
end
elseif string.sub (prop,1,1) == '_' then
local props = mw.text.split(string.sub (prop,2), '-')
local trans = {}
for k, w in ipairs(props) do
if string.sub (w,1,1) == 'Q' then
props[k] = '[[:wikidata:'..w..'|'..w..']]'
else
props[k] = '[[:wikidata:Property:'..w..'|'..w..']]'
end
local wd = WD.getLabel({w, ['lang']=p.lang})
if wd ~= nil then
table.insert (trans, wd)
end
end
row = row..'<td><span style="font-size:50%">WD </span>'..table.concat(props,',')..'</td><td>'..table.concat(trans,', ')..'</td>'
elseif string.sub (prop,1,5) == 'Color:' then
local color = string.sub (prop,6)
row = row..'<td><span style="background-color:'..color..'">'..color..'</span></td><td></td>'
else
row = row..'<td>'..prop..'</td><td></td>'
end
else
row = row..'<td></td><td></td>'
end
end
row = p.append_mod_item (mod_abbrev, row)
p.add_arg_types_used (item_type)
item_type = p.IT_required_vals (item_type, required, vals)
p.ins_tab_row (row..'<td>'..item_type..'</td>')
elseif option == p.LOpt.template then
item_type = tab..tab..tab..'"type": "'..AT_TD[ConvToTemplateDate(item_type)]..'"'
local wd = ''
local alias = {}
local function get_wd_alias (A)
if type(A) == 'table' then
wd = A[1]
for i = 2, #A do
table.insert (alias, A[i])
end
else
wd = A
end
end
if wd_lang == '' then
get_wd_alias (wd_main)
else
get_wd_alias (wd_lang)
if type(wd_main) == 'table' then
for _, w in ipairs(wd_main) do
table.insert (alias, w)
end
else
table.insert (alias, wd_main)
end
end
if #alias > 0 then
table.insert (p.tab_items, tab..tab..'"'..wd..'": {')
table.insert (p.tab_items, tab..tab..tab..'"aliases": [')
local function PresAlias (S)
local N = tonumber(S)
if not N then
return '"'..S..'"'
else
return '["'..S..'"]'
end
end
for i = 1, (#alias-1) do
table.insert (p.tab_items, tab..tab..tab..tab..PresAlias(alias[i])..',')
end
table.insert (p.tab_items, tab..tab..tab..tab..PresAlias (alias[#alias]))
table.insert (p.tab_items, tab..tab..tab..'],')
else
table.insert (p.tab_items, tab..tab..'"'..wd..'": {')
end
if required then
item_type = item_type..','
end
table.insert (p.tab_items, item_type)
if required then
table.insert (p.tab_items, tab..tab..tab..'"required": true')
end
table.insert (p.tab_items, tab..tab..'},')
end
end --add_arg_item
function p.GetITRFromLims (lims, key)
if lims == nil then
return p.IT.s
else
return lims[key]
end
end --GetITRFromLims
function p.GetITRFromLimsGr (lims, grp, key)
if lims[grp] == nil then
return p.IT.s
else
return lims[grp][key]
end
end --GetITRFromLimsGr
function p.add_arg_item (option, mod_abbrev, key, wd_main, wd_lang, lims)
local prop = nil
local item_type_req = p.GetITRFromLims (lims, key)
if p.with_arg_prop then
prop = wd_main[p.k.Args][key][2]
wd_main = wd_main[p.k.Args][key][1]
else
wd_main = wd_main[p.k.Args][key][1]
end
wd_lang = wd_lang[p.k.Args][key]
add_arg_item (option, mod_abbrev, key, wd_main, wd_lang, prop, item_type_req)
end --add_arg_item
function p.add_arg_item_grp (option, mod_abbrev, grp, key, wd_main, wd_lang, lims)
local prop = nil
local item_type_req = p.GetITRFromLims (lims, grp, key)
if p.with_arg_prop then
prop = wd_main[p.k.Args][grp][key][2]
wd_main = wd_main[p.k.Args][grp][key][1]
else
wd_main = wd_main[p.k.Args][grp][key][1]
end
wd_lang = wd_lang[p.k.Args][grp][key]
add_arg_item (option, mod_abbrev, grp..'.'..key, wd_main, wd_lang, prop, item_type_req)
end --add_arg_item_grp
local function CheckIdx0 (tab)
if tab == nil then
error ('List not assigned') --Don't translate, for debug
elseif not SA.TableWithItems(tab) then
error ('List without items') --Don't translate, for debug
end
end --CheckIdx0
function p.CheckIdx (tab)
--checks that table of {'a','b'..} is assigned, contents items.
CheckIdx0 (tab)
local s = #tab
local pos = 0
local old_val = ""
for _, key in ipairs(tab) do
pos = pos + 1
old_val = key
end
if pos ~= #tab then
error ('List error in the key after key "'..old_val..'"') --Don't translate, for debug
end
end --CheckIdx
function p.CheckLims0 (ModuleName, tab)
local s = #tab
for key, lims in pairs(tab) do
local found = false
local tt
local k
for t, i in pairs(p.IT) do
k = lims
if type(k) == 'table' then
k = k[1]
end
if i == k then
found = true
tt = t
break
end
end
local function key_lims ()
return '"'..key..'" (from '..ModuleName..')'
end
if not found then
error ('Invalid argument type ("'..k..'") for '..key_lims())
end
if type(lims) == 'table' then
local function CheckKeyN ()
if #lims ~= 2 then
error ('Two parameters (now '..#lims..') are required for '..key_lims())
end
end
if lims[1] == 'a' then --array
CheckKeyN ()
local count = 0
for _,i in ipairs(lims[2]) do
if type(i) ~= 'string' then
SD.vtos (i)
error ('An array item ('..SD.s..') is not a string. For '..key_lims())
end
count = count + 1
end
if count < 2 then
error ('More than 1 items ara required for '..lims[1]..' '..key_lims())
end
else --numeric with limits
local function ParFor (n)
return 'Parameter for '..lims[1]..' '..key_lims()
end
local function CheckOrder ()
if tonumber(lims[2][1]) > tonumber(lims[2][2]) then
error ('Invalid order for limits for '..key_lims())
end
end
if tt == p.IT.i then
CheckKeyN ()
SA.CheckSIsInt (lims[2][1], ParFor(2))
SA.CheckSIsInt (lims[2][2], ParFor(3))
CheckOrder ()
elseif tt == p.IT.n then
CheckKeyN ()
SA.CheckSIsNum (lims[2][1], ParFor(2))
SA.CheckSIsNum (lims[2][2], ParFor(3))
CheckOrder ()
else
error ('No parameters allowed for argument type "'..tt..'" for '..key_lims())
end
end
end
end
end --CheckLims0
function p.CheckLims (ModuleName, tab)
p.CheckLims0 (ModuleName, tab)
end
function p.foot_for_args ()
begin_foot (false)
perhaps_mod_used ()
if (#arg_types_used > 1) or has_required then
local item_types = {}
for _, i in ipairs(arg_types_used) do
table.insert (item_types, i..' ('..p.AT_Read[i]..')')
end
local row = 'Used argument types: '..table.concat(item_types,', ')
if has_required then
row = row..'. "-R" indicates required arguments.'
end
table.insert (p.tab_items, row)
end
return table.concat (p.tab_items, '')
end --foot_for_args
function p.show_arg_items (option, idx, func, tab_modname_func)
if option == p.LOpt.template then
table.insert (p.tab_items, '<pre>')
table.insert (p.tab_items, '<templatedata>')
table.insert (p.tab_items, '{')
table.insert (p.tab_items, tab..'"params": {')
else
table.insert (p.tab_items, '<table class="wikitable sortable">')
row = p.begin_headers()..'<th>Default names</th><th>Localized names (i18n)</th>'
if p.with_arg_prop then
row = row..'<th>Values</th><th>WD content ('..SA.lang_to_use..')</th>'
end
p.ins_tab_row (row..'<th>T.</th>')
end
p.CheckIdx (idx)
local function WhenMod (k)
for _, j in ipairs (tab_modname_func) do
if (j[1] == '') or (j[1] == k) then
j[2] (option, k)
break
end
end
end --WhenMod
local function WhenMain (k)
local mod_abbrev, wd_main, wd_lang, lims = func (k)
p.add_arg_item (option, mod_abbrev, k, wd_main, wd_lang, lims)
end
local function WhenModGr (grp, k)
for _, j in ipairs (tab_modname_func) do
if (j[1] == '') or (j[1] == k) then
j[2] (option, grp, k)
break
end
end
end --WhenModGr
local function WhenMainGr (grp, k)
local mod_abbrev, wd_main, wd_lang, lims = func (grp, k)
p.add_arg_item_grp (option, mod_abbrev, grp, k, wd_main, wd_lang, lims)
end
if idx[SA.HasChild] == nil then
for _, key in ipairs(idx) do
if type(key) == 'table' then -- key = {type, key}; when type, any value of {'al', 'a', 'l', '-'}
if key[1] == '-' then
WhenMod (key[2])
elseif string.find (key[1],'a') then
WhenMain (key[2])
end
else
if string.sub (key,1,1) == '_' then
WhenMod (string.sub (key,2))
else
WhenMain (key)
end
end
end
else
for _, grp in ipairs(idx) do
for _, key in ipairs(idx[grp]) do
if type(key) == 'table' then -- key = {type, key}; when type, any value of {'al', 'a', 'l', '-'}
if key[1] == '-' then
WhenModGr (grp, key[2])
elseif string.find (key[1],'a') then --'a' of argument
WhenMainGr (grp, key[2])
end
else
if string.sub (key,1,1) == '_' then
WhenModGr (grp, string.sub (key,2))
else
WhenMainGr (grp, key)
end
end
end
end
end
if option == p.LOpt.template then
local S = p.tab_items[#p.tab_items]
p.tab_items[#p.tab_items] = string.sub (S, 1, string.len(S)-1)
table.insert (p.tab_items, tab..'},')
table.insert (p.tab_items, tab..'"format": "block"')
table.insert (p.tab_items, '}')
table.insert (p.tab_items, '</templatedata>')
table.insert (p.tab_items, '</pre>')
return table.concat (p.tab_items, '</br>')
else
return p.foot_for_args ()
end
end --show_arg_items
local function add_lab_item (mod_abbrev, key, wd_main, wd_lang, lnk)
p.add_mod_used_in_class (mod_abbrev)
if wd_lang == nil then --not translated
wd_lang = ''
end
local row = ''
row = p.add_pos (row)
row = row..'<td>'..p.PerhapsDsplKeyMode(key)..'</td><td>'..wd_main..'</td>'
row = p.append_mod_item (mod_abbrev, row)
if p.uses_QP_for_labels then
if lnk ~= '' then
local lnk1 = lnk
if string.sub (lnk,1,1) == 'P' then
lnk1 = 'Property:'..lnk1
end
row = row..'<td>[[:wikidata:'..lnk1..'|'..lnk..']]</td><td>'..WD.getLabel({lnk, ['lang']=p.lang})..'</td>'
else
row = row..'<td></td><td></td>'
end
end
row = row..'<td>'..wd_lang..'</td>'
p.ins_tab_row (row)
end --add_lab_item
function p.add_lab_item (mod_abbrev, key, wd_main, wd_lang, lnk)
add_lab_item (mod_abbrev, key, wd_main, wd_lang, lnk)
end
function p.add_lab_item_grp (mod_abbrev, grp, key, wd_main, wd_lang, lnk)
add_lab_item (mod_abbrev, grp..'.'..key, wd_main, wd_lang, lnk)
end
function p.show_lab_items (idx, func, tab_modname_func)
table.insert (p.tab_items, '<table class="wikitable sortable">')
local row = ''
if p.uses_QP_for_labels then
row = '<th>Source/WD content (en)</th>'
else
row = '<th>Source</th>'
end
row = p.begin_headers()..row
if p.uses_QP_for_labels then
row = row..'<th>WD</th><th>WD content ('..SA.lang_to_use..')</th>'
end
row = row..'<th>Localization (i18n)</th>'
p.ins_tab_row (row)
p.CheckIdx (idx)
local function WhenMod (key)
if tab_modname_func ~= nil then
for _, j in ipairs (tab_modname_func) do
if (j[1] == "") or (j[1] == key) then
j[2](key)
break
end
end
end
end --WhenMod
local function WhenMain (k)
local mod_abbrev, key, wd_main, wd_lang, lnk = func (k)
p.add_lab_item (mod_abbrev, k, wd_main, wd_lang, lnk)
end
local function WhenModGr (grp, key)
if tab_modname_func ~= nil then
for _, j in ipairs (tab_modname_func) do
if (j[1] == "") or (j[1] == key) then
j[2](grp, key)
break
end
end
end
end --WhenModGr
local function WhenMainGr (grp, k)
local mod_abbrev, key, wd_main, wd_lang, lnk = func (grp, k)
p.add_lab_item_grp (mod_abbrev, grp, k, wd_main, wd_lang, lnk)
end
local function HasLabel (key)
return (string.find (key,'l')) or (key == 'L')
end
if idx[SA.HasChild] == nil then
for _, key in ipairs(idx) do
if type(key) == 'table' then -- key = {type, key}; when type, any value of {'al', 'a', 'l', '-'}
if key[1] == '-' then
WhenMod (key[2])
elseif HasLabel (key[1]) then
WhenMain (key[2])
end
else
if string.sub (key,1,1) == '_' then
WhenMod (string.sub (key,2))
else
WhenMain (key)
end
end
end
else
for _, grp in ipairs(idx) do
for _, key in ipairs(idx[grp]) do
if type(key) == 'table' then -- key = {type, key}; when type, any value of {'al', 'a', 'l', '-'}
if key[1] == '-' then
WhenModGr (grp, key[2])
elseif HasLabel (key[1]) then
WhenMainGr (grp, key[2])
end
else
if string.sub (key,1,1) == '_' then
WhenModGr (grp, string.sub (key,2))
else
WhenMainGr (grp, key)
end
end
end
end
end
begin_foot (true)
perhaps_mod_used ()
return table.concat (p.tab_items, '')
end --show_lab_items
local function add_msg_error_item (mod_abbrev, key, wd_main, wd_lang)
if wd_lang == nil then
wd_lang = ''
end
p.add_mod_used_in_class (mod_abbrev)
local any = '<td>'..key..'</td><td>'..wd_main..'</td><td>'..wd_lang..'</td>'
any = p.append_mod_item (mod_abbrev, any)
p.ins_tab_row (any)
end --add_msg_error_item
function p.add_msg_error_item (mod_abbrev, key, wd_main, wd_lang)
add_msg_error_item (mod_abbrev, key, wd_main, wd_lang)
end
function p.add_msg_error_item_grp (mod_abbrev, grp, key, wd_main, wd_lang)
add_msg_error_item (mod_abbrev, grp..'.'..key, wd_main, wd_lang)
end
function p.show_msgs_errors (idx, func, tab_modname_func)
table.insert (p.tab_items, '<table class="wikitable sortable">')
local row = '<th>Source</th><th>Translation</th>'
p.ins_tab_row (p.begin_headers()..row)
p.CheckIdx (idx)
if idx[SA.HasChild] == nil then
for _, key in ipairs(idx) do
if key[1] == '-' then
key = key[2]
for _, j in ipairs (tab_modname_func) do
if (j[1] == "") or (j[1] == key) then
j[2](key)
break
end
end
else
local mod_abbrev, key, tab_main, tab_lang = func (key[2])
p.add_msg_error_item (mod_abbrev, key, tab_main, tab_lang)
end
end
else
for _, grp in ipairs(idx) do
for _, key in ipairs(idx[grp]) do
if key[1] == '-' then
key = key[2]
for _, j in ipairs (tab_modname_func) do
if (j[1] == "") or (j[1] == key) then
j[2](grp, key)
break
end
end
else
local mod_abbrev, key, tab_main, tab_lang = func (grp, key[2])
p.add_msg_error_item_grp (mod_abbrev, grp, key, tab_main, tab_lang)
end
end
end
end
table.insert (p.tab_items, '</table>')
perhaps_mod_used ()
return table.concat (p.tab_items, '')
end --show_msgs_errors
return p