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 not ns then return end
return nil
    if type(ns) == 'string' then
end
        ns = lang:ucfirst(mw.ustring.lower(ns))
table.insert(self.classes, class)
        if ns == 'Main' then
            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 pageTitle = getTitleObject(args.page ~= '' and args.page)
end
    local title = pageTitle or mw.title.getCurrentTitle()
    local demospace = getNamespaceId(args.demospace ~= '' and args.demospace)
    local nsid = 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
   
    -- Only allow blank arguments for the parameter names listed in data.allowBlankParams.
    local newArgs = {}
    for k, v in pairs(args) do
        for i, param in ipairs(data.allowBlankParams or {}) do
            if v ~= '' or k == param then
                newArgs[k] = v
            end
        end
    end
    args = newArgs
    newArgs = nil


-- 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
        if args.cat then
self:setAllNamespaceCategories()
            args.cat1 = args.cat
end
        end
        local origCatNums = getArgNums(args, 'cat')
        if args.category then
            args.category1 = args.category
        end
        local origCategoryNums = getArgNums(args, 'category')
        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 isTemplatePage = type(name) == 'string' and title.prefixedText == ('Template:' .. name)
-- No categories added, no need to pass them to Category handler so,
    local templateCats = {}
-- if it was invoked, it would return the empty string.
    if data.templateCategory then
-- So we shortcut and return the empty string.
        if name then
return ""
            if isTemplatePage then
end
                tinsert(templateCats, format('[[Category:%s]]', data.templateCategory))
-- Convert category tables to strings and pass them through
            end
-- [[Module:Category handler]].
        elseif not title.isSubpage then
return require('Module:Category handler')._main{
            tinsert(templateCats, format('[[Category:%s]]', data.templateCategory))
main = table.concat(self.categories[0] or {}),
        end
template = table.concat(self.categories[10] or {}),
    end
all = table.concat(self.categories.all or {}),
   
nocat = self.args.nocat,
    -- Add an error category for the template namespace if appropriate.
page = self.args.page
    if data.templateErrorCategory then
}
        local catName = data.templateErrorCategory
end
        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


function MessageBox:export()
    -- Categories for all namespaces.
local root = mw.html.create()
    local allCats = {}
    if invalidType then
        local catsort = (nsid == 0 and 'Main:' or '') .. title.prefixedText
        tinsert(allCats, format('[[Category:Wikipedia message box parameter needs fixing|%s]]', catsort))
    end


-- Add the subst check error.
    ------------------------ Build the box ----------------------------
if self.isSubstituted and self.name then
   
root:tag('b')
    local root = htmlBuilder.create()
:addClass('error')
:wikitext(string.format(
'Template <code>%s[[Template:%s|%s]]%s</code> has been incorrectly substituted.',
mw.text.nowiki('{{'), self.name, self.name, mw.text.nowiki('}}')
))
end


local frame = mw.getCurrentFrame()
    -- Do the subst check.
root:wikitext(frame:extensionTag{
    if data.substCheck and args.subst == 'SUBST' then
name = 'templatestyles',
        if type(name) == 'string' then
args = { src = self.base_templatestyles },
            root
})
                .tag('b')
-- Add support for a single custom templatestyles sheet. Undocumented as
                    .addClass('error')
-- need should be limited and many templates using mbox are substed; we
                    .wikitext(format(
-- don't want to spread templatestyles sheets around to arbitrary places
                        'Template <code>%s%s%s</code> has been incorrectly substituted.',
if self.templatestyles then
                        mw.text.nowiki('{{'), name, mw.text.nowiki('}}')
root:wikitext(frame:extensionTag{
                    ))
name = 'templatestyles',
        end
args = { src = self.templatestyles },
        tinsert(allCats, '[[Category:Pages with incorrectly substituted templates]]')
})
    end
end


-- Create the box table.
    -- Create the box table.
local boxTable = root:tag('table')
    local box = root.tag('table')
boxTable:attr('id', self.id or nil)
    box
for i, class in ipairs(self.classes or {}) do
        .attr('id', args.id)
boxTable:addClass(class or nil)
    for i, class in ipairs(data.classes) do
end
        box
boxTable
            .addClass(class)
:cssText(self.style or nil)
    end
:attr('role', 'presentation')
    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')


if self.attrs then
    -- Add the left-hand image.
boxTable:attr(self.attrs)
    local row = box.tag('tr')
end
    local imageCheckBlank = data.imageCheckBlank
    if image ~= 'none' and not imageCheckBlank or image ~= 'none' and imageCheckBlank and image ~= 'blank' then
        local imageLeftCell = row.tag('td').addClass('mbox-image')
        if not isSmall and data.imageCellDiv then
            imageLeftCell = imageLeftCell.tag('div').css('width', '52px') -- If we are using a div, redefine imageLeftCell so that the image is inside it.
        end
        imageLeftCell
            .wikitext(image or format('[[File:%s|%s|link=|alt=]]', typeData.image, imageSize))
    elseif data.imageEmptyCell then
        row.tag('td')
            .addClass('mbox-empty-cell') -- No image. Cell with some width or padding necessary for text cell to have 100% width.
            .cssText(data.imageEmptyCellStyle and 'border:none;padding:0px;width:1px')
    end


-- Add the left-hand image.
    -- Add the text.
local row = boxTable:tag('tr')
    local textCell = row.tag('td').addClass('mbox-text')
if self.imageLeft then
    if data.useCollapsibleTextFields then
local imageLeftCell = row:tag('td'):addClass('mbox-image')
        textCell
if self.imageCellDiv then
            .cssText(args.textstyle)
-- If we are using a div, redefine imageLeftCell so that the image
        local textCellSpan = textCell.tag('span')
-- is inside it. Divs use style="width: 52px;", which limits the
        textCellSpan
-- image width to 52px. If any images in a div are wider than that,
            .addClass('mbox-text-span')
-- they may overlap with the text or cause other display problems.
            .wikitext(issue)
imageLeftCell = imageLeftCell:tag('div'):addClass('mbox-image-div')
        if not isSmall then
end
            textCellSpan
imageLeftCell:wikitext(self.imageLeft or nil)
                .tag('span')
elseif self.imageEmptyCell then
                    .addClass('hide-when-compact')
-- Some message boxes define an empty cell if no image is specified, and
                    .wikitext(talk)
-- some don't. The old template code in templates where empty cells are
                    .wikitext(' ')
-- specified gives the following hint: "No image. Cell with some width
                    .wikitext(fix)
-- or padding necessary for text cell to have 100% width."
                    .done()
row:tag('td')
        end
:addClass('mbox-empty-cell')
        textCellSpan
end
            .wikitext(date and format(" <small>''(%s)''</small>", date))
        if not isSmall then
            textCellSpan
                .tag('span')
                    .addClass('hide-when-compact')
                    .wikitext(info and ' ' .. info)
        end
    else
        textCell
            .cssText(args.textstyle)
            .wikitext(text)
    end


-- Add the text.
    -- Add the right-hand image.
local textCell = row:tag('td'):addClass('mbox-text')
    if imageRight and not (data.imageRightNone and imageRight == 'none') then
if self.useCollapsibleTextFields then
        local imageRightCell = row.tag('td').addClass('mbox-imageright')
-- The message box uses advanced text parameters that allow things to be
        if not isSmall and data.imageCellDiv then
-- collapsible. At the moment, only ambox uses this.
            imageRightCell = imageRightCell.tag('div').css('width', '52px') -- If we are using a div, redefine imageRightCell so that the image is inside it.
textCell:cssText(self.textstyle or nil)
        end
local textCellDiv = textCell:tag('div')
        imageRightCell
textCellDiv
            .wikitext(imageRight)
:addClass('mbox-text-span')
    end
:wikitext(self.issue or nil)
if (self.talk or self.fix) then
textCellDiv:tag('span')
:addClass('hide-when-compact')
:wikitext(self.talk and (' ' .. self.talk) or nil)
:wikitext(self.fix and (' ' .. self.fix) or nil)
end
textCellDiv:wikitext(self.date and (' ' .. self.date) or nil)
if self.info and not self.isSmall then
textCellDiv
:tag('span')
:addClass('hide-when-compact')
:wikitext(self.info and (' ' .. self.info) or nil)
end
if self.removalNotice then
textCellDiv:tag('span')
:addClass('hide-when-compact')
:tag('i')
:wikitext(string.format(" (%s)", self.removalNotice))
end
else
-- Default text formatting - anything goes.
textCell
:cssText(self.textstyle or nil)
:wikitext(self.text or nil)
end


-- Add the right-hand image.
    -- Add the below row.
if self.imageRight then
    if data.below and args.below then
local imageRightCell = row:tag('td'):addClass('mbox-imageright')
        box.tag('tr')
if self.imageCellDiv then
            .tag('td')
-- If we are using a div, redefine imageRightCell so that the image
                .attr('colspan', args.imageright and '3' or '2')
-- is inside it.
                .addClass('mbox-text')
imageRightCell = imageRightCell:tag('div'):addClass('mbox-image-div')
                .cssText(args.textstyle)
end
                .wikitext(args.below)
imageRightCell
    end
:wikitext(self.imageRight or nil)
end


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


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


-- Add categories.
    -- Add categories using categoryHandler.
root:wikitext(self:renderCategories() or nil)
    root
 
        .wikitext(categoryHandler{
return tostring(root)
            main = tconcat(mainCats),
            template = tconcat(templateCats),
            all = tconcat(allCats),
            nocat = args.nocat,
            demospace = demospace and args.demospace or nil,
            page = pageTitle and pageTitle.prefixedText or nil
        })
   
    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
            args[k] = v
        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"