Editing Module:Message box

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 1: Line 1:
require('Module:No globals')
-- This is a meta-module for producing message box templates, including {{mbox}}, {{ambox}}, {{imbox}}, {{tmbox}}, {{ombox}}, {{cmbox}} and {{fmbox}}.
local getArgs
 
-- Require necessary modules.
local htmlBuilder = require('Module:HtmlBuilder')
local categoryHandler = require('Module:Category handler').main
local yesno = require('Module:Yesno')
local yesno = require('Module:Yesno')
-- Get a language object for formatDate and ucfirst.
local lang = mw.language.getContentLanguage()
local lang = mw.language.getContentLanguage()


local CONFIG_MODULE = 'Module:Message box/configuration'
-- Set aliases for often-used functions to reduce table lookups.
local DEMOSPACES = {talk = 'tmbox', image = 'imbox', file = 'imbox', category = 'cmbox', article = 'ambox', main = 'ambox'}
local format = mw.ustring.format
local tinsert = table.insert
local tconcat = table.concat


--------------------------------------------------------------------------------
local p = {}
-- Helper functions
--------------------------------------------------------------------------------


local function getTitleObject(...)
local function getTitleObject(page)
-- Get the title object, passing the function through pcall
    if type(page) == 'string' then
-- in case we are over the expensive function count limit.
        -- Get the title object, passing the function through pcall  
local success, title = pcall(mw.title.new, ...)
        -- in case we are over the expensive function count limit.
if success then
        local success, title = pcall(mw.title.new, page)
return title
        if success then
end
            return title
        end
    end
end
end


local function union(t1, t2)
local function presentButBlank(s)
-- Returns the union of two arrays.
    if type(s) ~= 'string' then return end
local vals = {}
    if s and not mw.ustring.find(s, '%S') then
for i, v in ipairs(t1) do
        return true
vals[v] = true
    else
end
        return false
for i, v in ipairs(t2) do
    end
vals[v] = true
end
local ret = {}
for k in pairs(vals) do
table.insert(ret, k)
end
table.sort(ret)
return ret
end
end


local function getArgNums(args, prefix)
local function formatCategory(cat, date, all)
local nums = {}
    local ret = {}
for k, v in pairs(args) do
    cat = type(cat) == 'string' and cat
local num = mw.ustring.match(tostring(k), '^' .. prefix .. '([1-9]%d*)$')
    date = type(date) == 'string' and date
if num then
    all = type(all) == 'string' and all
table.insert(nums, tonumber(num))
    local preposition = 'from'
end
    if cat and date then
end
        local catTitle = format('Category:%s %s %s', cat, preposition, date)
table.sort(nums)
        tinsert(ret, format('[[%s]]', catTitle))
return nums
        catTitle = getTitleObject(catTitle)
        if not catTitle or not catTitle.exists then
            tinsert(ret, '[[Category:Articles with invalid date parameter in template]]')
        end
    elseif cat and not date then
        tinsert(ret, format('[[Category:%s]]', cat))
    end
    if all then
        tinsert(ret, format('[[Category:%s]]', all))
    end
    return tconcat(ret)
end
end


--------------------------------------------------------------------------------
local function union(t1, t2)
-- Box class definition
    -- Returns the union of two arrays.
--------------------------------------------------------------------------------
    local vals = {}
 
    for i, v in ipairs(t1) do
local MessageBox = {}
        vals[v] = true
MessageBox.__index = MessageBox
    end
 
    for i, v in ipairs(t2) do
function MessageBox.new(boxType, args, cfg)
        vals[v] = true
args = args or {}
    end
local obj = {}
    local ret = {}
 
    for k in pairs(vals) do
-- Set the title object and the namespace.
        tinsert(ret, k)
obj.title = getTitleObject(args.page) or mw.title.getCurrentTitle()
    end
 
    table.sort(ret)
-- Set the config for our box type.
    return ret
obj.cfg = cfg[boxType]
if not obj.cfg then
local ns = obj.title.namespace
-- boxType is "mbox" or invalid input
if args.demospace and args.demospace ~= '' then
-- implement demospace parameter of mbox
local demospace = string.lower(args.demospace)
if DEMOSPACES[demospace] then
-- use template from DEMOSPACES
obj.cfg = cfg[DEMOSPACES[demospace]]
elseif string.find( demospace, 'talk' ) then
-- demo as a talk page
obj.cfg = cfg.tmbox
else
-- default to ombox
obj.cfg = cfg.ombox
end
elseif ns == 0 then
obj.cfg = cfg.ambox -- main namespace
elseif ns == 6 then
obj.cfg = cfg.imbox -- file namespace
elseif ns == 14 then
obj.cfg = cfg.cmbox -- category namespace
else
local nsTable = mw.site.namespaces[ns]
if nsTable and nsTable.isTalk then
obj.cfg = cfg.tmbox -- any talk namespace
else
obj.cfg = cfg.ombox -- other namespaces or invalid input
end
end
end
 
-- Set the arguments, and remove all blank arguments except for the ones
-- listed in cfg.allowBlankParams.
do
local newArgs = {}
for k, v in pairs(args) do
if v ~= '' then
newArgs[k] = v
end
end
for i, param in ipairs(obj.cfg.allowBlankParams or {}) do
newArgs[param] = args[param]
end
obj.args = newArgs
end
 
-- Define internal data structure.
obj.categories = {}
obj.classes = {}
-- For lazy loading of [[Module:Category handler]].
obj.hasCategories = false
 
return setmetatable(obj, MessageBox)
end
end


function MessageBox:addCat(ns, cat, sort)
local function getArgNums(args, prefix)
if not cat then
    local nums = {}
return nil
    for k, v in pairs(args) do
end
        local num = mw.ustring.match(tostring(k), '^' .. prefix .. '([1-9]%d*)$')
if sort then
        if num then
cat = string.format('[[Category:%s|%s]]', cat, sort)
            tinsert(nums, tonumber(num))
else
        end
cat = string.format('[[Category:%s]]', cat)
    end
end
    table.sort(nums)
self.hasCategories = true
    return nums
self.categories[ns] = self.categories[ns] or {}
table.insert(self.categories[ns], cat)
end
end


function MessageBox:addClass(class)
local function getNamespaceId(ns)
if not class then
    if type(ns) == 'string' then
return nil
        ns = lang:ucfirst(mw.ustring.lower(ns))
end
        if ns == 'Main' then
table.insert(self.classes, class)
            ns = 0
        end
    end
    local nsTable = mw.site.namespaces[ns]
    if nsTable then
        return nsTable.id
    end
end
end


function MessageBox:setParameters()
local function getMboxType(nsid)
local args = self.args
    -- Gets the mbox type from a namespace number.
local cfg = self.cfg
    if nsid == 0 then
 
        return 'ambox' -- main namespace
-- Get type data.
    elseif nsid == 6 then
self.type = args.type
        return 'imbox' -- file namespace
local typeData = cfg.types[self.type]
    elseif nsid == 14 then
self.invalidTypeError = cfg.showInvalidTypeError
        return 'cmbox' -- category namespace
and self.type
    else
and not typeData
        local nsTable = mw.site.namespaces[nsid]
typeData = typeData or cfg.types[cfg.default]
        if nsTable and nsTable.isTalk then
self.typeClass = typeData.class
            return 'tmbox' -- any talk namespace
self.typeImage = typeData.image
        else
 
            return 'ombox' -- other namespaces or invalid input
-- Find if the box has been wrongly substituted.
        end
self.isSubstituted = cfg.substCheck and args.subst == 'SUBST'
    end
 
-- Find whether we are using a small message box.
self.isSmall = cfg.allowSmall and (
cfg.smallParam and args.small == cfg.smallParam
or not cfg.smallParam and yesno(args.small)
)
 
-- Add attributes, classes and styles.
self.id = args.id
self.name = args.name
if self.name then
self:addClass('box-' .. string.gsub(self.name,' ','_'))
end
if yesno(args.plainlinks) ~= false then
self:addClass('plainlinks')
end
for _, class in ipairs(cfg.classes or {}) do
self:addClass(class)
end
if self.isSmall then
self:addClass(cfg.smallClass or 'mbox-small')
end
self:addClass(self.typeClass)
self:addClass(args.class)
self.style = args.style
self.attrs = args.attrs
 
-- Set text style.
self.textstyle = args.textstyle
 
-- Find if we are on the template page or not. This functionality is only
-- used if useCollapsibleTextFields is set, or if both cfg.templateCategory
-- and cfg.templateCategoryRequireName are set.
self.useCollapsibleTextFields = cfg.useCollapsibleTextFields
if self.useCollapsibleTextFields
or cfg.templateCategory
and cfg.templateCategoryRequireName
then
if self.name then
local templateName = mw.ustring.match(
self.name,
'^[tT][eE][mM][pP][lL][aA][tT][eE][%s_]*:[%s_]*(.*)$'
) or self.name
templateName = 'Template:' .. templateName
self.templateTitle = getTitleObject(templateName)
end
self.isTemplatePage = self.templateTitle
and mw.title.equals(self.title, self.templateTitle)
end
-- Process data for collapsible text fields. At the moment these are only
-- used in {{ambox}}.
if self.useCollapsibleTextFields then
-- Get the self.issue value.
if self.isSmall and args.smalltext then
self.issue = args.smalltext
else
local sect
if args.sect == '' then
sect = 'This ' .. (cfg.sectionDefault or 'page')
elseif type(args.sect) == 'string' then
sect = 'This ' .. args.sect
end
local issue = args.issue
issue = type(issue) == 'string' and issue ~= '' and issue or nil
local text = args.text
text = type(text) == 'string' and text or nil
local issues = {}
table.insert(issues, sect)
table.insert(issues, issue)
table.insert(issues, text)
self.issue = table.concat(issues, ' ')
end
 
-- Get the self.talk value.
local talk = args.talk
-- Show talk links on the template page or template subpages if the talk
-- parameter is blank.
if talk == ''
and self.templateTitle
and (
mw.title.equals(self.templateTitle, self.title)
or self.title:isSubpageOf(self.templateTitle)
)
then
talk = '#'
elseif talk == '' then
talk = nil
end
if talk then
-- If the talk value is a talk page, make a link to that page. Else
-- assume that it's a section heading, and make a link to the talk
-- page of the current page with that section heading.
local talkTitle = getTitleObject(talk)
local talkArgIsTalkPage = true
if not talkTitle or not talkTitle.isTalkPage then
talkArgIsTalkPage = false
talkTitle = getTitleObject(
self.title.text,
mw.site.namespaces[self.title.namespace].talk.id
)
end
if talkTitle and talkTitle.exists then
                local talkText
                if self.isSmall then
                    local talkLink = talkArgIsTalkPage and talk or (talkTitle.prefixedText .. '#' .. talk)
                    talkText = string.format('([[%s|talk]])', talkLink)
                else
                    talkText = 'Relevant discussion may be found on'
                    if talkArgIsTalkPage then
                        talkText = string.format(
                            '%s [[%s|%s]].',
                            talkText,
                            talk,
                            talkTitle.prefixedText
                        )
                    else
                        talkText = string.format(
                            '%s the [[%s#%s|talk page]].',
                            talkText,
                            talkTitle.prefixedText,
                            talk
                        )
                    end
                end
self.talk = talkText
end
end
 
-- Get other values.
self.fix = args.fix ~= '' and args.fix or nil
local date
if args.date and args.date ~= '' then
date = args.date
elseif args.date == '' and self.isTemplatePage then
date = lang:formatDate('F Y')
end
if date then
self.date = string.format(" <span class='date-container'><i>(<span class='date'>%s</span>)</i></span>", date)
end
self.info = args.info
if yesno(args.removalnotice) then
self.removalNotice = cfg.removalNotice
end
end
 
-- Set the non-collapsible text field. At the moment this is used by all box
-- types other than ambox, and also by ambox when small=yes.
if self.isSmall then
self.text = args.smalltext or args.text
else
self.text = args.text
end
 
-- Set the below row.
self.below = cfg.below and args.below
 
-- General image settings.
self.imageCellDiv = not self.isSmall and cfg.imageCellDiv
self.imageEmptyCell = cfg.imageEmptyCell
 
-- Left image settings.
local imageLeft = self.isSmall and args.smallimage or args.image
if cfg.imageCheckBlank and imageLeft ~= 'blank' and imageLeft ~= 'none'
or not cfg.imageCheckBlank and imageLeft ~= 'none'
then
self.imageLeft = imageLeft
if not imageLeft then
local imageSize = self.isSmall
and (cfg.imageSmallSize or '30x30px')
or '40x40px'
self.imageLeft = string.format('[[File:%s|%s|link=|alt=]]', self.typeImage
or 'Imbox notice.png', imageSize)
end
end
 
-- Right image settings.
local imageRight = self.isSmall and args.smallimageright or args.imageright
if not (cfg.imageRightNone and imageRight == 'none') then
self.imageRight = imageRight
end
-- set templatestyles
self.base_templatestyles = cfg.templatestyles
self.templatestyles = args.templatestyles
end
end


function MessageBox:setMainspaceCategories()
function p.build(boxType, args)
local args = self.args
    if type(args) ~= 'table' then
local cfg = self.cfg
        error(format('invalid "args" parameter type; expected type "table", got type "%s"', type(args)), 2)
    end


if not cfg.allowMainspaceCategories then
    -- Get the title object and the namespace.
return nil
    local title = getTitleObject(args.page) or mw.title.getCurrentTitle()
end
    local nsid = getNamespaceId(args.demospace) or title.namespace


local nums = {}
    -- Get the box config data from the data page.
for _, prefix in ipairs{'cat', 'category', 'all'} do
    if boxType == 'mbox' then
args[prefix .. '1'] = args[prefix]
        boxType = getMboxType(nsid)
nums = union(nums, getArgNums(args, prefix))
    end
end
    local dataTables = mw.loadData('Module:Message box/data')
    local data = dataTables[boxType]
    if not data then
        local boxTypes = {}
        for k, v in pairs(dataTables) do
            tinsert(boxTypes, format('"%s"', k))
        end
        tinsert(boxTypes, '"mbox"')
        error(format('invalid message box type "%s"; valid types are %s', tostring(boxType), mw.text.listToText(boxTypes)), 2)
    end


-- The following is roughly equivalent to the old {{Ambox/category}}.
    ------------------------ Process config data ----------------------------
local date = args.date
date = type(date) == 'string' and date
local preposition = 'from'
for _, num in ipairs(nums) do
local mainCat = args['cat' .. tostring(num)]
or args['category' .. tostring(num)]
local allCat = args['all' .. tostring(num)]
mainCat = type(mainCat) == 'string' and mainCat
allCat = type(allCat) == 'string' and allCat
if mainCat and date and date ~= '' then
local catTitle = string.format('%s %s %s', mainCat, preposition, date)
self:addCat(0, catTitle)
catTitle = getTitleObject('Category:' .. catTitle)
if not catTitle or not catTitle.exists then
self:addCat(0, 'Articles with invalid date parameter in template')
end
elseif mainCat and (not date or date == '') then
self:addCat(0, mainCat)
end
if allCat then
self:addCat(0, allCat)
end
end
end


function MessageBox:setTemplateCategories()
    -- Type data.
local args = self.args
    local typeData = data.types[args.type]
local cfg = self.cfg
    local invalidType = args.type and not typeData and true or false
    typeData = typeData or data.types[data.default]


-- Add template categories.
    -- Process data for collapsible text fields
if cfg.templateCategory then
    local name, issue, talk, fix, date, info
if cfg.templateCategoryRequireName then
    if data.useCollapsibleTextFields then
if self.isTemplatePage then
        name = args.name
self:addCat(10, cfg.templateCategory)
        local nameTitle = getTitleObject(name)
end
        local isTemplatePage = nameTitle and title.prefixedText == ('Template:' .. nameTitle.text) and true or false
elseif not self.title.isSubpage then
        local sect = args.sect
self:addCat(10, cfg.templateCategory)
        if presentButBlank(sect) then
end
            sect = format('This %s ', data.sectionDefault or 'page')
end
        elseif type(sect) == 'string' then
            sect = 'This ' .. sect .. ' '
        end
        issue = (sect or '') .. (args.issue or '') .. ' ' .. (args.text or '')
        talk = args.talk
        if presentButBlank(talk) and isTemplatePage then
            talk = '#'
        end
        fix = args.fix
        date = args.date
        if presentButBlank(date) and isTemplatePage then
            date = lang:formatDate('F Y')
        end
        info = args.info
    end


-- Add template error categories.
    -- Process the talk link, if present.
if cfg.templateErrorCategory then
    if talk then
local templateErrorCategory = cfg.templateErrorCategory
        -- See if the talk link exists and is for a talk or a content namespace.
local templateCat, templateSort
        local talkTitle = type(talk) == 'string' and getTitleObject(talk)
if not self.name and not self.title.isSubpage then
        if not talkTitle or not talkTitle.isTalkPage then
templateCat = templateErrorCategory
            -- If we couldn't process the talk page link, get the talk page of the current page.
elseif self.isTemplatePage then
            local success
local paramsToCheck = cfg.templateErrorParamsToCheck or {}
            success, talkTitle = pcall(title.talkPageTitle, title)
local count = 0
            if not success then
for i, param in ipairs(paramsToCheck) do
                talkTitle = nil
if not args[param] then
            end
count = count + 1
        end
end
        if talkTitle and talkTitle.exists then
end
            local talkText = ' Relevant discussion may be found on'
if count > 0 then
            if talkTitle.isTalkPage then
templateCat = templateErrorCategory
                talkText = format('%s [[%s|%s]].', talkText, talk, talkTitle.prefixedText)
templateSort = tostring(count)
            else
end
                talkText = format('%s the [[%s#%s|talk page]].', talkText, talkTitle.prefixedText, talk)
if self.categoryNums and #self.categoryNums > 0 then
            end
templateCat = templateErrorCategory
            talk = talkText
templateSort = 'C'
        end
end
    end
end
self:addCat(10, templateCat, templateSort)
end
end


function MessageBox:setAllNamespaceCategories()
    -- Find whether we are using a small message box and process our data accordingly.
-- Set categories for all namespaces.
    local isSmall = data.allowSmall and (args.small == 'yes' or args.small == true) and true or false
if self.invalidTypeError then
    local smallClass, image, imageRight, text, imageSize
local allSort = (self.title.namespace == 0 and 'Main:' or '') .. self.title.prefixedText
    if isSmall then
self:addCat('all', 'Wikipedia message box parameter needs fixing', allSort)
        smallClass = data.smallClass or 'mbox-small'
end
        image = args.smallimage or args.image
if self.isSubstituted then
        imageRight = args.smallimageright or args.imageright
self:addCat('all', 'Pages with incorrectly substituted templates')
        if data.useCollapsibleTextFields then
end
            text = args.smalltext or issue
end
        else
            text = args.smalltext or args.text
        end
        imageSize = data.imageSmallSize or '30x30px'
    else
        image = args.image
        imageRight = args.imageright
        imageSize = '40x40px'
        text = args.text
    end


function MessageBox:setCategories()
    -- Process mainspace categories.
if self.title.namespace == 0 then
    local mainCats = {}
self:setMainspaceCategories()
    local origCategoryNums -- origCategoryNums might be used in computing the template error category.
elseif self.title.namespace == 10 then
    if data.allowMainspaceCategories then
self:setTemplateCategories()
        -- Categories for the main namespace.
end
        local origCatNums = getArgNums(args, 'cat')
self:setAllNamespaceCategories()
        local origCategoryNums = getArgNums(args, 'category')
end
        local catNums = union(origCatNums, origCategoryNums)
        for _, num in ipairs(catNums) do
            local cat = args['cat' .. tostring(num)] or args['category' .. tostring(num)]
            local all = args['all' .. tostring(num)]
            tinsert(mainCats, formatCategory(cat, args.date, all))
        end
    end


function MessageBox:renderCategories()
    -- Process template namespace categories
if not self.hasCategories then
    local templateCats = {}
-- No categories added, no need to pass them to Category handler so,
    if data.templateCategory and not title.isSubpage and not yesno(args.nocat) then
-- if it was invoked, it would return the empty string.
        tinsert(templateCats, format('[[Category:%s]]', data.templateCategory))
-- So we shortcut and return the empty string.
    end
return ""
end
-- Convert category tables to strings and pass them through
-- [[Module:Category handler]].
return require('Module:Category handler')._main{
main = table.concat(self.categories[0] or {}),
template = table.concat(self.categories[10] or {}),
all = table.concat(self.categories.all or {}),
nocat = self.args.nocat,
page = self.args.page
}
end


function MessageBox:export()
    -- Add an error category for the template namespace if appropriate.
local root = mw.html.create()
    if data.templateErrorCategory then
        local catName = data.templateErrorCategory
        local templateCat
        if not name and not title.isSubpage then
            templateCat = format('[[Category:%s]]', catName)
        elseif type(name) == 'string' and title.prefixedText == ('Template:' .. name) then
            local paramsToCheck = data.templateErrorParamsToCheck or {}
            local count = 0
            for i, param in ipairs(paramsToCheck) do
                if not args[param] then
                    count = count + 1
                end
            end
            if count > 0 then
                templateCat = format('[[Category:%s|%d]]', catName, count)
            end
            if origCategoryNums and #origCategoryNums > 0 then
                templateCat = format('[[Category:%s|C]]', catName)
            end
        end
        tinsert(templateCats, templatecat)
    end


-- Add the subst check error.
    -- Categories for all namespaces.
if self.isSubstituted and self.name then
    local allCats = {}
root:tag('b')
    if invalidType then
:addClass('error')
        local catsort = (nsid == 0 and 'Main:' or '') .. title.prefixedText
:wikitext(string.format(
        tinsert(allCats, format('[[Category:Wikipedia message box parameter needs fixing|%s]]', catsort))
'Template <code>%s[[Template:%s|%s]]%s</code> has been incorrectly substituted.',
    end
mw.text.nowiki('{{'), self.name, self.name, mw.text.nowiki('}}')
))
end


local frame = mw.getCurrentFrame()
    ------------------------ Build the box ----------------------------
root:wikitext(frame:extensionTag{
   
name = 'templatestyles',
    local root = htmlBuilder.create()
args = { src = self.base_templatestyles },
})
-- Add support for a single custom templatestyles sheet. Undocumented as
-- need should be limited and many templates using mbox are substed; we
-- don't want to spread templatestyles sheets around to arbitrary places
if self.templatestyles then
root:wikitext(frame:extensionTag{
name = 'templatestyles',
args = { src = self.templatestyles },
})
end


-- Create the box table.
    -- Do the subst check.
local boxTable = root:tag('table')
    if data.substCheck and args.subst == 'SUBST' then
boxTable:attr('id', self.id or nil)
        if type(name) == 'string' then
for i, class in ipairs(self.classes or {}) do
            root
boxTable:addClass(class or nil)
                .tag('b')
end
                    .addClass('error')
boxTable
                    .wikitext(format(
:cssText(self.style or nil)
                        'Template <code>%s%s%s</code> has been incorrectly substituted.',
:attr('role', 'presentation')
                        mw.text.nowiki('{{'), name, mw.text.nowiki('}}')
                    ))
        end
        tinsert(allCats, '[[Category:Pages with incorrectly substituted templates]]')
    end


if self.attrs then
    -- Create the box table.
boxTable:attr(self.attrs)
    local box = root.tag('table')
end
    box
        .attr('id', args.id)
    for i, class in ipairs(data.classes) do
        box
            .addClass(class)
    end
    box
        .addClass(isSmall and smallClass)
        .addClass(data.classPlainlinksYesno and yesno(args.plainlinks or true) and 'plainlinks')
        .addClass(typeData.class)
        .addClass(args.class)
        .cssText(args.style)
        .attr('role', 'presentation')


-- Add the left-hand image.
    -- Add the left-hand image.
local row = boxTable:tag('tr')
    local row = box.tag('tr')
if self.imageLeft then
    local imageCheckBlank = data.imageCheckBlank
local imageLeftCell = row:tag('td'):addClass('mbox-image')
    if image ~= 'none' and not imageCheckBlank or image ~= 'none' and imageCheckBlank and image ~= 'blank' then
if self.imageCellDiv then
        local imageLeftCell = row.tag('td').addClass('mbox-image')
-- If we are using a div, redefine imageLeftCell so that the image
        if not isSmall and data.imageCellDiv then
-- is inside it. Divs use style="width: 52px;", which limits the
            imageLeftCell = imageLeftCell.tag('div').css('width', '52px') -- If we are using a div, redefine imageLeftCell so that the image is inside it.
-- image width to 52px. If any images in a div are wider than that,
        end
-- they may overlap with the text or cause other display problems.
        imageLeftCell
imageLeftCell = imageLeftCell:tag('div'):addClass('mbox-image-div')
            .wikitext(image or format('[[File:%s|%s|link=|alt=]]', typeData.image, imageSize))
end
    elseif data.imageEmptyCell then
imageLeftCell:wikitext(self.imageLeft or nil)
        row.tag('td')
elseif self.imageEmptyCell then
            .addClass('mbox-empty-cell') -- No image. Cell with some width or padding necessary for text cell to have 100% width.
-- Some message boxes define an empty cell if no image is specified, and
            .cssText(data.imageEmptyCellStyle and 'border:none;padding:0px;width:1px')
-- some don't. The old template code in templates where empty cells are
    end
-- specified gives the following hint: "No image. Cell with some width
-- or padding necessary for text cell to have 100% width."
row:tag('td')
:addClass('mbox-empty-cell')
end


-- Add the text.
    -- Add the text.
local textCell = row:tag('td'):addClass('mbox-text')
    local textCell = row.tag('td').addClass('mbox-text')
if self.useCollapsibleTextFields then
    if data.useCollapsibleTextFields then
-- The message box uses advanced text parameters that allow things to be
        textCell
-- collapsible. At the moment, only ambox uses this.
            .cssText(args.textstyle)
textCell:cssText(self.textstyle or nil)
        local textCellSpan = textCell.tag('span')
local textCellDiv = textCell:tag('div')
        textCellSpan
textCellDiv
            .addClass('mbox-text-span')
:addClass('mbox-text-span')
            .wikitext(issue)
:wikitext(self.issue or nil)
        if not isSmall then
if (self.talk or self.fix) then
            textCellSpan
textCellDiv:tag('span')
                .tag('span')
:addClass('hide-when-compact')
                    .addClass('hide-when-compact')
:wikitext(self.talk and (' ' .. self.talk) or nil)
                    .wikitext(talk)
:wikitext(self.fix and (' ' .. self.fix) or nil)
                    .wikitext(' ')
end
                    .wikitext(fix)
textCellDiv:wikitext(self.date and (' ' .. self.date) or nil)
                    .done()
if self.info and not self.isSmall then
        end
textCellDiv
        textCellSpan
:tag('span')
            .wikitext(date and format(" <small>''(%s)''</small>", date))
:addClass('hide-when-compact')
        if not isSmall then
:wikitext(self.info and (' ' .. self.info) or nil)
            textCellSpan
end
                .tag('span')
if self.removalNotice then
                    .addClass('hide-when-compact')
textCellDiv:tag('span')
                    .wikitext(info and ' ' .. info)
:addClass('hide-when-compact')
        end
:tag('i')
    else
:wikitext(string.format(" (%s)", self.removalNotice))
        textCell
end
            .cssText(args.textstyle)
else
            .wikitext(text)
-- Default text formatting - anything goes.
    end
textCell
:cssText(self.textstyle or nil)
:wikitext(self.text or nil)
end


-- Add the right-hand image.
    -- Add the right-hand image.
if self.imageRight then
    if imageRight and not (data.imageRightNone and imageRight == 'none') then
local imageRightCell = row:tag('td'):addClass('mbox-imageright')
        local imageRightCell = row.tag('td').addClass('mbox-imageright')
if self.imageCellDiv then
        if not isSmall and data.imageCellDiv then
-- If we are using a div, redefine imageRightCell so that the image
            imageRightCell = imageRightCell.tag('div').css('width', '52px') -- If we are using a div, redefine imageRightCell so that the image is inside it.
-- is inside it.
        end
imageRightCell = imageRightCell:tag('div'):addClass('mbox-image-div')
        imageRightCell
end
            .wikitext(imageRight)
imageRightCell
    end
:wikitext(self.imageRight or nil)
end


-- Add the below row.
    -- Add the below row.
if self.below then
    if data.below and args.below then
boxTable:tag('tr')
        box.tag('tr')
:tag('td')
            .tag('td')
:attr('colspan', self.imageRight and '3' or '2')
                .attr('colspan', args.imageright and '3' or '2')
:addClass('mbox-text')
                .addClass('mbox-text')
:cssText(self.textstyle or nil)
                .cssText(args.textstyle)
:wikitext(self.below or nil)
                .wikitext(args.below)
end
    end


-- Add error message for invalid type parameters.
    ------------------------ Error messages and categories ----------------------------
if self.invalidTypeError then
root:tag('div')
:addClass('mbox-invalid-type')
:wikitext(string.format(
'This message box is using an invalid "type=%s" parameter and needs fixing.',
self.type or ''
))
end


-- Add categories.
    -- Add error message for invalid type parameters.
root:wikitext(self:renderCategories() or nil)
    if invalidType then
        root
            .tag('div')
                .addClass('error')
                .css('text-align', 'center')
                .wikitext(format('This message box is using an invalid type parameter (<code>type=%s</code>) and needs fixing.', args.type or ''))
    end


return tostring(root)
    -- Add categories using categoryHandler.
    root
        .wikitext(categoryHandler{
            main = tconcat(mainCats),
            template = tconcat(templateCats),
            all = tconcat(allCats)
        })
   
    return tostring(root)
end
end


--------------------------------------------------------------------------------
local function makeWrapper(boxType)
-- Exports
    return function (frame)
--------------------------------------------------------------------------------
        -- If called via #invoke, use the args passed into the invoking
 
        -- template, or the args passed to #invoke if any exist. Otherwise
local p, mt = {}, {}
        -- assume args are being passed directly in from the debug console
 
        -- or from another Lua module.
function p._exportClasses()
        local origArgs
-- For testing.
        if frame == mw.getCurrentFrame() then
return {
            origArgs = frame:getParent().args
MessageBox = MessageBox
            for k, v in pairs(frame.args) do
}
                origArgs = frame.args
end
                break
 
            end
function p.main(boxType, args, cfgTables)
        else
local box = MessageBox.new(boxType, args, cfgTables or mw.loadData(CONFIG_MODULE))
            origArgs = frame
box:setParameters()
        end
box:setCategories()
        -- Trim whitespace and remove blank arguments.
return box:export()
        local args = {}
        for k, v in pairs(origArgs) do
            if type(v) == 'string' then
                v = mw.text.trim(v)
            end
            if v ~= '' or k == 'talk' or k == 'sect' or k == 'date' then
                args[k] = v
            end
        end
        return p.build(boxType, args)
    end
end
end


function mt.__index(t, k)
p.mbox = makeWrapper('mbox')
return function (frame)
p.ambox = makeWrapper('ambox')
if not getArgs then
p.cmbox = makeWrapper('cmbox')
getArgs = require('Module:Arguments').getArgs
p.fmbox = makeWrapper('fmbox')
end
p.imbox = makeWrapper('imbox')
return t.main(k, getArgs(frame, {trim = false, removeBlanks = false}))
p.ombox = makeWrapper('ombox')
end
p.tmbox = makeWrapper('tmbox')
end


return setmetatable(p, mt)
return p
Please note that all contributions to Meta Wiki may be edited, altered, or removed by other contributors. If you do not want your writing to be edited mercilessly, 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 (see Meta Wiki:Copyrights for details). Do not submit copyrighted work without permission!
Cancel Editing help (opens in new window)

Template used on this page:

Retrieved from "https://meta.skywiki.org/wiki/Module:Message_box"