Line 1: |
Line 1: |
− | -- This is a meta-module for producing message box templates, including {{mbox}}, {{ambox}}, | + | -- This is a meta-module for producing message box templates, including |
− | -- {{imbox}}, {{tmbox}}, {{ombox}}, {{cmbox}} and {{fmbox}}.
| + | -- {{mbox}}, {{ambox}}, {{imbox}}, {{tmbox}}, {{ombox}}, {{cmbox}} and {{fmbox}}. |
| | | |
− | -- Require necessary modules. | + | -- Load necessary modules. |
− | local getArgs = require('Module:Arguments').getArgs
| + | require('Module:No globals') |
− | local htmlBuilder = require('Module:HtmlBuilder') | + | local getArgs |
− | local categoryHandler = require('Module:Category handler').main | + | local categoryHandler = require('Module:Category handler')._main |
| local yesno = require('Module:Yesno') | | local yesno = require('Module:Yesno') |
− |
| |
− | -- Load the configuration page.
| |
− | local cfgTables = mw.loadData('Module:Message box/configuration')
| |
| | | |
| -- Get a language object for formatDate and ucfirst. | | -- Get a language object for formatDate and ucfirst. |
| local lang = mw.language.getContentLanguage() | | local lang = mw.language.getContentLanguage() |
− |
| |
− | -- Set aliases for often-used functions to reduce table lookups.
| |
− | local format = mw.ustring.format
| |
− | local tinsert = table.insert
| |
− | local tconcat = table.concat
| |
− | local trim = mw.text.trim
| |
| | | |
| -------------------------------------------------------------------------------- | | -------------------------------------------------------------------------------- |
Line 24: |
Line 15: |
| -------------------------------------------------------------------------------- | | -------------------------------------------------------------------------------- |
| | | |
− | local function getTitleObject(page, ...) | + | local function getTitleObject(...) |
− | if type(page) == 'string' then | + | -- Get the title object, passing the function through pcall |
− | -- Get the title object, passing the function through pcall
| + | -- in case we are over the expensive function count limit. |
− | -- in case we are over the expensive function count limit.
| + | local success, title = pcall(mw.title.new, ...) |
− | local success, title = pcall(mw.title.new, page, ...)
| + | if success then |
− | if success then
| + | return title |
− | return title
| |
− | end
| |
| end | | end |
| end | | end |
Line 46: |
Line 35: |
| local ret = {} | | local ret = {} |
| for k in pairs(vals) do | | for k in pairs(vals) do |
− | tinsert(ret, k) | + | table.insert(ret, k) |
| end | | end |
| table.sort(ret) | | table.sort(ret) |
Line 57: |
Line 46: |
| local num = mw.ustring.match(tostring(k), '^' .. prefix .. '([1-9]%d*)$') | | local num = mw.ustring.match(tostring(k), '^' .. prefix .. '([1-9]%d*)$') |
| if num then | | if num then |
− | tinsert(nums, tonumber(num)) | + | table.insert(nums, tonumber(num)) |
| end | | end |
| end | | end |
Line 68: |
Line 57: |
| -------------------------------------------------------------------------------- | | -------------------------------------------------------------------------------- |
| | | |
− | local box = {} | + | local MessageBox = {} |
− | box.__index = box
| + | MessageBox.__index = MessageBox |
| | | |
− | function box.new() | + | function MessageBox.new(boxType, args, cfg) |
| + | args = args or {} |
| local obj = {} | | local obj = {} |
− | setmetatable(obj, box)
| |
− | return obj
| |
− | end
| |
| | | |
− | function box.getNamespaceId(ns)
| + | -- Set the title object and the namespace. |
− | if not ns then return end | + | obj.title = getTitleObject(args.page) or mw.title.getCurrentTitle() |
− | if type(ns) == 'string' then
| |
− | ns = lang:ucfirst(mw.ustring.lower(ns))
| |
− | if ns == 'Main' then
| |
− | ns = 0
| |
− | end
| |
− | end
| |
− | local nsTable = mw.site.namespaces[ns]
| |
− | if nsTable then
| |
− | return nsTable.id
| |
− | end
| |
− | end
| |
| | | |
− | function box.getMboxType(nsid)
| + | -- Set the config for our box type. |
− | -- Gets the mbox type from a namespace number. | + | obj.cfg = cfg[boxType] |
− | if nsid == 0 then
| + | if not obj.cfg then |
− | return 'ambox' -- main namespace
| + | local ns = obj.title.namespace |
− | elseif nsid == 6 then
| + | -- boxType is "mbox" or invalid input |
− | return 'imbox' -- file namespace
| + | if ns == 0 then |
− | elseif nsid == 14 then
| + | obj.cfg = cfg.ambox -- main namespace |
− | return 'cmbox' -- category namespace
| + | elseif ns == 6 then |
− | else
| + | obj.cfg = cfg.imbox -- file namespace |
− | local nsTable = mw.site.namespaces[nsid]
| + | elseif ns == 14 then |
− | if nsTable and nsTable.isTalk then
| + | obj.cfg = cfg.cmbox -- category namespace |
− | return 'tmbox' -- any talk namespace
| |
| else | | else |
− | return 'ombox' -- other namespaces or invalid input | + | 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 |
| end | | end |
− | end
| |
| | | |
− | function box:addCat(ns, cat, sort)
| + | -- Set the arguments, and remove all blank arguments except for the ones |
− | if type(cat) ~= 'string' then return end | + | -- listed in cfg.allowBlankParams. |
− | local nsVals = {'main', 'template', 'all'} | + | do |
− | local tname
| + | local newArgs = {} |
− | for i, val in ipairs(nsVals) do
| + | for k, v in pairs(args) do |
− | if ns == val then
| + | if v ~= '' then |
− | tname = ns .. 'Cats' | + | newArgs[k] = v |
| + | end |
| end | | end |
− | end
| + | for i, param in ipairs(obj.cfg.allowBlankParams or {}) do |
− | if not tname then
| + | newArgs[param] = args[param] |
− | for i, val in ipairs(nsVals) do | |
− | nsVals[i] = format('"%s"', val) | |
| end | | end |
− | error('invalid ns parameter passed to box:addCat; valid values are ' .. mw.text.listToText(nsVals, nil, ' or ')) | + | obj.args = newArgs |
− | end
| |
− | self[tname] = self[tname] or {}
| |
− | if type(sort) == 'string' then
| |
− | tinsert(self[tname], format('[[Category:%s|%s]]', cat, sort))
| |
− | else
| |
− | tinsert(self[tname], format('[[Category:%s]]', cat))
| |
| end | | end |
− | end
| |
| | | |
− | function box:addClass(class)
| + | -- Define internal data structure. |
− | if type(class) ~= 'string' then return end | + | obj.categories = {} |
− | self.classes = self.classes or {} | + | obj.classes = {} |
− | tinsert(self.classes, class) | |
− | end
| |
| | | |
− | function box:setTitle(args)
| + | return setmetatable(obj, MessageBox) |
− | -- Get the title object and the namespace.
| |
− | self.pageTitle = getTitleObject(args.page ~= '' and args.page)
| |
− | self.title = self.pageTitle or mw.title.getCurrentTitle()
| |
− | self.demospace = args.demospace ~= '' and args.demospace or nil
| |
− | self.nsid = box.getNamespaceId(self.demospace) or self.title.namespace | |
| end | | end |
| | | |
− | function box:getConfig(boxType) | + | function MessageBox:addCat(ns, cat, sort) |
− | -- Get the box config data from the data page.
| + | if not cat then |
− | if boxType == 'mbox' then | + | return nil |
− | boxType = box.getMboxType(self.nsid) | |
| end | | end |
− | local cfg = cfgTables[boxType]
| + | if sort then |
− | if not cfg then | + | cat = string.format('[[Category:%s|%s]]', cat, sort) |
− | local boxTypes = {} | + | else |
− | for k, v in pairs(dataTables) do
| + | cat = string.format('[[Category:%s]]', cat) |
− | 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 | | end |
− | return cfg | + | self.categories[ns] = self.categories[ns] or {} |
| + | table.insert(self.categories[ns], cat) |
| end | | end |
| | | |
− | function box:removeBlankArgs(cfg, args) | + | function MessageBox:addClass(class) |
− | -- Only allow blank arguments for the parameter names listed in cfg.allowBlankParams. | + | if not class then |
− | local newArgs = {}
| + | return nil |
− | for k, v in pairs(args) do
| |
− | if v ~= '' then
| |
− | newArgs[k] = v
| |
− | end | |
| end | | end |
− | for i, param in ipairs(cfg.allowBlankParams or {}) do | + | table.insert(self.classes, class) |
− | newArgs[param] = args[param]
| |
− | end
| |
− | return newArgs
| |
| end | | end |
| | | |
− | function box:setBoxParameters(cfg, args) | + | function MessageBox:setParameters() |
| + | local args = self.args |
| + | local cfg = self.cfg |
| + | |
| -- Get type data. | | -- Get type data. |
| self.type = args.type | | self.type = args.type |
| local typeData = cfg.types[self.type] | | local typeData = cfg.types[self.type] |
− | self.invalidTypeError = cfg.showInvalidTypeError and self.type and not typeData and true or false | + | self.invalidTypeError = cfg.showInvalidTypeError |
| + | and self.type |
| + | and not typeData |
| typeData = typeData or cfg.types[cfg.default] | | typeData = typeData or cfg.types[cfg.default] |
| self.typeClass = typeData.class | | self.typeClass = typeData.class |
Line 187: |
Line 145: |
| | | |
| -- Find if the box has been wrongly substituted. | | -- Find if the box has been wrongly substituted. |
− | if cfg.substCheck and args.subst == 'SUBST' then | + | self.isSubstituted = cfg.substCheck and args.subst == 'SUBST' |
− | self.isSubstituted = true
| |
− | end
| |
| | | |
| -- Find whether we are using a small message box. | | -- Find whether we are using a small message box. |
− | if cfg.allowSmall and ( | + | self.isSmall = cfg.allowSmall and ( |
| cfg.smallParam and args.small == cfg.smallParam | | cfg.smallParam and args.small == cfg.smallParam |
| or not cfg.smallParam and yesno(args.small) | | or not cfg.smallParam and yesno(args.small) |
| ) | | ) |
− | then
| |
− | self.isSmall = true
| |
− | else
| |
− | self.isSmall = false
| |
− | end
| |
| | | |
| -- Add attributes, classes and styles. | | -- Add attributes, classes and styles. |
− | if cfg.allowId then | + | self.id = args.id |
− | self.id = args.id
| + | self:addClass( |
− | end
| + | cfg.usePlainlinksParam and yesno(args.plainlinks or true) and 'plainlinks' |
− | self:addClass(cfg.usePlainlinksParam and yesno(args.plainlinks or true) and 'plainlinks') | + | ) |
| for _, class in ipairs(cfg.classes or {}) do | | for _, class in ipairs(cfg.classes or {}) do |
| self:addClass(class) | | self:addClass(class) |
Line 212: |
Line 163: |
| if self.isSmall then | | if self.isSmall then |
| self:addClass(cfg.smallClass or 'mbox-small') | | self:addClass(cfg.smallClass or 'mbox-small') |
− | end
| |
− | if yesno(args.hidden) then
| |
− | self:addClass('infobox editsection')
| |
| end | | end |
| self:addClass(self.typeClass) | | self:addClass(self.typeClass) |
| self:addClass(args.class) | | self:addClass(args.class) |
| self.style = args.style | | self.style = args.style |
| + | self.attrs = args.attrs |
| | | |
| -- Set text style. | | -- Set text style. |
| self.textstyle = args.textstyle | | self.textstyle = args.textstyle |
| | | |
− | -- Find if we are on the template page or not. This functionality is only used if useCollapsibleTextFields is set, | + | -- Find if we are on the template page or not. This functionality is only |
− | -- or if both cfg.templateCategory and cfg.templateCategoryRequireName are set.
| + | -- used if useCollapsibleTextFields is set, or if both cfg.templateCategory |
| + | -- and cfg.templateCategoryRequireName are set. |
| self.useCollapsibleTextFields = cfg.useCollapsibleTextFields | | self.useCollapsibleTextFields = cfg.useCollapsibleTextFields |
− | if self.useCollapsibleTextFields or cfg.templateCategory and cfg.templateCategoryRequireName then | + | if self.useCollapsibleTextFields |
| + | or cfg.templateCategory |
| + | and cfg.templateCategoryRequireName |
| + | then |
| self.name = args.name | | self.name = args.name |
| if self.name 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 | + | local templateName = mw.ustring.match( |
| + | self.name, |
| + | '^[tT][eE][mM][pP][lL][aA][tT][eE][%s_]*:[%s_]*(.*)$' |
| + | ) or self.name |
| templateName = 'Template:' .. templateName | | templateName = 'Template:' .. templateName |
| self.templateTitle = getTitleObject(templateName) | | self.templateTitle = getTitleObject(templateName) |
| end | | end |
− | self.isTemplatePage = self.templateTitle and mw.title.equals(self.title, self.templateTitle) or false | + | self.isTemplatePage = self.templateTitle |
| + | and mw.title.equals(self.title, self.templateTitle) |
| end | | end |
| | | |
− | -- Process data for collapsible text fields. At the moment these are only used in {{ambox}}. | + | -- Process data for collapsible text fields. At the moment these are only |
| + | -- used in {{ambox}}. |
| if self.useCollapsibleTextFields then | | if self.useCollapsibleTextFields then |
| -- Get the self.issue value. | | -- Get the self.issue value. |
Line 253: |
Line 211: |
| text = type(text) == 'string' and text or nil | | text = type(text) == 'string' and text or nil |
| local issues = {} | | local issues = {} |
− | tinsert(issues, sect) | + | table.insert(issues, sect) |
− | tinsert(issues, issue) | + | table.insert(issues, issue) |
− | tinsert(issues, text) | + | table.insert(issues, text) |
− | self.issue = tconcat(issues, ' ') | + | self.issue = table.concat(issues, ' ') |
| end | | end |
| | | |
| -- Get the self.talk value. | | -- Get the self.talk value. |
| local talk = args.talk | | local talk = args.talk |
− | if talk == '' -- Show talk links on the template page or template subpages if the talk parameter is blank. | + | -- Show talk links on the template page or template subpages if the talk |
− | and self.templateTitle | + | -- parameter is blank. |
− | and (mw.title.equals(self.templateTitle, self.title) or self.title:isSubpageOf(self.templateTitle)) | + | if talk == '' |
| + | and self.templateTitle |
| + | and ( |
| + | mw.title.equals(self.templateTitle, self.title) |
| + | or self.title:isSubpageOf(self.templateTitle) |
| + | ) |
| then | | then |
| talk = '#' | | talk = '#' |
Line 270: |
Line 233: |
| end | | end |
| if talk then | | 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, | + | -- If the talk value is a talk page, make a link to that page. Else |
− | -- and make a link to the talk page of the current page with that section heading.
| + | -- 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 talkTitle = getTitleObject(talk) |
| local talkArgIsTalkPage = true | | local talkArgIsTalkPage = true |
| if not talkTitle or not talkTitle.isTalkPage then | | if not talkTitle or not talkTitle.isTalkPage then |
| talkArgIsTalkPage = false | | talkArgIsTalkPage = false |
− | talkTitle = getTitleObject(self.title.text, mw.site.namespaces[self.title.namespace].talk.id) | + | talkTitle = getTitleObject( |
| + | self.title.text, |
| + | mw.site.namespaces[self.title.namespace].talk.id |
| + | ) |
| end | | end |
| if talkTitle and talkTitle.exists then | | if talkTitle and talkTitle.exists then |
| local talkText = 'Relevant discussion may be found on' | | local talkText = 'Relevant discussion may be found on' |
| if talkArgIsTalkPage then | | if talkArgIsTalkPage then |
− | talkText = format('%s [[%s|%s]].', talkText, talk, talkTitle.prefixedText) | + | talkText = string.format( |
| + | '%s [[%s|%s]].', |
| + | talkText, |
| + | talk, |
| + | talkTitle.prefixedText |
| + | ) |
| else | | else |
− | talkText = format('%s the [[%s#%s|talk page]].', talkText, talkTitle.prefixedText, talk) | + | talkText = string.format( |
| + | '%s the [[%s#%s|talk page]].', |
| + | talkText, |
| + | talkTitle.prefixedText, |
| + | talk |
| + | ) |
| end | | end |
| self.talk = talkText | | self.talk = talkText |
Line 298: |
Line 275: |
| end | | end |
| if date then | | if date then |
− | self.date = format(" <small>''(%s)''</small>", date) | + | self.date = string.format(" <small>''(%s)''</small>", date) |
| end | | end |
| self.info = args.info | | self.info = args.info |
| end | | end |
| | | |
− | -- Set the non-collapsible text field. At the moment this is used by all box types other than ambox, | + | -- Set the non-collapsible text field. At the moment this is used by all box |
− | -- and also by ambox when small=yes.
| + | -- types other than ambox, and also by ambox when small=yes. |
| if self.isSmall then | | if self.isSmall then |
| self.text = args.smalltext or args.text | | self.text = args.smalltext or args.text |
Line 315: |
Line 292: |
| | | |
| -- General image settings. | | -- General image settings. |
− | self.imageCellDiv = not self.isSmall and cfg.imageCellDiv and true or false | + | self.imageCellDiv = not self.isSmall and cfg.imageCellDiv |
| self.imageEmptyCell = cfg.imageEmptyCell | | self.imageEmptyCell = cfg.imageEmptyCell |
| if cfg.imageEmptyCellStyle then | | if cfg.imageEmptyCellStyle then |
Line 328: |
Line 305: |
| self.imageLeft = imageLeft | | self.imageLeft = imageLeft |
| if not imageLeft then | | if not imageLeft then |
− | local imageSize = self.isSmall and (cfg.imageSmallSize or '30x30px') or '40x40px' | + | local imageSize = self.isSmall |
− | self.imageLeft = format('[[File:%s|%s|link=|alt=]]', self.typeImage or 'Imbox notice.png', imageSize) | + | 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 |
| end | | end |
Line 337: |
Line 317: |
| if not (cfg.imageRightNone and imageRight == 'none') then | | if not (cfg.imageRightNone and imageRight == 'none') then |
| self.imageRight = imageRight | | self.imageRight = imageRight |
| + | end |
| + | end |
| + | |
| + | function MessageBox:setMainspaceCategories() |
| + | local args = self.args |
| + | local cfg = self.cfg |
| + | |
| + | if not cfg.allowMainspaceCategories then |
| + | return nil |
| end | | end |
| | | |
− | -- Add mainspace categories. At the moment these are only used in {{ambox}}. | + | local nums = {} |
− | if cfg.allowMainspaceCategories then | + | for _, prefix in ipairs{'cat', 'category', 'all'} do |
− | if args.cat then | + | args[prefix .. '1'] = args[prefix] |
− | args.cat1 = args.cat | + | nums = union(nums, getArgNums(args, prefix)) |
| + | end |
| + | |
| + | -- The following is roughly equivalent to the old {{Ambox/category}}. |
| + | 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 | | end |
− | self.catNums = getArgNums(args, 'cat')
| + | if allCat then |
− | if args.category then
| + | self:addCat(0, allCat) |
− | args.category1 = args.category
| |
− | end
| |
− | self.categoryNums = getArgNums(args, 'category')
| |
− | if args.all then | |
− | args.all1 = args.all
| |
− | end
| |
− | self.allNums = getArgNums(args, 'all')
| |
− | self.categoryParamNums = union(self.catNums, self.categoryNums)
| |
− | self.categoryParamNums = union(self.categoryParamNums, self.allNums)
| |
− | -- The following is roughly equivalent to the old {{Ambox/category}}.
| |
− | local date = args.date
| |
− | date = type(date) == 'string' and date
| |
− | local preposition = 'from'
| |
− | for _, num in ipairs(self.categoryParamNums) 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 = format('%s %s %s', mainCat, preposition, date)
| |
− | self:addCat('main', catTitle)
| |
− | catTitle = getTitleObject('Category:' .. catTitle)
| |
− | if not catTitle or not catTitle.exists then
| |
− | self:addCat('main', 'Articles with invalid date parameter in template')
| |
− | end
| |
− | elseif mainCat and (not date or date == '') then
| |
− | self:addCat('main', mainCat)
| |
− | end | |
− | if allCat then
| |
− | self:addCat('main', allCat)
| |
− | end
| |
| end | | end |
| end | | end |
| + | end |
| + | |
| + | function MessageBox:setTemplateCategories() |
| + | local args = self.args |
| + | local cfg = self.cfg |
| | | |
− | -- Add template-namespace categories. | + | -- Add template categories. |
| if cfg.templateCategory then | | if cfg.templateCategory then |
| if cfg.templateCategoryRequireName then | | if cfg.templateCategoryRequireName then |
| if self.isTemplatePage then | | if self.isTemplatePage then |
− | self:addCat('template', cfg.templateCategory) | + | self:addCat(10, cfg.templateCategory) |
| end | | end |
| elseif not self.title.isSubpage then | | elseif not self.title.isSubpage then |
− | self:addCat('template', cfg.templateCategory) | + | self:addCat(10, cfg.templateCategory) |
| end | | end |
| end | | end |
| | | |
− | -- Add template error category. | + | -- Add template error categories. |
| if cfg.templateErrorCategory then | | if cfg.templateErrorCategory then |
| local templateErrorCategory = cfg.templateErrorCategory | | local templateErrorCategory = cfg.templateErrorCategory |
Line 414: |
Line 398: |
| end | | end |
| end | | end |
− | self:addCat('template', templateCat, templateSort) | + | self:addCat(10, templateCat, templateSort) |
| end | | end |
| + | end |
| | | |
− | -- Categories for all namespaces. | + | function MessageBox:setAllNamespaceCategories() |
| + | -- Set categories for all namespaces. |
| if self.invalidTypeError then | | if self.invalidTypeError then |
− | local allSort = (self.nsid == 0 and 'Main:' or '') .. self.title.prefixedText | + | local allSort = (self.title.namespace == 0 and 'Main:' or '') .. self.title.prefixedText |
| self:addCat('all', 'Wikipedia message box parameter needs fixing', allSort) | | self:addCat('all', 'Wikipedia message box parameter needs fixing', allSort) |
| end | | end |
Line 425: |
Line 411: |
| self:addCat('all', 'Pages with incorrectly substituted templates') | | self:addCat('all', 'Pages with incorrectly substituted templates') |
| end | | end |
| + | end |
| + | |
| + | function MessageBox:setCategories() |
| + | if self.title.namespace == 0 then |
| + | self:setMainspaceCategories() |
| + | elseif self.title.namespace == 10 then |
| + | self:setTemplateCategories() |
| + | end |
| + | self:setAllNamespaceCategories() |
| + | end |
| | | |
− | -- Convert category tables to strings and pass them through [[Module:Category handler]]. | + | function MessageBox:renderCategories() |
− | self.categories = categoryHandler{ | + | -- Convert category tables to strings and pass them through |
− | main = tconcat(self.mainCats or {}), | + | -- [[Module:Category handler]]. |
− | template = tconcat(self.templateCats or {}), | + | return categoryHandler{ |
− | all = tconcat(self.allCats or {}), | + | main = table.concat(self.categories[0] or {}), |
− | nocat = args.nocat, | + | template = table.concat(self.categories[10] or {}), |
− | demospace = self.demospace,
| + | all = table.concat(self.categories.all or {}), |
− | page = self.pageTitle and self.pageTitle.prefixedText or nil | + | nocat = self.args.nocat, |
| + | page = self.args.page |
| } | | } |
| end | | end |
| | | |
− | function box:export() | + | function MessageBox:export() |
− | local root = htmlBuilder.create() | + | local root = mw.html.create() |
| | | |
| -- Add the subst check error. | | -- Add the subst check error. |
| if self.isSubstituted and self.name then | | if self.isSubstituted and self.name then |
− | root | + | root:tag('b') |
− | .tag('b')
| + | :addClass('error') |
− | .addClass('error')
| + | :wikitext(string.format( |
− | .wikitext(format(
| + | 'Template <code>%s[[Template:%s|%s]]%s</code> has been incorrectly substituted.', |
− | 'Template <code>%s[[Template:%s|%s]]%s</code> has been incorrectly substituted.',
| + | mw.text.nowiki('{{'), self.name, self.name, mw.text.nowiki('}}') |
− | mw.text.nowiki('{{'), self.name, self.name, mw.text.nowiki('}}')
| + | )) |
− | ))
| |
| end | | end |
| | | |
| -- Create the box table. | | -- Create the box table. |
− | local boxTable = root.tag('table') | + | local boxTable = root:tag('table') |
− | boxTable | + | boxTable:attr('id', self.id or nil) |
− | .attr('id', self.id)
| |
| for i, class in ipairs(self.classes or {}) do | | for i, class in ipairs(self.classes or {}) do |
− | boxTable | + | boxTable:addClass(class or nil) |
− | .addClass(class)
| |
| end | | end |
| boxTable | | boxTable |
− | .cssText(self.style) | + | :cssText(self.style or nil) |
− | .attr('role', 'presentation') | + | :attr('role', 'presentation') |
| + | |
| + | if self.attrs then |
| + | boxTable:attr(self.attrs) |
| + | end |
| | | |
| -- Add the left-hand image. | | -- Add the left-hand image. |
− | local row = boxTable.tag('tr') | + | local row = boxTable:tag('tr') |
| if self.imageLeft then | | if self.imageLeft then |
− | local imageLeftCell = row.tag('td').addClass('mbox-image') | + | local imageLeftCell = row:tag('td'):addClass('mbox-image') |
| if self.imageCellDiv then | | if self.imageCellDiv then |
− | -- If we are using a div, redefine imageLeftCell so that the image is inside it. | + | -- If we are using a div, redefine imageLeftCell so that the image |
− | -- Divs use style="width: 52px;", which limits the image width to 52px. If any
| + | -- is inside it. Divs use style="width: 52px;", which limits the |
− | -- images in a div are wider than that, they may overlap with the text or cause
| + | -- image width to 52px. If any images in a div are wider than that, |
− | -- other display problems.
| + | -- they may overlap with the text or cause other display problems. |
− | imageLeftCell = imageLeftCell.tag('div').css('width', '52px') | + | imageLeftCell = imageLeftCell:tag('div'):css('width', '52px') |
| end | | end |
− | imageLeftCell | + | imageLeftCell:wikitext(self.imageLeft or nil) |
− | .wikitext(self.imageLeft)
| |
| elseif self.imageEmptyCell then | | elseif self.imageEmptyCell then |
− | -- Some message boxes define an empty cell if no image is specified, and some don't. | + | -- Some message boxes define an empty cell if no image is specified, and |
− | -- The old template code in templates where empty cells are specified gives the following hint:
| + | -- some don't. The old template code in templates where empty cells are |
− | -- "No image. Cell with some width or padding necessary for text cell to have 100% width."
| + | -- specified gives the following hint: "No image. Cell with some width |
− | row.tag('td') | + | -- or padding necessary for text cell to have 100% width." |
− | .addClass('mbox-empty-cell') | + | row:tag('td') |
− | .cssText(self.imageEmptyCellStyle) | + | :addClass('mbox-empty-cell') |
| + | :cssText(self.imageEmptyCellStyle or nil) |
| end | | 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 self.useCollapsibleTextFields then |
− | -- The message box uses advanced text parameters that allow things to be collapsible. At the | + | -- The message box uses advanced text parameters that allow things to be |
− | -- moment, only ambox uses this.
| + | -- collapsible. At the moment, only ambox uses this. |
− | textCell | + | textCell:cssText(self.textstyle or nil) |
− | .cssText(self.textstyle)
| + | local textCellSpan = textCell:tag('span') |
− | local textCellSpan = textCell.tag('span') | |
| textCellSpan | | textCellSpan |
− | .addClass('mbox-text-span') | + | :addClass('mbox-text-span') |
− | .wikitext(self.issue) | + | :wikitext(self.issue or nil) |
| if not self.isSmall then | | if not self.isSmall then |
− | textCellSpan | + | textCellSpan:tag('span') |
− | .tag('span')
| + | :addClass('hide-when-compact') |
− | .addClass('hide-when-compact')
| + | :wikitext(self.talk and (' ' .. self.talk) or nil) |
− | .wikitext(self.talk and ' ' .. self.talk)
| + | :wikitext(self.fix and (' ' .. self.fix) or nil) |
− | .wikitext(self.fix and ' ' .. self.fix)
| |
| end | | end |
− | textCellSpan | + | textCellSpan:wikitext(self.date and (' ' .. self.date) or nil) |
− | .wikitext(self.date and ' ' .. self.date)
| |
| if not self.isSmall then | | if not self.isSmall then |
| textCellSpan | | textCellSpan |
− | .tag('span') | + | :tag('span') |
− | .addClass('hide-when-compact') | + | :addClass('hide-when-compact') |
− | .wikitext(self.info and ' ' .. self.info) | + | :wikitext(self.info and (' ' .. self.info) or nil) |
| end | | end |
| else | | else |
| -- Default text formatting - anything goes. | | -- Default text formatting - anything goes. |
| textCell | | textCell |
− | .cssText(self.textstyle) | + | :cssText(self.textstyle or nil) |
− | .wikitext(self.text) | + | :wikitext(self.text or nil) |
| end | | end |
| | | |
| -- Add the right-hand image. | | -- Add the right-hand image. |
| if self.imageRight then | | if self.imageRight then |
− | local imageRightCell = row.tag('td').addClass('mbox-imageright') | + | local imageRightCell = row:tag('td'):addClass('mbox-imageright') |
| if self.imageCellDiv then | | if self.imageCellDiv then |
− | imageRightCell = imageRightCell.tag('div').css('width', '52px') -- If we are using a div, redefine imageRightCell so that the image is inside it. | + | -- If we are using a div, redefine imageRightCell so that the image |
| + | -- is inside it. |
| + | imageRightCell = imageRightCell:tag('div'):css('width', '52px') |
| end | | end |
| imageRightCell | | imageRightCell |
− | .wikitext(self.imageRight) | + | :wikitext(self.imageRight or nil) |
| end | | end |
| | | |
| -- Add the below row. | | -- Add the below row. |
| if self.below then | | if self.below then |
− | boxTable.tag('tr') | + | boxTable:tag('tr') |
− | .tag('td') | + | :tag('td') |
− | .attr('colspan', self.imageRight and '3' or '2') | + | :attr('colspan', self.imageRight and '3' or '2') |
− | .addClass('mbox-text') | + | :addClass('mbox-text') |
− | .cssText(self.textstyle) | + | :cssText(self.textstyle or nil) |
− | .wikitext(self.below) | + | :wikitext(self.below or nil) |
| end | | end |
| | | |
| -- Add error message for invalid type parameters. | | -- Add error message for invalid type parameters. |
| if self.invalidTypeError then | | if self.invalidTypeError then |
− | root | + | root:tag('div') |
− | .tag('div')
| + | :css('text-align', 'center') |
− | .css('text-align', 'center')
| + | :wikitext(string.format( |
− | .wikitext(format('This message box is using an invalid "type=%s" parameter and needs fixing.', self.type or ''))
| + | 'This message box is using an invalid "type=%s" parameter and needs fixing.', |
| + | self.type or '' |
| + | )) |
| end | | end |
| | | |
| -- Add categories. | | -- Add categories. |
− | root | + | root:wikitext(self:renderCategories() or nil) |
− | .wikitext(self.categories)
| |
| | | |
| return tostring(root) | | return tostring(root) |
| end | | end |
| | | |
− | local function main(boxType, args) | + | -------------------------------------------------------------------------------- |
− | local outputBox = box.new() | + | -- Exports |
− | outputBox:setTitle(args) | + | -------------------------------------------------------------------------------- |
− | local cfg = outputBox:getConfig(boxType) | + | |
− | args = outputBox:removeBlankArgs(cfg, args) | + | local p, mt = {}, {} |
− | outputBox:setBoxParameters(cfg, args) | + | |
− | return outputBox:export() | + | function p._exportClasses() |
| + | -- For testing. |
| + | return { |
| + | MessageBox = MessageBox |
| + | } |
| + | end |
| + | |
| + | function p.main(boxType, args, cfgTables) |
| + | local box = MessageBox.new(boxType, args, cfgTables or mw.loadData('Module:Message box/configuration')) |
| + | box:setParameters() |
| + | box:setCategories() |
| + | return box:export() |
| end | | end |
| | | |
− | local function makeWrapper(boxType)
| + | function mt.__index(t, k) |
| return function (frame) | | return function (frame) |
− | local args = getArgs(frame, {trim = false, removeBlanks = false}) | + | if not getArgs then |
− | return main(boxType, args)
| + | getArgs = require('Module:Arguments').getArgs |
| + | end |
| + | return t.main(k, getArgs(frame, {trim = false, removeBlanks = false})) |
| end | | end |
| end | | end |
| | | |
− | local p = {
| + | return setmetatable(p, mt) |
− | main = main,
| |
− | mbox = makeWrapper('mbox')
| |
− | }
| |
− | | |
− | for boxType in pairs(cfgTables) do
| |
− | p[boxType] = makeWrapper(boxType)
| |
− | end
| |
− | | |
− | return p
| |