Editing Module:Infobox

Jump to navigation Jump to search
Warning: You are not logged in. Your IP address will be publicly visible if you make any edits. If you log in or create an account, your edits will be attributed to your username, along with other benefits.

The edit can be undone. Please check the comparison below to verify that this is what you want to do, and then publish the changes below to finish undoing the edit.

Latest revision Your text
Line 4: Line 4:


-- <nowiki>
-- <nowiki>
-- Edit button for unknown params
require('strict')
local editbutton = require('Module:Edit button')
local editbutton = require('Module:Edit button')
local smwutils = require('Module:SMW Utils')
local edit = editbutton("'''?''' (edit)")

local pagename = mw.title.getCurrentTitle().fullText


local Infobox = {}
local Infobox = {}
Line 13: Line 15:
--[[
--[[
Infobox class
Infobox class
-- infobox_name: the name of the infobox
-- config: table containing configuration parameters
-- params : definitions for each used value
-- args : parameters from frame to pass through
-- Special args: version, default_version
-- args : values passed from the Template
-- Sets a meta table and creates a <div> tag wrapper
---- the following values are treated specially: default_version, version, version1, version2...
-- other fields are initialized in other functions
--]]
--]]
function Infobox.new(config, params, args)
function Infobox.new(config, params, args)
Line 24: Line 27:
args_smw = {}, -- parameters parsed for smw
args_smw = {}, -- parameters parsed for smw
infobox_name = nil, -- template name
infobox_name = nil, -- template name
classes = {}, -- list of classes to add, using the default_version
param_names = {}, -- ordered param list
param_names = {}, -- ordered param list
params = {}, -- param definitions
params = {}, -- param definitions
Line 30: Line 32:
default_version = 1, -- default version to populate the infobox
default_version = 1, -- default version to populate the infobox
versions = nil, -- number of versions
versions = nil, -- number of versions
version_names = {}, -- title of each version (for selection and SMW)
version_names = {'INFOBOX_ERROR'}, -- title of each version (for selection and SMW); version_name[0] should not be used (base index should be 1)
rtable = nil, -- infobox table to return at the end
rtable = nil, -- infobox table to return at the end
switch_datatable = '', -- datatable for javascript for switch infoboxes
switch_datatable = nil, -- datatable for javascript for switch infoboxes
categories = {}, -- set of categories
errors = {}, -- list of errors
errors = {}, -- list of errors
__smw_debug = {}, -- debug data for smw subobjects
},
},
Infobox)
Infobox)
-- Step 1, setup config vars and count the versions
obj:config(config)
obj:config(config)
obj:parse_versions()
obj:parse_versions()
obj:create()
-- Step 2, process the params
obj:define_params(params)
obj:define_params(params)
obj:parse_params()
-- Table
obj:table_header()
obj:buttons()
-- Misc
obj:store_smw()
obj:parse_categories()
return obj
return obj
end
end




function Infobox:config(...)
--[[
for k, v in pairs(...) do
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)
local 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)
local 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)
local 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
local 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.rtable: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_buttons = 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
if k == 'infobox_name' then
self.infobox_name = mw.ustring.gsub(v, '%s', '_')
self.infobox_name = mw.ustring.gsub(v, '%s', '_')
elseif k == 'max_buttons' then
elseif k == 'max_buttons' then
self.max_buttons = tonumber(v)
self.max_buttons = tonumber(v)
elseif k == 'class' then
if type(v) == 'string' then
self.classes = {v}
elseif type(v) == 'table' then
self.classes = v
end
end
end
end
end
Line 230: Line 59:
return self
return self
end
end



--[[
--[[
Function for defining parameters
Counts the number of versions in the infobox
-- name : parameter name
Populates Infobox.version_names
-- func : function to define param, defaults to looking at blanks
Sets Infobox.default_version
DO NOT DEFINE VERSION HERE
USE :maxVersion()
Can be used any number of times for efficient definition
--]]
--]]
function Infobox:parse_versions()
local function insert_version_name(version_name)
table.insert(self.version_names, version_name)
if smwutils.valid_subobject_name(version_name) == false then
table.insert(self.errors, 'Illegal version value: must not be "0" nor contain a "." in the first five characters')
end
end
-- Count the versions and setup self.version_names
local i = 1
while self.args_raw['version'..i] do
insert_version_name(self.args_raw['version'..i])
i = i + 1
end
self.versions = i - 1
-- 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".')
end
-- Handle the no version case - check for a custom version_name
if self.versions == 0 then
insert_version_name(self.args_raw['version'] or 'DEFAULT')
self.versions = 1
end
-- Check for a default_version
if self.args_raw['default_version'] then
self.default_version = tonumber(self.args_raw['default_version'])
if self.default_version > self.versions then -- Make sure the default version exists
self.default_version = 1
end
end
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(...)
function Infobox:define_params(...)
-- For every parameter, store its corresponding function to self.params
for _, v in ipairs(...) do
for _, v in ipairs(...) do
-- For every parameter, store its corresponding function to self.params
if v.name then
if v.name then
local param = {}
local param = {}
Line 307: Line 87:
end
end
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
self.params[v.name] = param
table.insert(self.param_names, v.name)
table.insert(self.param_names, v.name)
end
end
end
end
self:parse_params()
--self:parse_categories()
return self
return self
end
end


--[[
Counts the number of versions in the infobox, and populates version_names
--]]
function Infobox:parse_versions()
-- Count the versions
local i = 1
while self.args_raw['version'..i] do
table.insert(self.version_names, self.args_raw['version'..i])
i = i + 1
end
self.versions = i - 1
-- Handle the no version case - might have a custom version_name
if self.versions == 0 then
table.insert(self.version_names, self.args_raw['version'] or 'DEFAULT')
end
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
if self.args_raw['default_version'] then
self.default_version = tonumber(self.args_raw['default_version'])
if self.default_version > self.versions then -- Make sure the default version exists
self.default_version = 1
end
end
end

-- Value is not defined if "action=edit" exists in string, otherwise
-- value is defined if not nil and non-empty string
function Infobox.is_value_defined(value)
if value == nil then
return false
end
if type(value) ~= 'string' then
return true
end
if value:find('action=edit') then
return false
end
if value:find('%S') then
return true
end
return false
end

--[[
Checks to see if a param is defined.
Returns 0 if param is never defined. Returns 1 if param is defined for some versions. Returns 2 if param is defined for all versions.
-- param: a table generated from Infobox:param(), Infobox:raw_param() or Infobox:smw_param()
]]
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 self.is_value_defined(value) then
defined = 1
else
undefined = 1
end
end
return 1 + defined - undefined
end


--[[
--[[
Fetches a param value. If the value is nil, will return the default value instead
Fetches a param value. If the value is nil, will return the default value instead
-- arg: a non-table value (string, number, etc), or Infobox.param(name), Infobox.raw_param(name), Infobox.smw_param(name)
-- arg: a table generated from Infobox:param(), Infobox:raw_param() or Infobox:smw_param(), or else
-- version: 0/'' for default, or else a number
-- version: '' 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)
function Infobox:get_param(arg, version)
Line 334: Line 169:
version = ''
version = ''
end
end
-- Handle Infobox.param(), Infobox.raw_param(), Infobox.smw_param()
if type(arg) == 'table' then
if type(arg) == 'table' then
local value = self[arg.property][arg.param_name..version]
local value = self[arg.property][arg.param_name..version]
-- If nil, grab default value (which could be nil as well)
if value == nil then -- Try to get default value if it exists
if value == nil then
value = self[arg.property][arg.param_name]
value = self[arg.property][arg.param_name]
end
end
return value
return value
end
end
-- Other (int, string)
-- Everything else passes through unmodified (string, number, etc)
return arg
return arg
end
end



--[[
--[[
Calculates the parsed value of a param
Calculates the parsed value of a param
-- param_name : param_name as a string
-- param_name : string, name of the param
-- version : 0/'' for default, or else a number
-- version : 0/'' for default, or else a number
-- smw : boolean, will use smw_func if true, or func is false
-- smw : boolean, whether to use the smw function or default function
--]]
--]]
function Infobox:parse_param(param_name, version, smw)
function Infobox:parse_param(param_name, version, smw)
Line 369: Line 201:
local func_params = func.params
local func_params = func.params
local func_fetched_params = {}
local func_fetched_params = {}
local i = 1
for _, func_param in ipairs(func_params) do
for _, func_param in ipairs(func_params) do
func_fetched_params[i] = self:get_param(func_param, version)
table.insert(func_fetched_params, self:get_param(func_param, version))
i = i + 1
end
end
return func_name(unpack(func_fetched_params))
return func_name(unpack(func_fetched_params))
Line 381: Line 211:




--[[
Parses all the param values (args_parsed and args_smw)
--]]
function Infobox:parse_params()
function Infobox:parse_params()
-- Calculate the param value for all params and all versions
-- Calculate the param value for all params and all versions
Line 389: Line 216:
for version=0, self.versions do
for version=0, self.versions do
if version == 0 then
if version == 0 then
version = ''
version = '' -- default version
end
end
-- get the parsed value
-- Only get the parsed value if the raw value is defined
self.args_parsed[param_name..version] = self:parse_param(param_name, version, false)
if self.args_raw[param_name..version] then
self.args_parsed[param_name..version] = self:parse_param(param_name, version, false)
-- Only get the smw value if smw_property is defined
if self.params[param_name].smw_property then
-- Only get the smw value if smw_property is defined
self.args_smw[param_name..version] = self:parse_param(param_name, version, true)
if self.params[param_name].smw_property then
self.args_smw[param_name..version] = self:parse_param(param_name, version, true)
end
end
end
end
end
Line 402: Line 231:




function Infobox:store_smw()
--[[
-- Abort if not in mainspace
Creates the table header
if mw.title.getCurrentTitle().namespace ~= 0 then
--]]
return false
function Infobox:table_header()
end
-- Create infobox table
-- Store a subobject for each version
self.rtable = mw.html.create('table')
for version=1, self.versions do
:addClass('plainlinks')
-- Reminder - subobject name cannot have a . in the first 5 characters
:addClass('infobox')
local subobject_name = 'Infobox.'..pagename..'#'..self.version_names[version]
:addClass('infobox-'..self.infobox_name)
local subobject = {}
for _, class in ipairs(self.classes) do
-- Store each param that has smw_property defined and has a defined value
local class_name = self:get_param(class, self.default_version)
for _, param_name in ipairs(self.param_names) do
if type(class_name) == 'string' then
local property = self.params[param_name].smw_property
self.rtable:addClass('infobox-'..mw.ustring.gsub(class_name, '%s', '_'))
if property then
value = self:get_param(self.smw_param(param_name), version)
if self.is_value_defined(value) then
subobject[property] = value
end
end
end
local result = mw.smw.subobject(subobject, subobject_name)
if result ~= true then
table.insert(self.errors, 'SMW error: '..result.error)
end
end
end
end
return true
-- 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')
end
return self
end
end


function Infobox.param(param_name)
param = {
property = 'args_parsed',
param_name = param_name,
}
return param
end


function Infobox.raw_param(param_name)
--[[
param = {
If multiple versions exist, creates a set of buttons for switching
property = 'args_raw',
-- self.max_buttons : if the number of versions exceeds this value, a dropdown will be created instead
param_name = param_name,
--]]
}
return param
end

function Infobox.smw_param(param_name)
param = {
property = 'args_smw',
param_name = param_name,
}
return param
end

-----------
-- Table --
-----------
function Infobox:buttons()
function Infobox:buttons()
if self.versions < 2 then
if self.versions < 2 then
return
return
end
end
-- Button caption
local buttons = self.rtable:tag('caption')
local buttons = self.rtable:tag('caption')
:tag('div')
:tag('div')
:addClass('infobox-buttons')
:addClass('infobox-buttons')
:attr('data-default-index', self.default_version)
:attr('data-default-version', self.default_version)
-- Dropdown list instead of buttons if too many versions
-- Dropdown list instead of buttons
if self.versions > self.max_buttons then
if self.versions > self.max_buttons then
buttons:addClass('infobox-buttons-select')
buttons:addClass('infobox-buttons-select')
end
end
-- Create all the buttons
for version=1, self.versions do
for version=1, self.versions do
local button = buttons:tag('span')
buttons:tag('span')
:attr('data-switch-index', version)
:attr('data-switch-index', version)
:attr('data-switch-anchor', '#'..self.version_names[version])
:attr('data-switch-anchor', '#'..self.version_names[version])
:addClass('button')
:addClass('button')
:wikitext(self.version_names[version])
:wikitext(self.version_names[version])
-- In case of dropdown list, hide the buttons as the switch gadget will convert them to a dropdown list - we can't directly create the dropdown list here as the select/option tags are rejected by wikitext
if self.versions > self.max_buttons then
button:addClass('hidden')
end
end
end
end
end


function Infobox:create()

-- Create infobox table
--[[
self.rtable = mw.html.create('table')
For each version, stores a subobject for all params that have smw_property defined
:addClass('plainlinks')
--]]
:addClass('infobox')
function Infobox:store_smw()
:addClass('infobox-'..self.infobox_name)
for version=1, self.versions do
-- Add necessary class if switch infobox
-- Generate a subobject name
if self.versions > 1 then
-- Reminder - subobject name cannot have a . in the first 5 characters
self.rtable:addClass('infobox-switch')
local subobject_name = self.version_names[version]
self.switch_datatable = mw.html.create('div')
-- Store each param that has smw_property defined and is not nil
:addClass('infobox-switch-resources')
local subobject = {Infobox = self.infobox_name} -- Also store the current Infobox name
:addClass('infobox-resources-'..self.infobox_name)
for _, param_name in ipairs(self.param_names) do
:addClass('hidden')
local property = self.params[param_name].smw_property
self.switch_datatable:tag('span'):wikitext('Versions: '..self.versions)
if property then
self.switch_datatable:tag('span'):wikitext('Default version: '..self.default_version)
local value = self:get_param(self.smw_param(param_name), version)
self:buttons()
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 = true
if self.versions == 1 then
result = mw.smw.set(subobject)
else
result = mw.smw.subobject(subobject, subobject_name)
end
if result ~= true then
table.insert(self.errors, 'SMW error: '..result.error)
end
end
end
end
return self
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)
function Infobox:add_switch_data(content)
-- Only check for params if there are multiple versions
if self.versions < 2 then
if self.versions <= 1 then
return false
return false
end
end
-- Only needed for non-constant params
if type(content) ~= 'table' then
if type(content) ~= 'table' then
return false
return false
end
end
-- Only needed if the param changes value between different versions
-- Only if the data varies between the different versions
local first_value = self:get_param(content, 1)
local first_value = self:get_param(cell_params.content, 1)
local all_same = true
local all_same = true
for version=2, self.versions do
for version=2, self.versions do
if first_value ~= self:get_param(content, version) then
if first_value ~= self:get_param(cell_params.content, version) then
all_same = false
all_same = false
break
break
Line 547: Line 350:
end
end
-- Let's build the datatable
-- Let's build the datatable
-- datum name: Prepend raw__ or smw__ if not a parsed argument
-- Prepend raw__ or smw$__ if not a parsed argument
local name = content.param_name
local name = content.param_name
if content.property == 'args_raw' then
if content.property == 'args_raw' then
Line 555: Line 358:
name = 'smw__' + name
name = 'smw__' + name
end
end
local data_param = self.switch_datatable:tag('span'):attr('data-attr-param', name)
data_param = self.switch_datatable:tag('span'):attr('data-attr-param', name)
-- Add each version to the datatable
-- Add each version to the datatable
for version=1, self.versions do
for version=1, self.versions do
local text = self:get_param(content, version)
text = self:get_param(content, version)
if text == nil then
if text == nil then
text = self.params[content.param_name].empty
text = edit
end
end
data_param:tag('span'):attr('data-attr-index', version):wikitext(text)
data_param:tag('span'):attr('data-attr-index', version):wikitext(text)
Line 567: Line 370:
return name
return name
end
end



--[[
--[[
Add parameters functions
Override tostring
All parameters should be tables
The first parameter defines the type of cell to create
-- tag = 'th' or 'td'
The second parameter defines what is inside the tag
-- content = string or Infobox.param
Additional named parameters can be used to add any styling or attributes
-- attr : mw.html:attr({ arg1 = '1', ... })
-- css : mw.html:css({ arg1 = '1', ...)
-- class : mw.html:addClass('arg') (common class: infobox-subheader)
---- class also supports a table of values, even though mw.html:addClass() does not
-- rowspan : mw.html:attr('rowspan',arg)
-- colspan : mw.html:attr('colspan',arg)
-- title : mw.html:attr('title',arg)
Example:
ipsobox:addRow( { 'th' , 'Header', title = 'Title' },
{ 'argh', 'arg1', class = 'parameter' } })
produces:
<tr><th title="Title">Header</th><th class="parameter">args.arg1</th></tr>

adding it to the infobox table of ipsobox

Cells defined as 'argh' and 'argd' will automatically have data-attr-param="" added, and defined as the passed argument if the infobox in creation is defined as a switch infobox

The row itself may be modified with metadata using the named index "addClass'
-- addClass : mw.html:addClass('arg')
-- this function currently only supports a single string
--]]
--]]
function Infobox:__tostring()
function Infobox:add_row(...)
-- Create error messages
-- New row to add
local error_text = ''
local args = ...
for _, v in ipairs(self.errors) do
local _row = self.rtable:tag('tr')
-- For each member of tags
error_text = error_text..'<span class="mw-message-box-error">'..v..'</span>'
for _, v in ipairs(args) do
end
local _cell = _row:tag(v.tag)
-- Create categories

local category_text = ''
-- mw.html:attr() and mw.html:css() both accept table input
if mw.title.getCurrentTitle():inNamespace(0) then
-- colspan, rowspan, title will be quick ways to access attr
for key, _ in pairs(self.categories) do
-- these functions also do all the necessary work
category_text = category_text..'[[Category:'..key..']]'
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 class is a string, it can be added directly
-- if a table, add every value
-- mw.html:addClass() doesn't function with tables
-- so iterate over the class names here and add them individually
if v.class then
if type(v.class) == 'string' then
_cell:addClass(v.class)
elseif type(v.class) == 'table' then
for _, w in ipairs(v.class) do
_cell:addClass(w)
end
end
end

local content = Infobox:get_param(v.content, self.default_version)
if content == nil then
content = edit
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
end
end

local dump = ''
-- allow classes to be defined on the whole row
if self.args_raw.__dump then
if args.addClass then
setmetatable(self, nil)
_row:addClass(args.addClass)
dump = '<nowiki>'..mw.dumpObject(self)..'</nowiki>'
setmetatable(self, Infobox)
end
end

return tostring(self.rtable) .. tostring(self.switch_datatable) .. error_text .. category_text .. dump
return self
end
end




--[[
--[[
-- adds a blank row of padding spanning the given number of columns
Debug function
--]]
--]]
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

-- addClass
function Infobox:addClass(arg)
self.rtable:addClass(arg)
return self
end

-- Override tostring
function Infobox:tostring()
error_text = ''
if #self.errors > 0 then
for _, v in ipairs(self.errors) do
error_text = error_text..'<span class="mw-message-box-error">'..v..'</span>'
end
end
return tostring(self.rtable) .. tostring(self.switch_datatable) .. tostring(error_text)
end



function Infobox:dump()
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))
mw.log(mw.dumpObject(self))
setmetatable(self, Infobox)
mw.log(tostring(self))
mw.log(tostring(self))
end
end



return Infobox
return Infobox
Please note that all contributions to Brighter Shores Wiki are considered to be released under the CC BY-NC-SA 3.0 (see Brighter Shores:Copyrights for details). If you do not want your writing to be edited mercilessly and redistributed at will, then do not submit it here.
You are also promising us that you wrote this yourself, or copied it from a public domain or similar free resource. Do not submit copyrighted work without permission!
Cancel Editing help (opens in new window)
Preview page with this template

Templates used on this page:

This page is a member of a hidden category:

Retrieved from ‘https://brightershoreswiki.org/w/Module:Infobox’