Documentation for this module may be created at Module:Sandbox/Χ/InfoboxMaker/doc
local ga = require('Module:Arguments').getArgs
local tt = require('Module:TableTools')
local ib = require('Module:Infobox').infobox
local ii = require('Module:InfoboxImage').InfoboxImage
local origArgs -- Args received from the the initalizing module.
local ibArgs = {} -- Args sent to Module:Infobox
local categories = {} -- Categories appended to the Infobox
local counter = {
row = 1,
subheader = 1,
image = 1,
}
local params = {
global = {
'child', -- properties
'subbox',
'name',
'italic title',
'decat',
'bodyclass', -- classes
'titleclass',
'aboveclass',
'subheaderclass',
'imageclass',
'headerclass',
'belowclass',
'bodystyle', -- styles
'titlestyle',
'abovestyle',
'subheaderstyle',
'captionstyle',
'imagestyle',
'headerstyle',
'labelstyle',
'datastyle',
'belowstyle',
},
row = {
'header',
'label',
'data',
'class',
'rowclass',
'rowstyle',
'rowcellstyle',
'dataid',
'labelid',
'headerid',
'rowid',
},
subheader = {
'subheader',
'subheaderrowclass',
'subheaderstyle',
},
image = {
'image',
'size',
'maxsize',
'sizedefault',
'alt',
'border',
'suppressplaceholder',
'imagerowclass',
'caption',
},
}
local functions = {
['or'] = function (x)
if type(x) ~= table then return x end
for _, v in pairs(x) do
if not isEmpty(v) then return v end
end
end,
['ul'] = function (x)
if type(x) ~= table then return x end
local l = mw.html.create('ul')
for _, v in pairs(x) do
if not isEmpty(v) then l:tag('li'):wikitext(v) end
end
return l
end,
['ol'] = function (x)
if type(x) ~= table then return x end
local l = mw.html.create('ol')
for _, v in pairs(x) do
if not isEmpty(v) then l:tag('li'):wikitext(v) end
end
return l
end,
___ = function (x) return type(x) == 'table' and x[1] or x end
}
setmetatable(functions, {__index = function (t) return t.___ end})
--[[
--------------------------------------------------------------------------------
------------------------------- Helper functions -------------------------------
--------------------------------------------------------------------------------
--]]
--[[
-- Checks whether x is nil, empty or false
--]]
local function isEmpty(x)
return x == nil or x == '' or x == false or (type(x) == 'table' and tt.size(x) == 0)
end
--[[
-- Transforms x into a table
--]]
function totable(x)
return type(x) == 'table' and x or {x}
end
--[[
-- Replaces one or multiple arguments with their associated value in origArgs.
-- There is an optional "n" suffix, intended to be a number.
--]]
local function argToVal(args, n)
n = n and tostring(n) or ""
if type(args) == 'table' then
if n == '1' then
for i, v in pairs(args) do
args[i] = origArgs[v .. '1'] or origArgs[v]
end
else
for i, v in pairs(args) do
args[i] = origArgst[v .. n]
end
end
elseif type(args) == 'string' then
if n == '1' then
args = origArgs[args .. '1'] or origArgs[args]
else
args = origArgs[args .. n]
end
end
return args
end
--[[
-- Used to build "repeated" things.
-- Filters out values and arguments using their indices.
--]]
function filter(args, params, valIndex, argIndex)
local newArgs = {}
for _, param in ipairs(params) do
local paramArg = args[param .. "Arg"]
local paramVal = args[param]
local default
if type(paramVal) ~= 'table' then
default = paramVal
paramVal = {}
end
newArgs[param] = paramVal[valIndex] or argToVal(paramArg, argIndex) or default
newArgs[param .. "Func"] = args[param .. "Func"]
end
return newArgs
end
--[[
-- Sets up unique elements like title, above, below, etc.
--]]
local function uniqueElement(prefix, args)
if type(args) ~= 'table' then
ibArgs[prefix] = args or ibArgs[prefix]
else
ibArgs[prefix] = args[prefix] or ibArgs[prefix]
ibArgs[prefix .. 'class'] = args.class or args[prefix .. 'class'] or ibArgs[prefix .. 'class']
ibArgs[prefix .. 'style'] = args.style or args[prefix .. 'style'] or ibArgs[prefix .. 'style']
end
end
--[[
-- Sets up incremental elements like images, subheader, and data rows
-- Optional n parameter.
--]]
function addElement(elem, args, n)
local i
if n == nil then
i = tostring(counter[elem])
counter[elem] = counter[elem] + 1
else
i = tostring(n)
end
for _, param in ipairs(params[elem]) do
local func = args[param .. "Func"]
if type(func) ~= 'function' then func = functions[func] end
local value = args[param] or argToVal(args[param .. "Arg"])
ibArgs[param .. i] = pcall(function () func(value) end) and func(value) or value
end
end
--[[
--------------------------------------------------------------------------------
------------------------------- Member functions -------------------------------
--------------------------------------------------------------------------------
--]]
local p = {}
function p.initialize(args)
-- Modules using InfoboxMaker must first initialize it with a set of args.
origArgs = args
end
--[[
-- Global styling and class assignments
--]]
function p.setup(args)
for _, param in ipairs(params.global) do
ibArgs[param] = args[param]
end
end
function p.title(args)
uniqueElement('title', args)
end
function p.above(args)
uniqueElement('above', args)
end
function p.below(args)
uniqueElement('below', args)
end
--[[
-- Adds a single subheader
--]]
function p.addSubheader(args)
uniqueElement('subheader', {class=args.class or args.subheaderclass})
addElement('subheader', args)
end
--[[
-- Adds a single image and caption
--]]
function p.addImage(args)
uniqueElement('image', {
class=args.class or args.imageclass,
style=args.style or args.imagestyle,
})
local imgArgs = {}
local i = tostring(counter.image)
counter.image = counter.image + 1
for _, param in ipairs(params.image) do
local func = args[param .. "Func"]
if type(func) ~= 'function' then func = functions[func] end
local value = args[param] or argToVal(args[param .. "Arg"])
imgArgs[param] = pcall(function () func(value) end) and func(value) or value
end
ibArgs['image' .. i] = ii{args=imgArgs}
ibArgs['imagerowclass' .. i] = imgArgs.imagerowclass
ibArgs['caption' .. i] = imgArgs.caption
end
--[[
-- Adds a single category
--]]
function p.addCategory(catArgs)
local name = catArgs.name or ""
local key = catArgs.key or ""
if not isEmpty(name) then
if isEmpty(key) then
table.insert(categories, "[[Category:" .. name .. "]]")
else
table.insert(categories, "[[Category:" .. name .. "|" .. key .. "]]")
end
end
end
--[[
-- Adds a single row
--]]
function p.addRow(rowArgs, n)
local i
if n == nil then
i = tostring(counter.row)
counter.row = counter.row + 1
else
i = tostring(n)
end
for _, param in ipairs(params.row) do
local func = rowArgs[param .. "Func"]
if type(func) ~= 'function' then func = functions[func] end
local value = rowArgs[param] or argToVal(rowArgs[param .. "Arg"])
ibArgs[param .. i] = pcall(function () func(value) end) and func(value) or value
end
if ibArgs["header" .. i] or ibArgs["data" .. i] then
return true
else
return false
end
end
--[[
-- Adds multiple rows. Useful for numbered parameters.
--]]
function p.addRepeatedRow(rowArgs)
local added = false
-- First, determine how many rows will be needed
local n = {}
local m = 0
for _, param in ipairs(params.row) do
-- Number of paramArgs
local paramArg = totable(rowArgs[param .. "Arg"])
for _, prefix in pairs(paramArg) do
for _, v in ipairs(tt.affixNums(origArgs, prefix)) do
table.insert(n, v)
end
end
-- Number of paramVals
local paramVal = totable(rowArgs[param])
m = math.max(m, #paramVal)
end
if isEmpty(n) then
for i=1,m do table.insert(n, i) end
else
n = tt.removeDuplicates(n)
table.sort(n)
end
-- Second, actually generate the rows
if not isEmpty(n) then
for i, j in ipairs(n) do
local newRowArgs = filter(rowArgs, params.row, i, j)
added = p.addRow(newRowArgs) or added
end
end
return added
end
--[[
-- Adds a set of rows. The "first" row is added only if the rest is not empty.
-- Individual rows can actually be sections, repeated rows, or single rows.
-- First row must be a single row.
--]]
function p.addSection(sectionArgs)
local rows = sectionArgs.rows or {}
local first = sectionArgs[1] or {}
local added = false
local h = counter.row
counter.row = counter.row + 1
for _, row in ipairs(rows) do
if row.mode == 'section' then
added = p.addSection(row) or added
elseif row.mode == 'repeated' then
added = p.addRepeatedRow(row) or added
else
added = p.addRow(row) or added
end
end
if added then
p.addRow(first, h)
end
return added
end
--[[
-- Adds multiple sections sharing the same definition.
-- Useful with numbered parameters.
-- Only single rows are accepted.
--]]
function p.addRepeatedSection(sectionArgs)
local rows = sectionArgs.rows or {}
local first = sectionArgs[1] or {}
local added = false
local added_row = false
local h
-- First, determine how many rows will be needed
local n = {}
local m = 0
for _, rowArgs in ipairs(rows) do
for _, param in ipairs(params.row) do
-- Number of paramArgs
local paramArg = totable(rowArgs[param .. "Arg"])
for _, prefix in pairs(paramArg) do
for _, v in ipairs(tt.affixNums(origArgs, prefix)) do
table.insert(n, v)
end
end
-- Number of paramVals
local paramVal = totable(rowArgs[param])
m = math.max(m, #paramVal)
end
end
if isEmpty(n) then
for i=1,m do table.insert(n, i) end
else
n = tt.removeDuplicates(n)
table.sort(n)
end
-- Second, actually generate the rows
if not isEmpty(n) then
for i, j in ipairs(n) do
added_row = false
h = counter.row
counter.row = counter.row + 1
for _, rowArgs in ipairs(rows) do
local newRowArgs = filter(rowArgs, params.row, i, j)
added_row = p.addRow(newRowArgs) or added
end
if added_row then
local newFirst = filter(first, params.row, i, j)
added = p.addRow(newFirst, h) or added_row or added
end
end
end
return added
end
--[[
-- Generate the infobox! Append categories if any.
--]]
function p.makeInfobox()
return ib(ibArgs) .. mw.text.listToText(categories, '', '')
end
return p