Latest revision |
Your text |
Line 4: |
Line 4: |
| -- Initialise necessary modules. | | -- Initialise necessary modules. |
| require('Module:No globals') | | require('Module:No globals') |
− | local makeFileLink = require('Module:File link')._main | + | local class = require('Module:Middleclass').class |
− | local effectiveProtectionLevel = require('Module:Effective protection level')._main | + | local mArguments = require('Module:Arguments') |
− | local effectiveProtectionExpiry = require('Module:Effective protection expiry')._main | + | local mFileLink = require('Module:File link') |
| + | local mProtectionLevel = require('Module:Effective protection level') |
| local yesno = require('Module:Yesno') | | local yesno = require('Module:Yesno') |
− |
| |
− | -- Lazily initialise modules and objects we don't always need.
| |
− | local getArgs, makeMessageBox, lang
| |
− |
| |
− | -- Set constants.
| |
− | local CONFIG_MODULE = 'Module:Protection banner/config'
| |
| | | |
| -------------------------------------------------------------------------------- | | -------------------------------------------------------------------------------- |
− | -- Helper functions | + | -- ProtectionStatus class |
| -------------------------------------------------------------------------------- | | -------------------------------------------------------------------------------- |
| | | |
− | local function makeCategoryLink(cat, sort) | + | local ProtectionStatus = class('ProtectionStatus') |
− | if cat then | + | |
− | return string.format( | + | function ProtectionStatus:initialize(args, titleObj) |
− | '[[%s:%s|%s]]', | + | -- Set action |
− | mw.site.namespaces[14].name, | + | do |
− | cat,
| + | local actions = { |
− | sort | + | create = true, |
− | ) | + | edit = true, |
| + | move = true, |
| + | autoreview = true |
| + | } |
| + | if args.action and actions[args.action] then |
| + | self._action = args.action |
| + | else |
| + | self._action = 'edit' |
| + | end |
| end | | end |
− | end
| |
| | | |
− | -- Validation function for the expiry and the protection date | + | -- Set level |
− | local function validateDate(dateString, dateType)
| + | do |
− | if not lang then | + | local level = mProtectionLevel._main(self._action, titleObj) |
− | lang = mw.language.getContentLanguage() | + | if level == 'accountcreator' then |
− | end
| + | -- Lump titleblacklisted pages in with template-protected pages, |
− | local success, result = pcall(lang.formatDate, lang, 'U', dateString)
| + | -- since templateeditors can do both. |
− | if success then
| + | level = 'templateeditor' |
− | result = tonumber(result)
| |
− | if result then
| |
− | return result | |
| end | | end |
| + | self._level = level or '*' |
| end | | end |
− | error(string.format( | + | |
− | 'invalid %s: %s',
| + | -- Set reason |
− | dateType,
| + | self._reason = args.reason |
− | tostring(dateString)
| + | |
− | ), 4) | + | -- Set expiry |
| + | self._expiry = args.expiry or 'indef' |
| + | end |
| + | |
| + | function ProtectionStatus:getAction() |
| + | return self._action |
| end | | end |
| | | |
− | local function makeFullUrl(page, query, display)
| + | function ProtectionStatus:getLevel() |
− | return string.format( | + | return self._level |
− | '[%s %s]',
| + | end |
− | tostring(mw.uri.fullUrl(page, query)),
| + | |
− | display
| + | function ProtectionStatus:getReason() |
− | ) | + | return self._reason |
| end | | end |
| | | |
− | -- Given a directed graph formatted as node -> table of direct successors,
| + | function ProtectionStatus:getExpiry() |
− | -- get a table of all nodes reachable from a given node (though always
| + | return self._expiry |
− | -- including the given node).
| |
− | local function getReachableNodes(graph, start)
| |
− | local toWalk, retval = {[start] = true}, {} | |
− | while true do
| |
− | -- Can't use pairs() since we're adding and removing things as we're iterating
| |
− | local k = next(toWalk) -- This always gets the "first" key
| |
− | if k == nil then
| |
− | return retval
| |
− | end
| |
− | toWalk[k] = nil
| |
− | retval[k] = true
| |
− | for _,v in ipairs(graph[k]) do
| |
− | if not retval[v] then
| |
− | toWalk[v] = true
| |
− | end
| |
− | end
| |
− | end
| |
| end | | end |
| | | |
| -------------------------------------------------------------------------------- | | -------------------------------------------------------------------------------- |
− | -- Protection class | + | -- Config class |
| -------------------------------------------------------------------------------- | | -------------------------------------------------------------------------------- |
| | | |
− | local Protection = {} | + | local Config = class('Config') |
− | Protection.__index = Protection
| |
| | | |
− | Protection.supportedActions = {
| + | function Config:initialize() |
− | edit = true, | + | self._cfg = mw.loadData('Module:Protection banner/config') |
− | move = true,
| + | end |
− | autoreview = true,
| |
− | upload = true
| |
− | }
| |
| | | |
− | Protection.bannerConfigFields = {
| + | function Config:getBannerConfig(protectionStatusObj) |
− | 'text',
| + | local cfg = self._cfg |
− | 'explanation',
| + | local action = protectionStatusObj:getAction() |
− | 'tooltip',
| + | local reason = protectionStatusObj:getReason() |
− | 'alt',
| + | if cfg.banners[action][reason] then |
− | 'link',
| + | return cfg.banners[action][reason] |
− | 'image'
| |
− | }
| |
− | | |
− | function Protection.new(args, cfg, title) | |
− | local obj = {} | |
− | obj._cfg = cfg
| |
− | obj.title = title or mw.title.getCurrentTitle() | |
− | | |
− | -- Set action | |
− | if not args.action then | |
− | obj.action = 'edit' | |
− | elseif Protection.supportedActions[args.action] then
| |
− | obj.action = args.action
| |
| else | | else |
− | error(string.format( | + | return cfg.defaultBanners[action] |
− | 'invalid action: %s',
| |
− | tostring(args.action)
| |
− | ), 3)
| |
| end | | end |
| + | end |
| | | |
− | -- Set level | + | function Config:getConfigTable(key) |
− | obj.level = args.demolevel or effectiveProtectionLevel(obj.action, obj.title)
| + | local blacklist = { |
− | if not obj.level or (obj.action == 'move' and obj.level == 'autoconfirmed') then | + | banners = true, |
− | -- Users need to be autoconfirmed to move pages anyway, so treat | + | defaultBanners = true |
− | -- semi-move-protected pages as unprotected.
| + | } |
− | obj.level = '*' | + | if not blacklist[key] then |
| + | return self._cfg[key] |
| + | else |
| + | return nil |
| end | | end |
| + | end |
| | | |
− | -- Set expiry
| + | -------------------------------------------------------------------------------- |
− | local effectiveExpiry = effectiveProtectionExpiry(obj.action, obj.title)
| + | -- Image class |
− | if effectiveExpiry == 'infinity' then
| + | -------------------------------------------------------------------------------- |
− | obj.expiry = 'indef'
| |
− | elseif effectiveExpiry ~= 'unknown' then
| |
− | obj.expiry = validateDate(effectiveExpiry, 'expiry date')
| |
− | end
| |
| | | |
− | -- Set reason
| + | local Image = class('Image') |
− | if args[1] then
| |
− | obj.reason = mw.ustring.lower(args[1])
| |
− | if obj.reason:find('|') then
| |
− | error('reasons cannot contain the pipe character ("|")', 3)
| |
− | end
| |
− | end
| |
| | | |
− | -- Set protection date
| + | function Image:setFilename(filename, configObj, protectionStatusObj, namespace) |
− | if args.date then | + | if filename then |
− | obj.protectionDate = validateDate(args.date, 'protection date') | + | self._filename = filename |
− | end
| + | else |
− |
| + | local images = configObj:getConfigTable('images') |
− | -- Set banner config
| + | local action = protectionStatusObj:getAction() |
− | do
| + | local level = protectionStatusObj:getLevel() |
− | obj.bannerConfig = {} | + | local reason = protectionStatusObj:getReason() |
− | local configTables = {} | + | local image |
− | if cfg.banners[obj.action] then | + | if reason == 'office' or reason == 'reset' then |
− | configTables[#configTables + 1] = cfg.banners[obj.action][obj.reason] | + | image = images.office |
− | end
| + | elseif namespace == 10 or namespace == 828 then |
− | if cfg.defaultBanners[obj.action] then | + | -- We are in the template or module namespaces. |
− | configTables[#configTables + 1] = cfg.defaultBanners[obj.action][obj.level] | + | if level == 'templateeditor' then |
− | configTables[#configTables + 1] = cfg.defaultBanners[obj.action].default | + | image = images.template |
− | end
| + | elseif level == 'sysop' then |
− | configTables[#configTables + 1] = cfg.masterBanner
| + | image = images.indef |
− | for i, field in ipairs(Protection.bannerConfigFields) do | + | end |
− | for j, t in ipairs(configTables) do | + | elseif action == 'create' then |
− | if t[field] then
| + | image = images.create |
− | obj.bannerConfig[field] = t[field]
| + | elseif action == 'move' |
− | break
| + | and ( |
− | end | + | level == 'templateeditor' |
| + | or level == 'sysop' |
| + | ) |
| + | then |
| + | image = images.move |
| + | elseif action == 'edit' then |
| + | if level == 'sysop' then |
| + | image = images.full |
| + | elseif level == 'autoconfirmed' then |
| + | image = images.semi |
| + | end |
| + | elseif action == 'autoreview' then |
| + | if level == 'autoconfirmed' then |
| + | image = images.pc1 |
| + | elseif level == 'reviewer' then |
| + | image = images.pc2 |
| end | | end |
| + | else |
| + | image = 'Transparent.gif' |
| end | | end |
| + | self._filename = image |
| end | | end |
− | return setmetatable(obj, Protection)
| |
| end | | end |
| | | |
− | function Protection:isProtected() | + | function Image:export() |
− | return self.level ~= '*' | + | return mFileLink.new(self._filename) |
| + | :width(self._size) |
| + | :alt(self._alt) |
| + | :caption(self._caption) |
| + | :render() |
| + | end |
| + | |
| + | -------------------------------------------------------------------------------- |
| + | -- Blurb class |
| + | -------------------------------------------------------------------------------- |
| + | |
| + | local Blurb = class('Blurb') |
| + | |
| + | function Blurb:initialize(bannerConfig) |
| + | self._config = bannerConfig |
| + | end |
| + | |
| + | -------------------------------------------------------------------------------- |
| + | -- BannerTemplate class |
| + | -------------------------------------------------------------------------------- |
| + | |
| + | local BannerTemplate = class('BannerTemplate') |
| + | |
| + | function BannerTemplate:initialize() |
| end | | end |
| | | |
− | function Protection:isTemporary() | + | function BannerTemplate:render() |
− | return type(self.expiry) == 'number'
| |
| end | | end |
| | | |
− | function Protection:makeProtectionCategory()
| + | -------------------------------------------------------------------------------- |
− | local cfg = self._cfg
| + | -- Banner class |
− | local title = self.title
| + | -------------------------------------------------------------------------------- |
− |
| + | |
− | -- Exit if the page is not protected. | + | local Banner = BannerTemplate:subclass('Banner') |
− | if not self:isProtected() then
| + | |
| + | -------------------------------------------------------------------------------- |
| + | -- Padlock class |
| + | -------------------------------------------------------------------------------- |
| + | |
| + | local Padlock = BannerTemplate:subclass('Padlock') |
| + | |
| + | -------------------------------------------------------------------------------- |
| + | -- Category class |
| + | -------------------------------------------------------------------------------- |
| + | |
| + | local Category = class('Category') |
| + | |
| + | function Category:initialize() |
| + | end |
| + | |
| + | function Category:setName(name) |
| + | self._name = name |
| + | end |
| + | |
| + | function Category:export() |
| + | if self._categoryName then |
| + | return string.format( |
| + | '[[%s:%s]]', |
| + | mw.site.namespaces[14].name, |
| + | self._categoryName |
| + | ) |
| + | else |
| return '' | | return '' |
| end | | end |
| + | end |
| + | |
| + | -------------------------------------------------------------------------------- |
| + | -- ProtectionCategory class |
| + | -------------------------------------------------------------------------------- |
| + | |
| + | local ProtectionCategory = Category:subclass('ProtectionCategory') |
| + | |
| + | function ProtectionCategory:setName(name, configObj, protectionStatusObj, namespace) |
| + | --[[ |
| + | -- Sets the protection category. If a category name is not provided, this |
| + | -- method gets a category name from the module config, given a combination |
| + | -- of the protection type, the protection level, the namespace number, the |
| + | -- reason for protection, and the expiry date. |
| + | --]] |
| + | local cats = configObj:getConfigTable('categories') |
| | | |
− | -- Get the expiry key fragment. | + | -- Get the namespace category key from the namespace number. |
− | local expiryFragment | + | local nskey |
− | if self.expiry == 'indef' then | + | do |
− | expiryFragment = self.expiry | + | local categoryNamespaces = configObj:getConfigTable('categoryNamespaces') |
− | elseif type(self.expiry) == 'number' then
| + | if not namespace or type(namespace) ~= 'number' then |
− | expiryFragment = 'temp'
| + | nskey = nil |
− | end
| + | else |
− | | + | nskey = categoryNamespaces[ns] |
− | -- Get the namespace key fragment.
| + | if not nskey and ns % 2 == 1 then |
− | local namespaceFragment = cfg.categoryNamespaceKeys[title.namespace]
| + | nskey = 'talk' |
− | if not namespaceFragment and title.namespace % 2 == 1 then
| + | end |
− | namespaceFragment = 'talk'
| + | end |
| end | | end |
| | | |
− | -- Define the order that key fragments are tested in. This is done with an
| |
− | -- array of tables containing the value to be tested, along with its
| |
− | -- position in the cfg.protectionCategories table.
| |
− | local order = {
| |
− | {val = expiryFragment, keypos = 1},
| |
− | {val = namespaceFragment, keypos = 2},
| |
− | {val = self.reason, keypos = 3},
| |
− | {val = self.level, keypos = 4},
| |
− | {val = self.action, keypos = 5}
| |
− | }
| |
− |
| |
| --[[ | | --[[ |
− | -- The old protection templates used an ad-hoc protection category system, | + | -- Define the properties table. Each property is a table containing the |
− | -- with some templates prioritising namespaces in their categories, and
| + | -- canonical order that the property is tested in, the position the |
− | -- others prioritising the protection reason. To emulate this in this module
| + | -- property has in the category key strings, and the property value itself. |
− | -- we use the config table cfg.reasonsWithNamespacePriority to set the
| |
− | -- reasons for which namespaces have priority over protection reason. | |
− | -- If we are dealing with one of those reasons, move the namespace table to
| |
− | -- the end of the order table, i.e. give it highest priority. If not, the | |
− | -- reason should have highest priority, so move that to the end of the table
| |
− | -- instead.
| |
| --]] | | --]] |
− | table.insert(order, table.remove(order, self.reason and cfg.reasonsWithNamespacePriority[self.reason] and 2 or 3)) | + | local properties = { |
| + | expiry = {order = 1, keypos = 5, val = expiry}, |
| + | namespace = {order = 2, keypos = 3, val = nskey}, |
| + | reason = {order = 3, keypos = 4, val = reason}, |
| + | level = {order = 4, keypos = 2, val = level}, |
| + | action = {order = 5, keypos = 1, val = action} |
| + | } |
| | | |
| --[[ | | --[[ |
− | -- Define the attempt order. Inactive subtables (subtables with nil "value" | + | -- Load the category order configuration for the reason specified. |
− | -- fields) are moved to the end, where they will later be given the key | + | -- The configuration is stored in the categoryOrder field of each reason |
− | -- "all". This is to cut down on the number of table lookups in | + | -- subtable of cfg.reasons. If the value is a table, then the order is the |
− | -- cfg.protectionCategories, which grows exponentially with the number of | + | -- values specified in the table. If the value is a string, then the |
− | -- non-nil keys. We keep track of the number of active subtables with the | + | -- property corresponding to that string is tested last (i.e. it is the most |
− | -- noActive parameter. | + | -- important, because it keeps its specified value the longest) and the |
| + | -- other properties are tested in the canonical order. If the value is of |
| + | -- any other type then the canonical order is used. |
| --]] | | --]] |
− | local noActive, attemptOrder | + | local reasonTable = reason and cfg.reasons[reason] |
− | do | + | local categoryOrder = reasonTable and reasonTable.categoryOrder |
− | local active, inactive = {}, {}
| + | local categoryOrderType = type(categoryOrder) |
− | for i, t in ipairs(order) do | + | local configOrder = {} |
− | if t.val then | + | if categoryOrderType == 'table' then |
− | active[#active + 1] = t | + | local dupes = {} |
| + | for i = 1, 5 do |
| + | local propertiesKey = categoryOrder[i] |
| + | if not propertiesKey then |
| + | local msg = 'no entry found for key ' |
| + | .. i |
| + | .. ' in the cfg.reasons.' |
| + | .. reason |
| + | .. '.categoryOrder table' |
| + | error(msg) |
| + | end |
| + | local property = properties[propertiesKey] |
| + | if not property then |
| + | local msg = 'invalid value "' |
| + | .. propertiesKey |
| + | .. '" detected in the cfg.reasons.' |
| + | .. reason |
| + | .. '.categoryOrder table' |
| + | error(msg) |
| + | end |
| + | if dupes[propertiesKey] then |
| + | local msg = 'duplicate values "' |
| + | .. propertiesKey |
| + | .. '" detected in the cfg.reasons.' |
| + | .. reason |
| + | .. '.categoryOrder table' |
| + | error(msg) |
| else | | else |
− | inactive[#inactive + 1] = t | + | dupes[propertiesKey] = true |
| + | end |
| + | configOrder[i] = property |
| + | end |
| + | else |
| + | for propertiesKey, t in pairs(properties) do |
| + | configOrder[t.order] = t |
| + | end |
| + | if categoryOrderType == 'string' then |
| + | local property = properties[categoryOrder] |
| + | if not property then |
| + | local msg = '"' |
| + | .. categoryOrder |
| + | .. '" is not a valid value of cfg.reasons.' |
| + | .. reason |
| + | .. '.categoryOrder' |
| + | error(msg) |
| end | | end |
| + | toTableEnd(configOrder, property.order) |
| end | | end |
− | noActive = #active
| + | end |
− | attemptOrder = active
| + | |
− | for i, t in ipairs(inactive) do
| + | --[[ |
− | attemptOrder[#attemptOrder + 1] = t | + | -- Define the attempt order. Properties with no value defined are moved |
| + | -- to the end, where they will later be given the value "all". This is |
| + | -- to cut down on the number of table lookups in the cats table, which |
| + | -- grows exponentially with the number of properties with valid values. |
| + | -- We keep track of the number of active properties with the noActive |
| + | -- parameter. |
| + | --]] |
| + | local active, inactive = {}, {} |
| + | for i, t in ipairs(configOrder) do |
| + | if t.val then |
| + | active[#active + 1] = t |
| + | else |
| + | inactive[#inactive + 1] = t |
| end | | end |
| + | end |
| + | local noActive = #active |
| + | local attemptOrder = active |
| + | for i, t in ipairs(inactive) do |
| + | attemptOrder[#attemptOrder + 1] = t |
| end | | end |
| | | |
| --[[ | | --[[ |
− | -- Check increasingly generic key combinations until we find a match. If a | + | -- Check increasingly generic key combinations until we find a match. |
− | -- specific category exists for the combination of key fragments we are | + | -- If a specific category exists for the combination of properties |
− | -- given, that match will be found first. If not, we keep trying different | + | -- we are given, that match will be found first. If not, we keep |
− | -- key fragment combinations until we match using the key | + | -- trying different key combinations until we match using the key |
| -- "all-all-all-all-all". | | -- "all-all-all-all-all". |
| -- | | -- |
− | -- To generate the keys, we index the key subtables using a binary matrix | + | -- To generate the keys, we index the property subtables using a |
− | -- with indexes i and j. j is only calculated up to the number of active | + | -- binary matrix with indexes i and j. j is only calculated up to |
− | -- subtables. For example, if there were three active subtables, the matrix
| + | -- the number of active properties. For example, if there were three |
− | -- would look like this, with 0 corresponding to the key fragment "all", and
| + | -- active properties, the matrix would look like this, with 0 |
− | -- 1 corresponding to other key fragments. | + | -- corresponding to the string "all", and 1 corresponding to the |
| + | -- val field in the property table: |
| -- | | -- |
| -- j 1 2 3 | | -- j 1 2 3 |
Line 275: |
Line 372: |
| -- 8 0 0 0 | | -- 8 0 0 0 |
| -- | | -- |
− | -- Values of j higher than the number of active subtables are set | + | -- Values of j higher than the number of active properties are set |
| -- to the string "all". | | -- to the string "all". |
| -- | | -- |
− | -- A key for cfg.protectionCategories is constructed for each value of i. | + | -- A key for the category table is constructed for each value of i. |
− | -- The position of the value in the key is determined by the keypos field in | + | -- The correct position of the value in the key is determined by the |
− | -- each subtable. | + | -- pos field in the property table. |
| --]] | | --]] |
− | local cats = cfg.protectionCategories
| |
| for i = 1, 2^noActive do | | for i = 1, 2^noActive do |
| local key = {} | | local key = {} |
Line 298: |
Line 394: |
| end | | end |
| end | | end |
− | key = table.concat(key, '|') | + | key = table.concat(key, '-') |
| local attempt = cats[key] | | local attempt = cats[key] |
| if attempt then | | if attempt then |
− | return makeCategoryLink(attempt, title.text) | + | return attempt |
| end | | end |
| end | | end |
− | return '' | + | error( |
− | end
| + | 'No category match found;' |
− | | + | .. ' please define the category for key "all-all-all-all-all"' |
− | function Protection:isIncorrect()
| + | ) |
− | local expiry = self.expiry
| |
− | return not self:isProtected()
| |
− | or type(expiry) == 'number' and expiry < os.time() | |
− | end
| |
− | | |
− | function Protection:isTemplateProtectedNonTemplate()
| |
− | local action, namespace = self.action, self.title.namespace
| |
− | return self.level == 'templateeditor'
| |
− | and ( | |
− | (action ~= 'edit' and action ~= 'move')
| |
− | or (namespace ~= 10 and namespace ~= 828)
| |
− | )
| |
− | end
| |
− | | |
− | function Protection:makeCategoryLinks()
| |
− | local msg = self._cfg.msg
| |
− | local ret = { self:makeProtectionCategory() }
| |
− | if self:isIncorrect() then
| |
− | ret[#ret + 1] = makeCategoryLink(
| |
− | msg['tracking-category-incorrect'],
| |
− | self.title.text
| |
− | )
| |
− | end
| |
− | if self:isTemplateProtectedNonTemplate() then
| |
− | ret[#ret + 1] = makeCategoryLink(
| |
− | msg['tracking-category-template'],
| |
− | self.title.text
| |
− | )
| |
− | end | |
− | return table.concat(ret)
| |
| end | | end |
| | | |
| -------------------------------------------------------------------------------- | | -------------------------------------------------------------------------------- |
− | -- Blurb class | + | -- ErrorCategory class |
| -------------------------------------------------------------------------------- | | -------------------------------------------------------------------------------- |
| | | |
− | local Blurb = {} | + | local ErrorCategory = Category:subclass('ErrorCategory') |
− | Blurb.__index = Blurb
| |
− | | |
− | Blurb.bannerTextFields = {
| |
− | text = true,
| |
− | explanation = true,
| |
− | tooltip = true,
| |
− | alt = true,
| |
− | link = true
| |
− | }
| |
− | | |
− | function Blurb.new(protectionObj, args, cfg)
| |
− | return setmetatable({
| |
− | _cfg = cfg,
| |
− | _protectionObj = protectionObj,
| |
− | _args = args
| |
− | }, Blurb)
| |
− | end
| |
− | | |
− | -- Private methods --
| |
− | | |
− | function Blurb:_formatDate(num)
| |
− | -- Formats a Unix timestamp into dd Month, YYYY format.
| |
− | lang = lang or mw.language.getContentLanguage()
| |
− | local success, date = pcall(
| |
− | lang.formatDate,
| |
− | lang,
| |
− | self._cfg.msg['expiry-date-format'] or 'j F Y',
| |
− | '@' .. tostring(num)
| |
− | )
| |
− | if success then
| |
− | return date
| |
− | end
| |
− | end
| |
− | | |
− | function Blurb:_getExpandedMessage(msgKey)
| |
− | return self:_substituteParameters(self._cfg.msg[msgKey])
| |
− | end
| |
− | | |
− | function Blurb:_substituteParameters(msg)
| |
− | if not self._params then
| |
− | local parameterFuncs = {}
| |
− | | |
− | parameterFuncs.CURRENTVERSION = self._makeCurrentVersionParameter
| |
− | parameterFuncs.EDITREQUEST = self._makeEditRequestParameter
| |
− | parameterFuncs.EXPIRY = self._makeExpiryParameter
| |
− | parameterFuncs.EXPLANATIONBLURB = self._makeExplanationBlurbParameter
| |
− | parameterFuncs.IMAGELINK = self._makeImageLinkParameter
| |
− | parameterFuncs.INTROBLURB = self._makeIntroBlurbParameter
| |
− | parameterFuncs.INTROFRAGMENT = self._makeIntroFragmentParameter
| |
− | parameterFuncs.PAGETYPE = self._makePagetypeParameter
| |
− | parameterFuncs.PROTECTIONBLURB = self._makeProtectionBlurbParameter
| |
− | parameterFuncs.PROTECTIONDATE = self._makeProtectionDateParameter
| |
− | parameterFuncs.PROTECTIONLEVEL = self._makeProtectionLevelParameter
| |
− | parameterFuncs.PROTECTIONLOG = self._makeProtectionLogParameter
| |
− | parameterFuncs.TALKPAGE = self._makeTalkPageParameter
| |
− | parameterFuncs.TOOLTIPBLURB = self._makeTooltipBlurbParameter
| |
− | parameterFuncs.TOOLTIPFRAGMENT = self._makeTooltipFragmentParameter
| |
− | parameterFuncs.VANDAL = self._makeVandalTemplateParameter
| |
− |
| |
− | self._params = setmetatable({}, {
| |
− | __index = function (t, k)
| |
− | local param
| |
− | if parameterFuncs[k] then
| |
− | param = parameterFuncs[k](self)
| |
− | end
| |
− | param = param or ''
| |
− | t[k] = param
| |
− | return param
| |
− | end
| |
− | })
| |
− | end
| |
− |
| |
− | msg = msg:gsub('${(%u+)}', self._params)
| |
− | return msg
| |
− | end
| |
− | | |
− | function Blurb:_makeCurrentVersionParameter()
| |
− | -- A link to the page history or the move log, depending on the kind of
| |
− | -- protection.
| |
− | local pagename = self._protectionObj.title.prefixedText
| |
− | if self._protectionObj.action == 'move' then
| |
− | -- We need the move log link.
| |
− | return makeFullUrl(
| |
− | 'Special:Log',
| |
− | {type = 'move', page = pagename},
| |
− | self:_getExpandedMessage('current-version-move-display')
| |
− | )
| |
− | else
| |
− | -- We need the history link.
| |
− | return makeFullUrl(
| |
− | pagename,
| |
− | {action = 'history'},
| |
− | self:_getExpandedMessage('current-version-edit-display')
| |
− | )
| |
− | end
| |
− | end
| |
− | | |
− | function Blurb:_makeEditRequestParameter()
| |
− | local mEditRequest = require('Module:Submit an edit request')
| |
− | local action = self._protectionObj.action
| |
− | local level = self._protectionObj.level
| |
− |
| |
− | -- Get the edit request type.
| |
− | local requestType
| |
− | if action == 'edit' then
| |
− | if level == 'autoconfirmed' then
| |
− | requestType = 'semi'
| |
− | elseif level == 'extendedconfirmed' then
| |
− | requestType = 'extended'
| |
− | elseif level == 'templateeditor' then
| |
− | requestType = 'template'
| |
− | end
| |
− | end
| |
− | requestType = requestType or 'full'
| |
− |
| |
− | -- Get the display value.
| |
− | local display = self:_getExpandedMessage('edit-request-display')
| |
− | | |
− | return mEditRequest._link{type = requestType, display = display}
| |
− | end
| |
− | | |
− | function Blurb:_makeExpiryParameter()
| |
− | local expiry = self._protectionObj.expiry
| |
− | if type(expiry) == 'number' then
| |
− | return self:_formatDate(expiry)
| |
− | else
| |
− | return expiry
| |
− | end
| |
− | end
| |
− | | |
− | function Blurb:_makeExplanationBlurbParameter()
| |
− | -- Cover special cases first.
| |
− | if self._protectionObj.title.namespace == 8 then
| |
− | -- MediaWiki namespace
| |
− | return self:_getExpandedMessage('explanation-blurb-nounprotect')
| |
− | end
| |
− | | |
− | -- Get explanation blurb table keys
| |
− | local action = self._protectionObj.action
| |
− | local level = self._protectionObj.level
| |
− | local talkKey = self._protectionObj.title.isTalkPage and 'talk' or 'subject'
| |
− | | |
− | -- Find the message in the explanation blurb table and substitute any
| |
− | -- parameters.
| |
− | local explanations = self._cfg.explanationBlurbs
| |
− | local msg
| |
− | if explanations[action][level] and explanations[action][level][talkKey] then
| |
− | msg = explanations[action][level][talkKey]
| |
− | elseif explanations[action][level] and explanations[action][level].default then
| |
− | msg = explanations[action][level].default
| |
− | elseif explanations[action].default and explanations[action].default[talkKey] then
| |
− | msg = explanations[action].default[talkKey]
| |
− | elseif explanations[action].default and explanations[action].default.default then
| |
− | msg = explanations[action].default.default
| |
− | else
| |
− | error(string.format(
| |
− | 'could not find explanation blurb for action "%s", level "%s" and talk key "%s"',
| |
− | action,
| |
− | level,
| |
− | talkKey
| |
− | ), 8)
| |
− | end
| |
− | return self:_substituteParameters(msg)
| |
− | end
| |
− | | |
− | function Blurb:_makeImageLinkParameter()
| |
− | local imageLinks = self._cfg.imageLinks
| |
− | local action = self._protectionObj.action
| |
− | local level = self._protectionObj.level
| |
− | local msg
| |
− | if imageLinks[action][level] then
| |
− | msg = imageLinks[action][level]
| |
− | elseif imageLinks[action].default then
| |
− | msg = imageLinks[action].default
| |
− | else
| |
− | msg = imageLinks.edit.default
| |
− | end
| |
− | return self:_substituteParameters(msg)
| |
− | end
| |
− | | |
− | function Blurb:_makeIntroBlurbParameter()
| |
− | if self._protectionObj:isTemporary() then
| |
− | return self:_getExpandedMessage('intro-blurb-expiry')
| |
− | else
| |
− | return self:_getExpandedMessage('intro-blurb-noexpiry')
| |
− | end
| |
− | end
| |
− | | |
− | function Blurb:_makeIntroFragmentParameter()
| |
− | if self._protectionObj:isTemporary() then
| |
− | return self:_getExpandedMessage('intro-fragment-expiry')
| |
− | else
| |
− | return self:_getExpandedMessage('intro-fragment-noexpiry')
| |
− | end
| |
− | end
| |
− | | |
− | function Blurb:_makePagetypeParameter()
| |
− | local pagetypes = self._cfg.pagetypes
| |
− | return pagetypes[self._protectionObj.title.namespace]
| |
− | or pagetypes.default
| |
− | or error('no default pagetype defined', 8)
| |
− | end
| |
− | | |
− | function Blurb:_makeProtectionBlurbParameter()
| |
− | local protectionBlurbs = self._cfg.protectionBlurbs
| |
− | local action = self._protectionObj.action
| |
− | local level = self._protectionObj.level
| |
− | local msg
| |
− | if protectionBlurbs[action][level] then
| |
− | msg = protectionBlurbs[action][level]
| |
− | elseif protectionBlurbs[action].default then
| |
− | msg = protectionBlurbs[action].default
| |
− | elseif protectionBlurbs.edit.default then
| |
− | msg = protectionBlurbs.edit.default
| |
− | else
| |
− | error('no protection blurb defined for protectionBlurbs.edit.default', 8)
| |
− | end
| |
− | return self:_substituteParameters(msg)
| |
− | end
| |
− | | |
− | function Blurb:_makeProtectionDateParameter()
| |
− | local protectionDate = self._protectionObj.protectionDate
| |
− | if type(protectionDate) == 'number' then
| |
− | return self:_formatDate(protectionDate)
| |
− | else
| |
− | return protectionDate
| |
− | end
| |
− | end
| |
− | | |
− | function Blurb:_makeProtectionLevelParameter()
| |
− | local protectionLevels = self._cfg.protectionLevels
| |
− | local action = self._protectionObj.action
| |
− | local level = self._protectionObj.level
| |
− | local msg
| |
− | if protectionLevels[action][level] then
| |
− | msg = protectionLevels[action][level]
| |
− | elseif protectionLevels[action].default then
| |
− | msg = protectionLevels[action].default
| |
− | elseif protectionLevels.edit.default then
| |
− | msg = protectionLevels.edit.default
| |
− | else
| |
− | error('no protection level defined for protectionLevels.edit.default', 8)
| |
− | end
| |
− | return self:_substituteParameters(msg)
| |
− | end
| |
− | | |
− | function Blurb:_makeProtectionLogParameter()
| |
− | local pagename = self._protectionObj.title.prefixedText
| |
− | if self._protectionObj.action == 'autoreview' then
| |
− | -- We need the pending changes log.
| |
− | return makeFullUrl(
| |
− | 'Special:Log',
| |
− | {type = 'stable', page = pagename},
| |
− | self:_getExpandedMessage('pc-log-display')
| |
− | )
| |
− | else
| |
− | -- We need the protection log.
| |
− | return makeFullUrl(
| |
− | 'Special:Log',
| |
− | {type = 'protect', page = pagename},
| |
− | self:_getExpandedMessage('protection-log-display')
| |
− | )
| |
− | end
| |
− | end
| |
− | | |
− | function Blurb:_makeTalkPageParameter()
| |
− | return string.format(
| |
− | '[[%s:%s#%s|%s]]',
| |
− | mw.site.namespaces[self._protectionObj.title.namespace].talk.name,
| |
− | self._protectionObj.title.text,
| |
− | self._args.section or 'top',
| |
− | self:_getExpandedMessage('talk-page-link-display')
| |
− | )
| |
− | end
| |
− | | |
− | function Blurb:_makeTooltipBlurbParameter()
| |
− | if self._protectionObj:isTemporary() then
| |
− | return self:_getExpandedMessage('tooltip-blurb-expiry')
| |
− | else
| |
− | return self:_getExpandedMessage('tooltip-blurb-noexpiry')
| |
− | end
| |
− | end
| |
− | | |
− | function Blurb:_makeTooltipFragmentParameter()
| |
− | if self._protectionObj:isTemporary() then
| |
− | return self:_getExpandedMessage('tooltip-fragment-expiry')
| |
− | else
| |
− | return self:_getExpandedMessage('tooltip-fragment-noexpiry')
| |
− | end
| |
− | end
| |
− | | |
− | function Blurb:_makeVandalTemplateParameter()
| |
− | return require('Module:Vandal-m')._main{
| |
− | self._args.user or self._protectionObj.title.baseText
| |
− | }
| |
− | end
| |
− | | |
− | -- Public methods --
| |
− | | |
− | function Blurb:makeBannerText(key)
| |
− | -- Validate input.
| |
− | if not key or not Blurb.bannerTextFields[key] then
| |
− | error(string.format(
| |
− | '"%s" is not a valid banner config field',
| |
− | tostring(key)
| |
− | ), 2)
| |
− | end
| |
− | | |
− | -- Generate the text.
| |
− | local msg = self._protectionObj.bannerConfig[key]
| |
− | if type(msg) == 'string' then
| |
− | return self:_substituteParameters(msg)
| |
− | elseif type(msg) == 'function' then
| |
− | msg = msg(self._protectionObj, self._args)
| |
− | if type(msg) ~= 'string' then
| |
− | error(string.format(
| |
− | 'bad output from banner config function with key "%s"'
| |
− | .. ' (expected string, got %s)',
| |
− | tostring(key),
| |
− | type(msg)
| |
− | ), 4)
| |
− | end
| |
− | return self:_substituteParameters(msg)
| |
− | end
| |
− | end
| |
| | | |
| -------------------------------------------------------------------------------- | | -------------------------------------------------------------------------------- |
− | -- BannerTemplate class | + | -- ExpiryCategory class |
| -------------------------------------------------------------------------------- | | -------------------------------------------------------------------------------- |
| | | |
− | local BannerTemplate = {} | + | local ExpiryCategory = Category:subclass('ExpiryCategory') |
− | BannerTemplate.__index = BannerTemplate
| |
− | | |
− | function BannerTemplate.new(protectionObj, cfg)
| |
− | local obj = {}
| |
− | obj._cfg = cfg
| |
− | | |
− | -- Set the image filename.
| |
− | local imageFilename = protectionObj.bannerConfig.image
| |
− | if imageFilename then
| |
− | obj._imageFilename = imageFilename
| |
− | else
| |
− | -- If an image filename isn't specified explicitly in the banner config,
| |
− | -- generate it from the protection status and the namespace.
| |
− | local action = protectionObj.action
| |
− | local level = protectionObj.level
| |
− | local namespace = protectionObj.title.namespace
| |
− | local reason = protectionObj.reason
| |
− |
| |
− | -- Deal with special cases first.
| |
− | if (
| |
− | namespace == 10
| |
− | or namespace == 828
| |
− | or reason and obj._cfg.indefImageReasons[reason]
| |
− | )
| |
− | and action == 'edit'
| |
− | and level == 'sysop'
| |
− | and not protectionObj:isTemporary()
| |
− | then
| |
− | -- Fully protected modules and templates get the special red "indef"
| |
− | -- padlock.
| |
− | obj._imageFilename = obj._cfg.msg['image-filename-indef']
| |
− | else
| |
− | -- Deal with regular protection types.
| |
− | local images = obj._cfg.images
| |
− | if images[action] then
| |
− | if images[action][level] then
| |
− | obj._imageFilename = images[action][level]
| |
− | elseif images[action].default then
| |
− | obj._imageFilename = images[action].default
| |
− | end
| |
− | end
| |
− | end
| |
− | end
| |
− | return setmetatable(obj, BannerTemplate)
| |
− | end
| |
− | | |
− | function BannerTemplate:renderImage()
| |
− | local filename = self._imageFilename
| |
− | or self._cfg.msg['image-filename-default']
| |
− | or 'Transparent.gif'
| |
− | return makeFileLink{
| |
− | file = filename,
| |
− | size = (self.imageWidth or 20) .. 'px',
| |
− | alt = self._imageAlt,
| |
− | link = self._imageLink,
| |
− | caption = self.imageCaption
| |
− | }
| |
− | end
| |
| | | |
| -------------------------------------------------------------------------------- | | -------------------------------------------------------------------------------- |
− | -- Banner class | + | -- ProtectionBanner class |
| -------------------------------------------------------------------------------- | | -------------------------------------------------------------------------------- |
| | | |
− | local Banner = setmetatable({}, BannerTemplate) | + | local ProtectionBanner = {} |
− | Banner.__index = Banner
| |
| | | |
− | function Banner.new(protectionObj, blurbObj, cfg) | + | function ProtectionBanner.exportToWiki(frame, title) |
− | local obj = BannerTemplate.new(protectionObj, cfg) -- This doesn't need the blurb. | + | local args = mArguments.getArgs(frame) |
− | obj.imageWidth = 40 | + | return ProtectionBanner.exportToLua(args, title) |
− | obj.imageCaption = blurbObj:makeBannerText('alt') -- Large banners use the alt text for the tooltip.
| |
− | obj._reasonText = blurbObj:makeBannerText('text')
| |
− | obj._explanationText = blurbObj:makeBannerText('explanation')
| |
− | obj._page = protectionObj.title.prefixedText -- Only makes a difference in testing.
| |
− | return setmetatable(obj, Banner)
| |
| end | | end |
| | | |
− | function Banner:__tostring() | + | function ProtectionBanner.exportToLua(args, title) |
− | -- Renders the banner. | + | title = title or mw.title.getCurrentTitle() |
− | makeMessageBox = makeMessageBox or require('Module:Message box').main
| + | local pstatus = ProtectionStatus.new(args, title) |
− | local reasonText = self._reasonText or error('no reason text set', 2) | + | local cfg = Config:new() |
− | local explanationText = self._explanationText | |
− | local mbargs = {
| |
− | page = self._page,
| |
− | type = 'protection',
| |
− | image = self:renderImage(),
| |
− | text = string.format(
| |
− | "'''%s'''%s",
| |
− | reasonText,
| |
− | explanationText and '<br />' .. explanationText or ''
| |
− | )
| |
− | }
| |
− | return makeMessageBox('mbox', mbargs)
| |
− | end
| |
| | | |
− | -------------------------------------------------------------------------------- | + | -- Get the banner template object |
− | -- Padlock class
| + | local banner |
− | --------------------------------------------------------------------------------
| + | do |
− | | + | local bannerClass |
− | local Padlock = setmetatable({}, BannerTemplate)
| + | if yesno(args.small) then |
− | Padlock.__index = Padlock
| + | bannerClass = Padlock |
− | | + | else |
− | function Padlock.new(protectionObj, blurbObj, cfg)
| + | bannerClass = Banner |
− | local obj = BannerTemplate.new(protectionObj, cfg) -- This doesn't need the blurb.
| + | end |
− | obj.imageWidth = 20
| + | banner = bannerClass:new() |
− | obj.imageCaption = blurbObj:makeBannerText('tooltip')
| + | end |
− | obj._imageAlt = blurbObj:makeBannerText('alt') | |
− | obj._imageLink = blurbObj:makeBannerText('link')
| |
− | obj._indicatorName = cfg.padlockIndicatorNames[protectionObj.action]
| |
− | or cfg.padlockIndicatorNames.default
| |
− | or 'pp-default'
| |
− | return setmetatable(obj, Padlock)
| |
| end | | end |
| | | |
− | function Padlock:__tostring() | + | function ProtectionBanner._exportClasses() |
− | local frame = mw.getCurrentFrame()
| |
− | -- The nowiki tag helps prevent whitespace at the top of articles.
| |
− | return frame:extensionTag{name = 'nowiki'} .. frame:extensionTag{
| |
− | name = 'indicator',
| |
− | args = {name = self._indicatorName},
| |
− | content = self:renderImage()
| |
− | }
| |
− | end
| |
− | | |
− | --------------------------------------------------------------------------------
| |
− | -- Exports
| |
− | --------------------------------------------------------------------------------
| |
− | | |
− | local p = {}
| |
− | | |
− | function p._exportClasses()
| |
− | -- This is used for testing purposes.
| |
| return { | | return { |
− | Protection = Protection, | + | ProtectionStatus = ProtectionStatus, |
| + | Config = Config, |
| + | Image = Image, |
| Blurb = Blurb, | | Blurb = Blurb, |
| BannerTemplate = BannerTemplate, | | BannerTemplate = BannerTemplate, |
| Banner = Banner, | | Banner = Banner, |
| Padlock = Padlock, | | Padlock = Padlock, |
| + | Category = Category, |
| + | ProtectionCategory = ProtectionCategory, |
| + | ErrorCategory = ErrorCategory, |
| + | ExpiryCategory = ExpiryCategory |
| } | | } |
| end | | end |
| | | |
− | function p._main(args, cfg, title)
| + | return ProtectionBanner |
− | args = args or {}
| |
− | cfg = cfg or require(CONFIG_MODULE)
| |
− | | |
− | local protectionObj = Protection.new(args, cfg, title)
| |
− | | |
− | local ret = {}
| |
− | | |
− | -- If a page's edit protection is equally or more restrictive than its
| |
− | -- protection from some other action, then don't bother displaying anything
| |
− | -- for the other action (except categories).
| |
− | if protectionObj.action == 'edit' or
| |
− | args.demolevel or
| |
− | not getReachableNodes(
| |
− | cfg.hierarchy,
| |
− | protectionObj.level
| |
− | )[effectiveProtectionLevel('edit', protectionObj.title)]
| |
− | then
| |
− | -- Initialise the blurb object
| |
− | local blurbObj = Blurb.new(protectionObj, args, cfg)
| |
− |
| |
− | -- Render the banner
| |
− | if protectionObj:isProtected() then
| |
− | ret[#ret + 1] = tostring(
| |
− | (yesno(args.small) and Padlock or Banner)
| |
− | .new(protectionObj, blurbObj, cfg)
| |
− | )
| |
− | end
| |
− | end
| |
− | | |
− | -- Render the categories
| |
− | if yesno(args.category) ~= false then
| |
− | ret[#ret + 1] = protectionObj:makeCategoryLinks()
| |
− | end
| |
− |
| |
− | return table.concat(ret)
| |
− | end
| |
− | | |
− | function p.main(frame, cfg)
| |
− | cfg = cfg or require(CONFIG_MODULE)
| |
− | | |
− | -- Find default args, if any.
| |
− | local parent = frame.getParent and frame:getParent()
| |
− | local defaultArgs = parent and cfg.wrappers[parent:getTitle():gsub('/sandbox$', '')]
| |
− | | |
− | -- Find user args, and use the parent frame if we are being called from a
| |
− | -- wrapper template.
| |
− | getArgs = getArgs or require('Module:Arguments').getArgs
| |
− | local userArgs = getArgs(frame, {
| |
− | parentOnly = defaultArgs,
| |
− | frameOnly = not defaultArgs
| |
− | })
| |
− | | |
− | -- Build the args table. User-specified args overwrite default args.
| |
− | local args = {}
| |
− | for k, v in pairs(defaultArgs or {}) do
| |
− | args[k] = v
| |
− | end
| |
− | for k, v in pairs(userArgs) do
| |
− | args[k] = v
| |
− | end
| |
− | return p._main(args, cfg)
| |
− | end
| |
− | | |
− | return p
| |