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 Infobox = {}
local Infobox = {}
Line 13: Line 13:
--[[
--[[
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(infobox_name, args)
local obj = setmetatable({
local obj = setmetatable({
args_raw = args, -- parameters (uncleaned)
args_raw = args, -- parameters (uncleaned)
Line 24: Line 25:
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
default_version = 1, -- default version to populate the infobox
max_buttons = 6, -- If there are more buttons than the max, the buttons will become a dropdown menu
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 = {}, -- title of each version (for selection and SMW)
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)
obj.infobox_name = mw.ustring.gsub(infobox_name, '%s', '_')
-- Step 1, setup config vars and count the versions
obj:config(config)
obj:parse_versions()
obj:parse_versions()
obj:create()
-- 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
return obj
end
end
Line 55: Line 43:


--[[
--[[
Function for defining parameters
Refers to a param after being processed by the validating func
-- name : parameter name
Used in add_row(), define_params() and is_param_defined()
-- func : function to define param, defaults to looking at blanks
DO NOT DEFINE VERSION HERE
USE :maxVersion()
Can be used any number of times for efficient definition
--]]
--]]
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
self.infobox_name = mw.ustring.gsub(v, '%s', '_')
elseif k == 'max_buttons' then
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
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()
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 69:
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()
return self
return self
end
end



--[[
--[[
Counts the number of versions in the infobox, and populates version_names
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)
-- 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)
function Infobox:parse_versions()
-- Count the versions
if version == 0 then
version = ''
local i = 1
while self.args_raw['version'..i] do
table.insert(self.version_names, self.args_raw['version'..i])
i = i + 1
end
end
self.versions = i - 1
-- Handle Infobox.param(), Infobox.raw_param(), Infobox.smw_param()
-- Handle the no version case - might have a custom version_name
if type(arg) == 'table' then
if self.versions == 0 then
local value = self[arg.property][arg.param_name..version]
table.insert(self.version_names, self.args_raw['version'] or 'DEFAULT')
-- If nil, grab default value (which could be nil as well)
if value == nil then
value = self[arg.property][arg.param_name]
end
return value
end
end
if self.versions == 1 then
-- Everything else passes through unmodified (string, number, etc)
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".')
return arg
self.versions = 0
end
if self.args_raw['default_version'] then
self.default_version = tonumber(self.args_raw['default_version'])
end
end
end



--[[
Fetches a param value. If the value is nil, will return the default value instead
-- arg: a table generated from Infobox:param(), Infobox:raw_param() or Infobox:smw_param(), or else
-- version: '' for default, or else a number
--]]
function Infobox:get_param(arg, version)
if version == 0 then
version = ''
end
if type(arg) == 'table' then
local value = self[arg.property][arg.param_name..version]
if value == nil then -- Try to get default value if it exists
value = self[arg.property][arg.param_name]
end
return value
end
-- Other (int, string)
return arg
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)
if version == 0 then
if version == 0 then
version = ''
version = ''
end
end
-- use func or smw_func depending on smw argument
-- use func or smw_func depending on smw argument
local param = self.params[param_name]
local param = self.params[param_name]
local func = smw and param.smw_func or param.func
local func = smw and param.smw_func or param.func
-- call functions by passing the param_name
-- call functions by passing the param_name
if type(func) == 'function' then
if type(func) == 'function' then
return func(self:get_param(self.raw_param(param_name), version))
return func(self:get_param(self.raw_param(param_name), version))
-- call tables by grabbing the function and reading the param arguments
-- call tables by grabbing the function and reading the param arguments
elseif type(func) == 'table' then
elseif type(func) == 'table' then
local func_name = func.name
local func_name = func.name
local func_params = func.params
local func_params = func.params
local func_fetched_params = {}
local func_fetched_params = {}
for _, func_param in ipairs(func_params) do
local i = 1
table.insert(func_fetched_params, self:get_param(func_param, version))
for _, func_param in ipairs(func_params) do
end
func_fetched_params[i] = self:get_param(func_param, version)
return func_name(unpack(func_fetched_params))
i = i + 1
else
end
table.insert(self.errors, 'Invalid param definition for '..param_name)
return func_name(unpack(func_fetched_params))
end
else
table.insert(self.errors, 'Invalid param definition for '..param_name)
end
end
end




--[[
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
for _, param_name in ipairs(self.param_names) do
for _, param_name in ipairs(self.param_names) do
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
if self.params[param_name].smw_property then
self.args_smw[param_name..version] = self:parse_param(param_name, version, true)
self.args_smw[param_name..version] = self:parse_param(param_name, version, true)
end
end
end
end
end
end
end
end
end




function Infobox.param(param_name)
--[[
param = {
Creates the table header
property = 'args_parsed',
--]]
param_name = param_name,
function Infobox:table_header()
}
return param
end

function Infobox.raw_param(param_name)
param = {
property = 'args_raw',
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:create()
-- Create infobox table
-- Create infobox table
self.rtable = mw.html.create('table')
self.rtable = mw.html.create('table')
:addClass('plainlinks')
:addClass('plainlinks')
:addClass('infobox')
:addClass('infobox')
:addClass('infobox-'..self.infobox_name)
:addClass('infobox-'..self.infobox_name)
-- Add necessary class if switch infobox
for _, class in ipairs(self.classes) do
local class_name = self:get_param(class, self.default_version)
if type(class_name) == 'string' then
self.rtable:addClass('infobox-'..mw.ustring.gsub(class_name, '%s', '_'))
end
end
-- Create the switch datatable if multiple versions
if self.versions > 1 then
if self.versions > 1 then
self.rtable:addClass('infobox-switch')
self.rtable:addClass('infobox-switch')
self.switch_datatable = mw.html.create('div')
self.switch_datatable = mw.html.create('div')
:addClass('infobox-switch-resources')
:addClass('infobox-switch-resources')
:addClass('infobox-resources-'..self.infobox_name)
:addClass('infobox-resources-'..self.infobox_name)
:addClass('hidden')
:addClass('hidden')
self.switch_datatable:tag('span'):wikitext('Versions: '..self.versions)
self.switch_datatable:tag('span'):wikitext('Default version: '..self.default_version)
end
end
return self
return self
end
end



--[[
--[[
Add parameters functions
If multiple versions exist, creates a set of buttons for switching
All parameters should be tables
-- self.max_buttons : if the number of versions exceeds this value, a dropdown will be created instead
The first parameter defines the type of cell to create
--]]
-- tag = 'th' or 'td'
function Infobox:buttons()
The second parameter defines what is inside the tag
if self.versions < 2 then
-- content = string or Infobox.param
return
Additional named parameters can be used to add any styling or attributes
end
-- attr : mw.html:attr({ arg1 = '1', ... })
-- Button caption
-- css : mw.html:css({ arg1 = '1', ...)
local buttons = self.rtable:tag('caption')
-- class : mw.html:addClass('arg')
:tag('div')
---- class also supports a table of values, even though mw.html:addClass() does not
:addClass('infobox-buttons')
-- rowspan : mw.html:attr('rowspan',arg)
:attr('data-default-index', self.default_version)
-- colspan : mw.html:attr('colspan',arg)
-- Dropdown list instead of buttons if too many versions
-- title : mw.html:attr('title',arg)
if self.versions > self.max_buttons then
Example:
buttons:addClass('infobox-buttons-select')
ipsobox:addRow( { 'th' , 'Header', title = 'Title' },
end
{ 'argh', 'arg1', class = 'parameter' } })
-- Create all the buttons
produces:
for version=1, self.versions do
<tr><th title="Title">Header</th><th class="parameter">args.arg1</th></tr>
local button = buttons:tag('span')
:attr('data-switch-index', version)
:attr('data-switch-anchor', '#'..self.version_names[version])
:addClass('button')
: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


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
--[[

For each version, stores a subobject for all params that have smw_property defined
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:store_smw()
function Infobox:add_switch_data(content)
for version=1, self.versions do
-- Only check for params if there are multiple versions
-- Generate a subobject name
if self.versions <= 1 then
-- Reminder - subobject name cannot have a . in the first 5 characters
return false
local subobject_name = self.version_names[version]
end
-- Store each param that has smw_property defined and is not nil
if type(content) ~= 'table' then
local subobject = {Infobox = self.infobox_name} -- Also store the current Infobox name
return false
for _, param_name in ipairs(self.param_names) do
end
local property = self.params[param_name].smw_property
-- Only if the data varies between the different versions
if property then
local value = self:get_param(self.smw_param(param_name), version)
local first_value = self:get_param(cell_params.content, 1)
local all_same = true
if value ~= nil then
for version=2, self.versions do
subobject[property] = value
if first_value ~= self:get_param(cell_params.content, version) then
end
all_same = false
end
break
end
end
-- Keep a copy for debugging
end
self.__smw_debug[subobject_name] = subobject
if all_same then
-- Save subobjects if not in mainspace
return false
if mw.title.getCurrentTitle():inNamespace(0) then
end
local result = true
-- Let's build the datatable
if self.versions == 1 then
-- Prepend raw__ or smw$<__ if not a parsed argument
result = mw.smw.set(subobject)
local name = content.param_name
else
if content.property == 'args_raw' then
result = mw.smw.subobject(subobject, subobject_name)
name = 'raw__' + name
end
end
if result ~= true then
if content.property == 'args_smw' then
table.insert(self.errors, 'SMW error: '..result.error)
name = 'smw__' + name
end
end
end
data_param = self.switch_datatable:tag('span'):attr('data-attr-param', name)
end
-- Add each version to the datatable
for version=1, self.versions do
text = self:get_param(content, version)
if text == nil then
text = edit
end
data_param:tag('span'):attr('data-attr-index', version):wikitext(text)
end
-- return the 'data-attr-param' name
return name
end
end


function Infobox:add_row(...)
-- New row to add
local args = ...
local _row = self.rtable:tag('tr')
-- For each member of tags
for _, v in ipairs(args) do
local _cell = _row:tag(v.tag)


-- mw.html:attr() and mw.html:css() both accept table input
--[[
-- colspan, rowspan, title will be quick ways to access attr
Automatically add categories for each param as defined in define_params()
-- these functions also do all the necessary work
--]]
if v.attr then
function Infobox:parse_categories()
_cell:attr(v.attr)
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
end
if defined == 1 and param.category_partial then
if v.colspan then
_cell:attr('colspan',v.colspan)
self.categories[param.category_partial] = 1
end
end
if defined < 2 and param.category_incomplete then
if v.rowspan then
_cell:attr('rowspan',v.rowspan)
self.categories[param.category_incomplete] = 1
end
end
if defined == 2 and param.category_complete then
if v.title then
_cell:attr('title',v.title)
self.categories[param.category_complete] = 1
end
if v.css then
_cell:css(v.css)
end
end
end
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
When a parameter is added into the table, add the alternative versions' data into the switch datatable
-- so iterate over the class names here and add them individually
-- content : a non-table value (string, number, etc), or Infobox.param(name), Infobox.raw_param(name), Infobox.smw_param(name)
if v.class then
Returns the name of the parameter in the tag 'data-attr-param'
if type(v.class) == 'string' then
--]]
_cell:addClass(v.class)
function Infobox:add_switch_data(content)
if self.versions < 2 then
elseif type(v.class) == 'table' then
for _, w in ipairs(v.class) do
return false
_cell:addClass(w)
end
end
-- Only needed for non-constant params
end
if type(content) ~= 'table' then
return false
end
-- Only needed if the param changes value between different versions
local first_value = self:get_param(content, 1)
local all_same = true
for version=2, self.versions do
if first_value ~= self:get_param(content, version) then
all_same = false
break
end
end
end
if all_same then
return false
end
-- Let's build the datatable
-- datum name: Prepend raw__ or smw__ if not a parsed argument
local name = content.param_name
if content.property == 'args_raw' then
name = 'raw__' + name
end
if content.property == 'args_smw' then
name = 'smw__' + name
end
local data_param = self.switch_datatable:tag('span'):attr('data-attr-param', name)
-- Add each version to the datatable
for version=1, self.versions do
local text = self:get_param(content, version)
if text == nil then
text = self.params[content.param_name].empty
end
data_param:tag('span'):attr('data-attr-index', version):wikitext(text)
end
-- return the 'data-attr-param' name
return name
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)
Override tostring
if data_attr_param then
--]]
_cell:attr('data-attr-param', data_attr_param)
function Infobox:__tostring()
end
-- Create error messages
local error_text = ''
for _, v in ipairs(self.errors) do
error_text = error_text..'<span class="mw-message-box-error">'..v..'</span>'
end
end

-- Create categories
-- allow classes to be defined on the whole row
local category_text = ''
if args.addClass then
if mw.title.getCurrentTitle():inNamespace(0) then
_row:addClass(args.addClass)
for key, _ in pairs(self.categories) do
category_text = category_text..'[[Category:'..key..']]'
end
end
local dump = ''
if self.args_raw.__dump then
setmetatable(self, nil)
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

-- 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





--[[
Debug function
--]]
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’