Latest revision |
Your text |
Line 1: |
Line 1: |
| -- This module implements {{pp-meta}} and its daughter templates such as | | -- This module implements {{pp-meta}} and its daughter templates such as |
| -- {{pp-dispute}}, {{pp-vandalism}} and {{pp-sock}}. | | -- {{pp-dispute}}, {{pp-vandalism}} and {{pp-sock}}. |
− |
| |
− | -- Initialise necessary modules.
| |
− | require('Module:No globals')
| |
− | local makeFileLink = require('Module:File link')._main
| |
− | local effectiveProtectionLevel = require('Module:Effective protection level')._main
| |
− | local effectiveProtectionExpiry = require('Module:Effective protection expiry')._main
| |
− | 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 | + | -- Configuration |
| -------------------------------------------------------------------------------- | | -------------------------------------------------------------------------------- |
| | | |
− | local function makeCategoryLink(cat, sort) | + | local cfg = {} |
− | if cat then
| |
− | return string.format(
| |
− | '[[%s:%s|%s]]',
| |
− | mw.site.namespaces[14].name,
| |
− | cat,
| |
− | sort
| |
− | )
| |
− | end
| |
− | end
| |
| | | |
− | -- Validation function for the expiry and the protection date
| + | cfg.reasons = { |
− | local function validateDate(dateString, dateType)
| + | blp = { |
− | if not lang then
| + | categoryOrder = 'reason', |
− | lang = mw.language.getContentLanguage() | + | banner = 'blp' |
− | end | + | }, |
− | local success, result = pcall(lang.formatDate, lang, 'U', dateString) | + | dispute = { |
− | if success then | + | categoryOrder = 'reason', |
− | result = tonumber(result) | + | banner = 'dispute' |
− | if result then | + | }, |
− | return result
| + | office = { |
− | end | + | categoryOrder = 'reason', |
− | end | + | banner = 'office' |
− | error(string.format( | + | }, |
− | 'invalid %s: %s', | + | sock = { |
− | dateType, | + | categoryOrder = 'reason', |
− | tostring(dateString) | + | banner = 'sock' |
− | ), 4) | + | }, |
− | end
| + | usertalk = { |
| + | banner = 'usertalk' |
| + | }, |
| + | vandalism = { |
| + | categoryOrder = 'namespace', |
| + | banner = 'vandalism' |
| + | } |
| + | } |
| | | |
− | local function makeFullUrl(page, query, display)
| + | cfg.banners = { |
− | return string.format( | + | -- $1 = "until" or "or until" depending on the expiry |
− | '[%s %s]',
| + | -- $2 = "disputes", with or without a section link |
− | tostring(mw.uri.fullUrl(page, query)),
| + | blp = { |
− | display | + | }, |
− | ) | + | dispute = { |
− | end
| + | text = '$1 editing $2 have been resolved', |
| + | tooltip = 'due to editing disputes', |
| + | dispute = true |
| + | }, |
| + | office = { |
| + | }, |
| + | sock = { |
| + | }, |
| + | usertalk = { |
| + | text = '', |
| + | explanation = 'If you cannot edit this user talk page and you need to' |
| + | .. ' make a change or leave a message, you can' |
| + | .. ' [[Wikipedia:Requests for page protection#' |
| + | .. 'Current requests for edits to a protected page|request an edit]],' |
| + | .. ' [[Wikipedia:Requests for page protection#' |
| + | .. 'Current requests for reduction in protection level|request unprotection]],' |
| + | .. ' [[Special:Userlogin|log in]],' |
| + | .. ' or [[Special:UserLogin/signup|create an account]].' |
| + | }, |
| + | vandalism = { |
| + | text = 'due to [[Wikipedia:Vandalism|vandalism]]', |
| + | tooltip = 'due to vandalism' |
| + | }, |
| + | } |
| | | |
− | -- Given a directed graph formatted as node -> table of direct successors, | + | cfg.categories = { |
− | -- get a table of all nodes reachable from a given node (though always | + | -- The key strings follow this format: |
− | -- including the given node). | + | -- type, level, ns, reason, expiry |
− | local function getReachableNodes(graph, start)
| + | ['all-all-all-all-all'] = 'Wikipedia protected pages', |
− | local toWalk, retval = {[start] = true}, {} | + | ['all-all-all-office-all'] = 'Wikipedia Office-protected pages', |
− | while true do | + | ['edit-all-template-all-all'] = 'Wikipedia protected templates', |
− | -- Can't use pairs() since we're adding and removing things as we're iterating
| + | ['edit-autoconfirmed-all-all-all'] = 'Wikipedia semi-protected pages', |
− | local k = next(toWalk) -- This always gets the "first" key
| + | ['edit-autoconfirmed-all-all-indef'] = 'Wikipedia indefinitely semi-protected pages', |
− | if k == nil then
| + | ['edit-autoconfirmed-all-blp-all'] = 'Wikipedia indefinitely semi-protected biographies of living people', |
− | return retval
| + | ['edit-autoconfirmed-all-blp-temp'] = 'Wikipedia temporarily semi-protected biographies of living people', |
− | end
| + | ['edit-autoconfirmed-all-dispute-all'] = 'Wikipedia pages semi-protected due to dispute', |
− | toWalk[k] = nil
| + | ['edit-autoconfirmed-all-sock-all'] = 'Wikipedia pages semi-protected from banned users', |
− | retval[k] = true
| + | ['edit-autoconfirmed-all-vandalism-all'] = 'Wikipedia pages semi-protected against vandalism', |
− | for _,v in ipairs(graph[k]) do
| + | ['edit-autoconfirmed-category-all-all'] = 'Wikipedia semi-protected categories', |
− | if not retval[v] then
| + | ['edit-autoconfirmed-file-all-all'] = 'Semi-protected images', |
− | toWalk[v] = true
| + | ['edit-autoconfirmed-portal-all-all'] = 'Semi-protected portals', |
− | end
| + | ['edit-autoconfirmed-project-all-all'] = 'Semi-protected project pages', |
− | end
| + | ['edit-autoconfirmed-talk-all-all'] = 'Semi-protected talk pages', |
− | end | + | ['edit-autoconfirmed-template-all-all'] = 'Wikipedia semi-protected templates', |
− | end
| + | ['edit-autoconfirmed-template-all-all'] = 'Wikipedia semi-protected templates', |
| + | ['edit-autoconfirmed-user-all-all'] = 'Wikipedia semi-protected user and user talk pages', |
| + | ['edit-sysop-all-blp-all'] = 'Wikipedia indefinitely protected biographies of living people', |
| + | ['edit-sysop-all-blp-temp'] = 'Wikipedia temporarily protected biographies of living people', |
| + | ['edit-sysop-all-dispute-all'] = 'Wikipedia pages protected due to dispute', |
| + | ['edit-sysop-all-sock-all'] = 'Wikipedia pages protected from banned users', |
| + | ['edit-sysop-all-vandalism-all'] = 'Wikipedia pages protected against vandalism', |
| + | ['edit-sysop-category-all-all'] = 'Wikipedia protected categories', |
| + | ['edit-sysop-file-all-all'] = 'Protected images', |
| + | ['edit-sysop-project-all-all'] = 'Protected project pages', |
| + | ['edit-sysop-talk-all-all'] = 'Protected talk pages', |
| + | ['edit-sysop-template-all-all'] = 'Wikipedia protected templates', |
| + | ['edit-sysop-user-all-all'] = 'Wikipedia protected user and user talk pages', |
| + | ['move-sysop-all-all-all'] = 'Wikipedia move-protected pages', |
| + | ['move-sysop-all-all-indef'] = 'Wikipedia indefinitely move-protected pages', |
| + | ['move-sysop-all-dispute-all'] = 'Wikipedia pages move-protected due to dispute', |
| + | ['move-sysop-all-vandalism-all'] = 'Wikipedia pages move-protected due to vandalism', |
| + | ['move-sysop-portal-all-all'] = 'Wikipedia move-protected portals', |
| + | ['move-sysop-portal-all-all'] = 'Wikipedia move-protected portals', |
| + | ['move-sysop-project-all-all'] = 'Wikipedia move-protected project pages', |
| + | ['move-sysop-talk-all-all'] = 'Wikipedia move-protected talk pages', |
| + | ['move-sysop-template-all-all'] = 'Wikipedia move-protected templates', |
| + | ['move-sysop-user-all-all'] = 'Wikipedia move-protected user and user talk pages', |
| + | ['pc-autoconfirmed-all-all-all'] = 'Wikipedia pending changes protected pages (level 1)', |
| + | ['pc-reviewer-all-all-all'] = 'Wikipedia pending changes protected pages (level 2)', |
| + | } |
| | | |
− | --------------------------------------------------------------------------------
| + | cfg.categoryNamespaces = { |
− | -- Protection class
| + | [2] = 'user', |
− | --------------------------------------------------------------------------------
| + | [3] = 'user', |
− | | + | [4] = 'project', |
− | local Protection = {}
| + | [6] = 'file', |
− | Protection.__index = Protection
| + | [10] = 'template', |
| + | [12] = 'project', |
| + | [14] = 'category', |
| + | [100] = 'portal', |
| + | } |
| | | |
− | Protection.supportedActions = {
| + | cfg.pagetypeNamespaces = { |
− | edit = true, | + | [0] = 'article', |
− | move = true, | + | [6] = 'file', |
− | autoreview = true, | + | [10] = 'template', |
− | upload = true | + | [14] = 'category', |
| + | [828] = 'module', |
| + | default = 'page' |
| } | | } |
| | | |
− | Protection.bannerConfigFields = {
| + | --[[ |
− | 'text', | + | -- Not currently used |
− | 'explanation', | + | local error_categories = { |
− | 'tooltip', | + | incorrect = 'Wikipedia pages with incorrect protection templates', |
− | 'alt',
| + | no_expiry = 'Wikipedia protected pages without expiry', |
− | 'link',
| + | create = 'Wikipedia pages tagged as create-protected', |
− | 'image' | + | template = 'Wikipedia template-protected pages other than templates and modules' |
| } | | } |
| + | --]] |
| | | |
− | function Protection.new(args, cfg, title)
| + | -------------------------------------------------------------------------------- |
− | local obj = {}
| + | -- Main functions |
− | obj._cfg = cfg
| + | -------------------------------------------------------------------------------- |
− | obj.title = title or mw.title.getCurrentTitle()
| |
| | | |
− | -- Set action
| + | -- Initialise necessary modules. |
− | if not args.action then
| + | local mArguments = require('Module:Arguments') |
− | obj.action = 'edit'
| + | local mMessageBox -- only needs to be loaded if we are outputting a banner, so lazily initialise |
− | elseif Protection.supportedActions[args.action] then
| |
− | obj.action = args.action
| |
− | else
| |
− | error(string.format(
| |
− | 'invalid action: %s',
| |
− | tostring(args.action)
| |
− | ), 3)
| |
− | end
| |
| | | |
− | -- Set level
| + | -- Define often-used functions as local variables. |
− | obj.level = args.demolevel or effectiveProtectionLevel(obj.action, obj.title)
| + | local tconcat = table.concat |
− | if not obj.level or (obj.action == 'move' and obj.level == 'autoconfirmed') then
| + | local tinsert = table.insert |
− | -- Users need to be autoconfirmed to move pages anyway, so treat
| + | local tremove = table.remove |
− | -- semi-move-protected pages as unprotected.
| + | local ceil = math.ceil |
− | obj.level = '*'
| + | local format = string.format |
− | end
| |
| | | |
− | -- Set expiry
| + | local function toTableEnd(t, pos) |
− | local effectiveExpiry = effectiveProtectionExpiry(obj.action, obj.title)
| + | -- Sends the value at position pos to the end of array t, and shifts the |
− | if effectiveExpiry == 'infinity' then | + | -- other items down accordingly. |
− | obj.expiry = 'indef'
| + | return tinsert(t, tremove(t, pos)) |
− | elseif effectiveExpiry ~= 'unknown' then | + | end |
− | obj.expiry = validateDate(effectiveExpiry, 'expiry date')
| |
− | end
| |
| | | |
− | -- Set reason
| + | local p = {} |
− | 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 p.getPagetype(ns) |
− | if args.date then | + | -- Returns a string with the page's type. Takes a namespace number as input. |
− | obj.protectionDate = validateDate(args.date, 'protection date') | + | local pagetype = pagetypeNamespaces[ns] or pagetypeNamespaces.default |
| + | if not pagetype then |
| + | error('the page type could not be found; please define a name for the key "default"') |
| end | | end |
− |
| + | return pagetype |
− | -- Set banner config
| |
− | do
| |
− | obj.bannerConfig = {}
| |
− | local configTables = {}
| |
− | if cfg.banners[obj.action] then
| |
− | configTables[#configTables + 1] = cfg.banners[obj.action][obj.reason]
| |
− | end
| |
− | if cfg.defaultBanners[obj.action] then
| |
− | configTables[#configTables + 1] = cfg.defaultBanners[obj.action][obj.level]
| |
− | configTables[#configTables + 1] = cfg.defaultBanners[obj.action].default
| |
− | end
| |
− | configTables[#configTables + 1] = cfg.masterBanner
| |
− | for i, field in ipairs(Protection.bannerConfigFields) do
| |
− | for j, t in ipairs(configTables) do
| |
− | if t[field] then
| |
− | obj.bannerConfig[field] = t[field]
| |
− | break
| |
− | end
| |
− | end
| |
− | end
| |
− | end
| |
− | return setmetatable(obj, Protection) | |
− | end
| |
− | | |
− | function Protection:isProtected()
| |
− | return self.level ~= '*'
| |
− | end
| |
− | | |
− | function Protection:isTemporary()
| |
− | return type(self.expiry) == 'number'
| |
| end | | end |
| | | |
− | function Protection:makeProtectionCategory() | + | function p.matchNamespace(ns) |
− | local cfg = self._cfg | + | -- Matches a namespace number to a string that can be passed to the |
− | local title = self.title
| + | -- namespace parameter of p.getCategoryName. |
− |
| + | if not ns or type(ns) ~= 'number' then |
− | -- Exit if the page is not protected. | + | return nil |
− | if not self:isProtected() then | |
− | return '' | |
| end | | end |
− |
| + | local nskey = cfg.categoryNamespaces[ns] |
− | -- Get the expiry key fragment.
| + | if not nskey and ns % 2 == 1 then |
− | local expiryFragment | + | nskey = 'talk' |
− | if self.expiry == 'indef' then
| |
− | expiryFragment = self.expiry
| |
− | elseif type(self.expiry) == 'number' then | |
− | expiryFragment = 'temp'
| |
| end | | end |
| + | return nskey |
| + | end |
| | | |
− | -- Get the namespace key fragment.
| + | function p.getCategoryName(cats, action, level, namespace, reason, expiry) |
− | local namespaceFragment = cfg.categoryNamespaceKeys[title.namespace]
| + | --[[ |
− | if not namespaceFragment and title.namespace % 2 == 1 then
| + | -- Gets a category name from the category table, given a combination of |
− | namespaceFragment = 'talk'
| + | -- the protection type, the protection level, the namespace number, the |
− | end
| + | -- reason for protection, and the expiry date. |
− |
| + | --]] |
− | -- Define the order that key fragments are tested in. This is done with an | + | cats = cats or cfg.categories |
− | -- 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 = p.matchNamespace(namespace)}, |
| + | 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 |
| + | error('no properties key') |
| + | end |
| + | local property = properties[propertiesKey] |
| + | if not property then |
| + | error('invalid properties key') |
| + | end |
| + | if dupes[property] then |
| + | error('dupe detected') |
| else | | else |
− | inactive[#inactive + 1] = t | + | dupes[property] = true |
| end | | end |
| + | configOrder[i] = property |
| end | | end |
− | noActive = #active
| + | else |
− | attemptOrder = active
| + | for propertiesKey, t in pairs(properties) do |
− | for i, t in ipairs(inactive) do | + | configOrder[t.order] = t |
− | attemptOrder[#attemptOrder + 1] = t | |
| end | | end |
| + | if categoryOrderType == 'string' then |
| + | local property = properties[categoryOrder] |
| + | if not property then |
| + | error('invalid category order string') |
| + | end |
| + | toTableEnd(configOrder, property.order) |
| + | end |
| + | end |
| + | |
| + | --[[ |
| + | -- 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 |
| + | 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 299: |
| -- 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 290: |
Line 313: |
| else | | else |
| local quotient = i / 2 ^ (j - 1) | | local quotient = i / 2 ^ (j - 1) |
− | quotient = math.ceil(quotient) | + | quotient = ceil(quotient) |
| if quotient % 2 == 1 then | | if quotient % 2 == 1 then |
| key[t.keypos] = t.val | | key[t.keypos] = t.val |
Line 298: |
Line 321: |
| end | | end |
| end | | end |
− | key = table.concat(key, '|') | + | key = tconcat(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('No category match found; please define the category for key "all-all-all-all-all"') |
| end | | end |
| | | |
− | function Protection:isIncorrect() | + | function p.renderImageLink(image, size, link, text, alt) |
− | local expiry = self.expiry
| + | --[[ |
− | return not self:isProtected()
| + | -- Renders the image link wikitext All parameters are optional |
− | or type(expiry) == 'number' and expiry < os.time()
| + | -- apart from the display text. |
− | end
| + | -- |
− | | + | -- @parameters: |
− | function Protection:isTemplateProtectedNonTemplate()
| + | -- image - the image name |
− | local action, namespace = self.action, self.title.namespace
| + | -- size - the image size, as a number |
− | return self.level == 'templateeditor'
| + | -- link - page linked to by the image |
− | and (
| + | -- text - the tooltip text |
− | (action ~= 'edit' and action ~= 'move')
| + | -- alt - the alt text |
− | or (namespace ~= 10 and namespace ~= 828)
| + | -- |
− | )
| + | -- All parameters are optional apart from the text parameter. |
− | end
| + | --]] |
− | | + | image = image or 'Transparent.gif' |
− | function Protection:makeCategoryLinks()
| + | size = size or 20 |
− | local msg = self._cfg.msg | + | if link then |
− | local ret = { self:makeProtectionCategory() } | + | link = '|link=' .. link |
− | 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
| |
− | | |
− | --------------------------------------------------------------------------------
| |
− | -- Blurb class | |
− | -------------------------------------------------------------------------------- | |
− | | |
− | local Blurb = {}
| |
− | 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 | | else |
− | -- We need the history link. | + | link = '' |
− | return makeFullUrl(
| |
− | pagename,
| |
− | {action = 'history'},
| |
− | self:_getExpandedMessage('current-version-edit-display')
| |
− | )
| |
| end | | end |
− | end
| + | text = text or error('No text parameter supplied to p.renderImageLink') |
− | | + | if alt then |
− | function Blurb:_makeEditRequestParameter()
| + | alt = '|alt=' .. alt |
− | 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 | | else |
− | return expiry | + | alt = '' |
| end | | end |
| + | return string.format('[[Image:%s|%dpx%s|%s%s]]', image, size, link, text, alt) |
| end | | end |
| | | |
− | function Blurb:_makeExplanationBlurbParameter() | + | function p.renderPadlock(image, right) |
− | -- Cover special cases first. | + | --[[ |
− | if self._protectionObj.title.namespace == 8 then | + | -- Renders the html of the padlock seen in the top-right-hand corner |
− | -- MediaWiki namespace
| + | -- of protected pages. |
− | return self:_getExpandedMessage('explanation-blurb-nounprotect')
| + | -- |
− | end
| + | -- @parameters: |
− | | + | -- image - the image wikitext (required) |
− | -- Get explanation blurb table keys | + | -- right - the "right" css property value, as a string (optional) |
− | local action = self._protectionObj.action
| + | --]] |
− | local level = self._protectionObj.level | + | image = image or error('No image parameter specified in p.renderPadlock') |
− | local talkKey = self._protectionObj.title.isTalkPage and 'talk' or 'subject' | + | local root = mw.html.create('div') |
− | | + | root |
− | -- Find the message in the explanation blurb table and substitute any | + | :addClass('metadata topicon nopopups') |
− | -- parameters. | + | :attr('id', 'protected-icon') |
− | local explanations = self._cfg.explanationBlurbs | + | :css{display = 'none', right = right or '55px'} |
− | local msg
| + | :wikitext(image) |
− | if explanations[action][level] and explanations[action][level][talkKey] then
| + | return tostring(root) |
− | 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 | | end |
| | | |
− | function Blurb:_makeImageLinkParameter() | + | function p.renderBanner(page, image, text) |
− | local imageLinks = self._cfg.imageLinks
| + | --[[ |
− | local action = self._protectionObj.action
| + | -- Renders the large protection banner placed at the top of articles, |
− | local level = self._protectionObj.level
| + | -- using the data provided in the data table. |
− | local msg
| + | -- |
− | if imageLinks[action][level] then
| + | -- @parameters: |
− | msg = imageLinks[action][level]
| + | -- page - demo page parameter to pass to {{mbox}} |
− | elseif imageLinks[action].default then
| + | -- image - the image wikitext |
− | msg = imageLinks[action].default
| + | -- text - the text to display |
− | else
| + | -- |
− | msg = imageLinks.edit.default
| + | -- All parameters are optional. |
− | end
| + | --]] |
− | return self:_substituteParameters(msg)
| + | mMessageBox = require('Module:Message box') |
− | end
| + | local mbargs = { -- arguments for the message box module |
− | | + | page = page, |
− | 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
| |
− | --------------------------------------------------------------------------------
| |
− | | |
− | local BannerTemplate = {}
| |
− | 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
| |
− | --------------------------------------------------------------------------------
| |
− | | |
− | local Banner = setmetatable({}, BannerTemplate)
| |
− | Banner.__index = Banner
| |
− | | |
− | function Banner.new(protectionObj, blurbObj, cfg)
| |
− | local obj = BannerTemplate.new(protectionObj, cfg) -- This doesn't need the blurb.
| |
− | obj.imageWidth = 40 | |
− | 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
| |
− | | |
− | function Banner:__tostring()
| |
− | -- Renders the banner. | |
− | makeMessageBox = makeMessageBox or require('Module:Message box').main | |
− | local reasonText = self._reasonText or error('no reason text set', 2)
| |
− | local explanationText = self._explanationText
| |
− | local mbargs = { | |
− | page = self._page, | |
| type = 'protection', | | type = 'protection', |
− | image = self:renderImage(), | + | image = image, |
− | text = string.format( | + | text = text |
− | "'''%s'''%s",
| |
− | reasonText,
| |
− | explanationText and '<br />' .. explanationText or ''
| |
− | )
| |
| } | | } |
− | return makeMessageBox('mbox', mbargs) | + | return mMessageBox.main('mbox', mbargs) |
− | end
| |
− | | |
− | --------------------------------------------------------------------------------
| |
− | -- Padlock class
| |
− | --------------------------------------------------------------------------------
| |
− | | |
− | local Padlock = setmetatable({}, BannerTemplate)
| |
− | Padlock.__index = Padlock
| |
− | | |
− | function Padlock.new(protectionObj, blurbObj, cfg)
| |
− | local obj = BannerTemplate.new(protectionObj, cfg) -- This doesn't need the blurb.
| |
− | obj.imageWidth = 20
| |
− | obj.imageCaption = blurbObj:makeBannerText('tooltip')
| |
− | 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
| |
− | | |
− | function Padlock:__tostring()
| |
− | 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 {
| |
− | Protection = Protection,
| |
− | Blurb = Blurb,
| |
− | BannerTemplate = BannerTemplate,
| |
− | Banner = Banner,
| |
− | Padlock = Padlock,
| |
− | }
| |
− | end
| |
− | | |
− | function p._main(args, cfg, title)
| |
− | 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 | | end |
| | | |
| return p | | return p |