Module:Infobox: Difference between revisions
Clean up, annotated. Finalized, hopefully not many bugs
(Fix tabs) |
(Clean up, annotated. Finalized, hopefully not many bugs) |
||
Line 6:
-- Edit button for unknown params
local editbutton = require('Module:Edit button')
local Infobox = {}
Infobox.__index = Infobox
--[[
Infobox class
-- config: table containing configuration parameters
--
-- args : values passed from the Template
---- the following values are treated specially: default_version, version, version1, version2...
--]]
function Infobox.new(config, params, args)
Line 32 ⟶ 29:
default_version = 1, -- default version to populate the infobox
versions = nil, -- number of versions
version_names = {
rtable = nil, -- infobox table to return at the end
switch_datatable = nil, -- datatable for javascript for switch infoboxes
categories = {}, -- set of categories
errors = {}, -- list of errors
__smw_debug = {}, -- debug data for smw subobjects
},
Infobox)
-- Step 1, setup config vars and count the versions
obj:config(config)
obj:parse_versions()
-- Step 2, process the params
obj:define_params(params)
obj:parse_params()
-- Table
obj:table_header()
obj:buttons()
-- Misc
obj:store_smw()
obj:parse_categories()
return obj
end
--[[
Refers to a param after being processed by the validating func
Used in add_row(), define_params() and is_param_defined()
--]]
function Infobox.param(param_name)
param = {
property = 'args_parsed',
param_name = param_name,
}
return param
end
--[[
Refers to a param in raw form as passed from the Template
Used in add_row(), define_params() and is_param_defined()
--]]
function Infobox.raw_param(param_name)
param = {
property = 'args_raw',
param_name = param_name,
}
return param
end
--[[
Refers to a param after being processed by the validating smw_func
Used in add_row(), define_params() and is_param_defined()
--]]
function Infobox.smw_param(param_name)
param = {
property = 'args_smw',
param_name = param_name,
}
return param
end
--[[
Checks to see if a param is defined.
-- param: Infobox.param(name), Infobox.raw_param(name) or Infobox.smw_param(name)
Returns 0 if param is never defined
1 if param is defined for a fraction of the versions
2 if param is defined for all versions
]]
function Infobox:is_param_defined(param)
local undefined = 0
local defined = 0
for version = 1, self.versions do
local value = self:get_param(param, version)
if value ~= nil then
defined = 1
else
undefined = 1
end
end
return 1 + defined - undefined
end
--[[
Adds a row to the infobox table
Parameter should be a table of cells, where each cell is a table with the following arguments:
-- tag : 'td' or 'th'
-- content : a string or Infobox.param(name), Infobox.raw_param(name), Infobox.smw_param(name)
-- attr (optional) : mw.html:attr({ arg1 = '1', ... })
-- css (optional) : mw.html:css({ arg1 = '1', ...)
-- class (optional) : mw.html:addClass('arg')
---- class also supports a table of values, even though mw.html:addClass() does not
---- common classes: infobox-subheader
-- rowspan (optional) : mw.html:attr('rowspan',arg)
-- colspan (optional) : mw.html:attr('colspan',arg)
-- title (optional) : mw.html:attr('title',arg)
The row itself may be assigned a single class by setting the value of the key addClass
-- addClass : mw.html:addClass('arg')
-- this function currently only supports a single string
--]]
function Infobox:add_row(...)
local args = ...
local _row = self.rtable:tag('tr')
-- For each cell
for _, v in ipairs(args) do
local _cell = _row:tag(v.tag)
-- Optional parameters
if v.attr then
_cell:attr(v.attr)
end
if v.colspan then
_cell:attr('colspan',v.colspan)
end
if v.rowspan then
_cell:attr('rowspan',v.rowspan)
end
if v.title then
_cell:attr('title',v.title)
end
if v.css then
_cell:css(v.css)
end
if v.class then
if type(v.class) == 'string' then
_cell:addClass(v.class)
-- mw.html:addClass() doesn't function with tables, add in a loop
elseif type(v.class) == 'table' then
for _, w in ipairs(v.class) do
_cell:addClass(w)
end
end
end
-- Populate the cell contents
local content = self:get_param(v.content, self.default_version)
if content == nil then
content = self.params[v.content.param_name].empty
end
_cell:wikitext(content)
-- Add the switch data if multiple values exist
data_attr_param = self:add_switch_data(v.content)
if data_attr_param then
_cell:attr('data-attr-param', data_attr_param)
end
end
-- allow classes to be defined on the whole row
if args.addClass then
_row:addClass(args.addClass)
end
return self
end
--[[
Adds a blank row of padding spanning the given number of columns
--]]
function Infobox:pad(colspan, class)
local tr = self:tag('tr'):tag('td'):attr('colspan', colspan or 1):addClass('infobox-padding')
if class then
tr:addClass(class)
end
return self
end
--[[
Adds a class to the table as a whole
--]]
function Infobox:addClass(arg)
self.rtable:addClass(arg)
return self
end
--[[
Setup config values
-- config: table containing configuration parameters
---- infobox_name = mandatory unique identifier for this infobox, used for css
---- max_buttuons = max number of switch buttons before using a dropdown list instead
--]]
function Infobox:config(config)
for k, v in pairs(config) do
if k == 'infobox_name' then
self.infobox_name = mw.ustring.gsub(v, '%s', '_')
elseif k == 'max_buttons' then
self.max_buttons = tonumber(v)
end
end
if self.infobox_name == nil then
table.insert(self.errors, 'infobox_name needs to be defined in Infobox.new()\'s config!')
end
return self
end
--[[
Counts the number of versions in the infobox
Populates Infobox.version_names
Sets Infobox.default_version
--]]
function Infobox:parse_versions()
-- Count the versions and setup self.version_names
local i = 1
while self.args_raw['version'..i] do
Line 107 ⟶ 239:
end
self.versions = i - 1
-- Handle the no version case -
if self.versions == 0 then
table.insert(self.version_names, self.args_raw['version'] or 'DEFAULT')
end
-- Should either have 0 or 2+ versions
if self.versions == 1 then
table.insert(self.errors, 'There should be multiple versions or no versions. If defining a custom version name for a single entry, use "version=Name" instead of "version1=Name".')
self.versions = 0
end
-- Check for a default_version
if self.args_raw['default_version'] then
self.default_version = tonumber(self.args_raw['default_version'])
Line 123 ⟶ 257:
end
--[[
Define all used parameters (except for default_version/version)
-- name : parameter name as used in the Template
-- func : function to validate and process the Template argument
-- If func is a function, will call func(Infobox.raw_param(name))
-- If func is a table, contains the following key-value pairs:
---- name : function
---- params : list of arguments to pass to the function (use Infobox.raw_param(),
---- Infobox.param() and Infobox.smw_param() to use arguments)
-- empty (optional) : text to display in the infobox if func returns nil, defaults to "? (edit)"
-- category_never : category to add if func returns nil for all versions
-- category_partial : category to add if func returns nil for some versions, but a value for other versions
-- category_incomplete : category to add if func returns nil for at least 1 version (i.e. category_never and category_partial combined)
-- category_complete : category to add if func returns a value for all versions
-- smw_property (optional) : if this string is defined, the parameter will be saved into smw
-- smw_func (optional) : function to validate and process the Template argument to save into smw
-- func is used by default if smw_func is not defined
--]]
function Infobox:define_params(...)
-- For every parameter, store its corresponding function to self.params
for _, v in ipairs(...) do
if v.name then
local param = {}
-- Copy the function
if type(v.func) == 'function' or type(v.func) == 'table' then
param.func = v.func
end
-- If smw_property is defined, then use smw_func, or default to func if it is not defined
if v.smw_property then
param.smw_property = v.smw_property
if type(v.smw_func) == 'function' or type(v.smw_func) == 'table' then
param.smw_func = v.smw_func
else
param.smw_func = param.func
end
end
-- If empty is not defined, default message is "? (edit)"
param.empty = v.empty or editbutton("'''?''' (edit)")
-- Get the category names
param.category_never = v.category_never
param.category_partial = v.category_partial
param.category_incomplete = v.category_incomplete
param.category_complete = v.category_complete
-- Store the param
self.params[v.name] = param
table.insert(self.param_names, v.name)
end
end
return
end
--[[
Fetches a param value. If the value is nil, will return the default value instead
-- arg: a non-table
-- version: 0/'' for default, or else a number
Returns arg if a constant
param value (or default value) if Infobox.param(name), Infobox.raw_param(name), Infobox.smw_param(name)
--]]
function Infobox:get_param(arg, version)
Line 169 ⟶ 321:
version = ''
end
-- Handle Infobox.param(), Infobox.raw_param(), Infobox.smw_param()
if type(arg) == 'table' then
local value = self[arg.property][arg.param_name..version]
if value == nil then
value = self[arg.property][arg.param_name]
end
return value
end
-- Everything else passes through unmodified (string, number, etc)
return arg
end
--[[
Calculates the parsed value of a param
-- param_name :
-- version : 0/'' for default, or else a number
-- smw : boolean,
--]]
function Infobox:parse_param(param_name, version, smw)
Line 211 ⟶ 366:
--[[
Parses all the param values (args_parsed and args_smw)
--]]
function Infobox:parse_params()
-- Calculate the param value for all params and all versions
Line 216 ⟶ 374:
for version=0, self.versions do
if version == 0 then
version = ''
end
--
-- Only get the smw value if smw_property is defined
end
end
Line 231 ⟶ 387:
--[[
Creates the table header
--]]
function Infobox:table_header()
-- Create infobox table
self.rtable = mw.html.create('table')
:addClass('plainlinks')
:addClass('infobox')
:addClass('infobox-'..self.infobox_name)
-- Create the switch datatable if multiple versions
if self.versions > 1 then
self.rtable:addClass('infobox-switch')
self.switch_datatable = mw.html.create('div')
:addClass('infobox-switch-resources')
:addClass('infobox-resources-'..self.infobox_name)
:addClass('hidden')
self.switch_datatable:tag('span'):wikitext('Versions: '..self.versions)
self.switch_datatable:tag('span'):wikitext('Default version: '..self.default_version)
end
return self
end
--[[
If multiple versions exist, creates a set of buttons for switching
-- self.max_buttons : if the number of versions exceeds this value, a dropdown will be created instead
--]]
function Infobox:buttons()
if self.versions < 2 then
return
end
-- Button caption
local buttons = self.rtable:tag('caption')
:tag('div')
:addClass('infobox-buttons')
:attr('data-default-version', self.default_version)
-- Dropdown list instead of buttons if too many versions
if self.versions > self.max_buttons then
buttons:addClass('infobox-buttons-select')
end
-- Create all the buttons
for version=1, self.versions do
buttons:tag('span')
Line 305 ⟶ 435:
:wikitext(self.version_names[version])
end
end
--[[
For each version, stores a subobject for all params that have smw_property defined
--]]
function Infobox:store_smw()
for version=1, self.versions do
-- Generate a subobject name
-- Reminder - subobject name cannot have a . in the first 5 characters
local subobject_name = 'Infobox.'..mw.title.getCurrentTitle().fullText..'#'..self.version_names[version]
-- Store each param that has smw_property defined and is not nil
local subobject = {}
for _, param_name in ipairs(self.param_names) do
local property = self.params[param_name].smw_property
if property then
value = self:get_param(self.smw_param(param_name), version)
if value ~= nil then
subobject[property] = value
end
end
end
-- Keep a copy for debugging
self.__smw_debug[subobject_name] = subobject
-- Save subobjects if not in mainspace
if mw.title.getCurrentTitle():inNamespace(0) then
local result = mw.smw.subobject(subobject, subobject_name)
if result ~= true then
table.insert(self.errors, 'SMW error: '..result.error)
end
end
end
end
--[[
Automatically add categories for each param as defined in define_params()
--]]
function Infobox:parse_categories()
for _, param_name in ipairs(self.param_names) do
local param = self.params[param_name]
local defined = self:is_param_defined(Infobox.param(param_name))
if defined == 0 and param.category_never then
self.categories[param.category_never] = 1
end
if defined == 1 and param.category_partial then
self.categories[param.category_partial] = 1
end
if defined < 2 and param.category_incomplete then
self.categories[param.category_incomplete] = 1
end
if defined == 2 and param.category_complete then
self.categories[param.category_complete] = 1
end
end
end
--[[
When a parameter is added into the table, add the alternative versions' data into the switch datatable
-- content : a non-table value (string, number, etc), or Infobox.param(name), Infobox.raw_param(name), Infobox.smw_param(name)
Returns the name of the parameter in the tag 'data-attr-param'
--]]
function Infobox:add_switch_data(content)
if self.versions <= 1 then
return false
end
-- Only needed for non-constant params
if type(content) ~= 'table' then
return false
end
-- Only needed if the
local first_value = self:get_param(
local all_same = true
for version=2, self.versions do
if first_value ~= self:get_param(
all_same = false
break
Line 350 ⟶ 519:
end
-- Let's build the datatable
-- datum name: Prepend raw__ or
local name = content.param_name
if content.property == 'args_raw' then
Line 363 ⟶ 532:
text = self:get_param(content, version)
if text == nil then
text =
end
data_param:tag('span'):attr('data-attr-index', version):wikitext(text)
Line 370 ⟶ 539:
return name
end
--[[
Override tostring
--]]
function Infobox:
--
local
error_text = error_text..'<span class="mw-message-box-error">'..v..'</span>'
end
-- Create categories
local category_text = ''
for key, _ in pairs(self.categories) do
category_text = category_text..'[[Category:'..key..']]'
end
return tostring(self.rtable) .. tostring(self.switch_datatable) .. error_text .. category_text
end
--[[
Debug function
--]]
function Infobox:dump()
-- Temporarily detach the metatable so we don't override tostring anymore, allowing us to use dumpObject
setmetatable(self, nil)
mw.log(mw.dumpObject(self))
setmetatable(self, Infobox)
mw.log(tostring(self))
end
return Infobox
| |||