Latest revision |
Your text |
Line 3: |
Line 3: |
| | | |
| -- Initialise necessary modules. | | -- Initialise necessary modules. |
− | require('Module:No globals')
| + | local mArguments = require('Module:Arguments') |
− | local makeFileLink = require('Module:File link')._main | + | local mProtectionLevel = require('Module:Effective protection level')._main |
− | local effectiveProtectionLevel = require('Module:Effective protection level')._main | + | local mFileLink = require('Module:File link') |
− | local effectiveProtectionExpiry = require('Module:Effective protection expiry')._main | |
| local yesno = require('Module:Yesno') | | local yesno = require('Module:Yesno') |
| + | local mMessageBox -- only needs to be loaded if we are outputting a banner, so lazily initialise |
| | | |
− | -- Lazily initialise modules and objects we don't always need. | + | -- Load config |
− | local getArgs, makeMessageBox, lang | + | local cfg = mw.loadData('Module:Protection banner/config') |
| | | |
− | -- Set constants.
| + | local p = {} |
− | local CONFIG_MODULE = 'Module:Protection banner/config' | |
| | | |
| -------------------------------------------------------------------------------- | | -------------------------------------------------------------------------------- |
Line 19: |
Line 18: |
| -------------------------------------------------------------------------------- | | -------------------------------------------------------------------------------- |
| | | |
− | local function makeCategoryLink(cat, sort) | + | local function validateField(tName, t, field, expectType, nilOk) |
− | if cat then | + | local val = t[field] |
− | return string.format( | + | local valType = type(val) |
− | '[[%s:%s|%s]]', | + | if not (valType == expectType or nilOk and valType == 'nil') then |
− | mw.site.namespaces[14].name, | + | error(string.format( |
− | cat, | + | "type error in '%s' field '%s' (%s%s expected, got %s)", |
− | sort | + | tName, |
− | ) | + | tostring(field), |
| + | expectType, |
| + | nilOk and ' or nil' or '', |
| + | valType |
| + | ), 2) |
| end | | end |
| end | | end |
| | | |
− | -- Validation function for the expiry and the protection date | + | local function toTableEnd(t, pos) |
− | local function validateDate(dateString, dateType)
| + | -- Sends the value at position pos to the end of array t, and shifts the |
− | if not lang then | + | -- other items down accordingly. |
− | lang = mw.language.getContentLanguage()
| + | return table.insert(t, table.remove(t, pos)) |
− | end | + | end |
− | local success, result = pcall(lang.formatDate, lang, 'U', dateString) | + | |
− | if success then | + | -------------------------------------------------------------------------------- |
− | result = tonumber(result) | + | -- Main functions |
− | if result then
| + | -------------------------------------------------------------------------------- |
− | return result
| + | |
− | end | + | function p.main(frame) |
| + | local args = mArguments.getArgs(frame) |
| + | return p._main(args) |
| + | end |
| + | |
| + | function p._main(args) |
| + | local protectionLevel = p.getProtectionLevel(args) |
| + | local isSmall = yesno(args.small) or false |
| + | local bannerConfig = p.getBannerConfig(protectionLevel, args) |
| + | |
| + | local ret = '' |
| + | if isSmall then |
| + | ret = ret .. p.makePadlock(protectionLevel, args, bannerConfig) |
| + | else |
| + | ret = ret .. p.makeBanner(protectionLevel, args, bannerConfig) |
| end | | end |
− | error(string.format( | + | ret = ret .. p.getProtectionCategory(protectionLevel, args) |
− | 'invalid %s: %s',
| + | ret = ret .. p.getTrackingCategories(protectionLevel, args) |
− | dateType,
| + | return ret |
− | tostring(dateString)
| |
− | ), 4) | |
| end | | end |
| | | |
− | local function makeFullUrl(page, query, display)
| + | -------------------------------------------------------------------------------- |
− | return string.format( | + | -- Protection functions |
− | '[%s %s]',
| + | -------------------------------------------------------------------------------- |
− | tostring(mw.uri.fullUrl(page, query)), | + | |
− | display
| + | function p.getProtectionLevel(args) |
− | ) | + | local title |
| + | if args.page then |
| + | title = mw.title.new(args.page) |
| + | else |
| + | title = mw.title.getCurrentTitle() |
| + | end |
| + | local protectionData = p.getProtectionData(title) |
| + | protectionLevel = protectionData[args.action or 'edit'] |
| + | return protectionLevel or '*' |
| end | | end |
| | | |
− | -- Given a directed graph formatted as node -> table of direct successors, | + | function p.getProtectionData(title) |
− | -- get a table of all nodes reachable from a given node (though always | + | -- Gets a table containing protection data for the given title. The data |
− | -- including the given node). | + | -- is cached using a metatable, and so can be indexed as needed without |
− | local function getReachableNodes(graph, start) | + | -- a performance loss. |
− | local toWalk, retval = {[start] = true}, {} | + | local protectionData = {} |
− | while true do
| + | local actions = { |
− | -- Can't use pairs() since we're adding and removing things as we're iterating | + | create = true, |
− | local k = next(toWalk) -- This always gets the "first" key | + | edit = true, |
− | if k == nil then | + | move = true, |
− | return retval | + | autoreview = true |
− | end
| + | } |
− | toWalk[k] = nil
| + | setmetatable(protectionData, { |
− | retval[k] = true
| + | __index = function (t, key) |
− | for _,v in ipairs(graph[k]) do
| + | local level |
− | if not retval[v] then
| + | if actions[key] then |
− | toWalk[v] = true | + | level = mProtectionLevel(key, title) |
| + | if level == 'accountcreator' then |
| + | -- Lump titleblacklisted pages in with template-protected pages, |
| + | -- since templateeditors can do both. |
| + | level = 'templateeditor' |
| + | end |
| end | | end |
| + | protectionData[key] = level |
| + | return level |
| end | | end |
− | end | + | }) |
− | end | + | return protectionData |
| + | end |
| | | |
| -------------------------------------------------------------------------------- | | -------------------------------------------------------------------------------- |
− | -- Protection class | + | -- Banner config functions |
| -------------------------------------------------------------------------------- | | -------------------------------------------------------------------------------- |
| | | |
− | local Protection = {}
| + | function p.getBannerConfig(protectionLevel, args) |
− | Protection.__index = Protection
| + | end |
| | | |
− | Protection.supportedActions = {
| + | -------------------------------------------------------------------------------- |
− | edit = true,
| + | -- Padlock functions |
− | move = true,
| + | -------------------------------------------------------------------------------- |
− | autoreview = true,
| |
− | upload = true
| |
− | }
| |
| | | |
− | Protection.bannerConfigFields = {
| + | function p.makePadlock(protectionLevel, args, bannerConfig) |
− | 'text',
| + | local data = p.makePadlockData(protectionLevel, args, bannerConfig) |
− | 'explanation',
| + | return p.renderPadlock(data) |
− | 'tooltip', | + | end |
− | 'alt',
| |
− | 'link', | |
− | 'image'
| |
− | }
| |
| | | |
− | function Protection.new(args, cfg, title) | + | function p.makePadlockData(protectionLevel, args, bannerConfig) |
− | local obj = {}
| + | end |
− | obj._cfg = cfg
| |
− | obj.title = title or mw.title.getCurrentTitle()
| |
| | | |
− | -- Set action | + | function p.renderPadlock(data) |
− | if not args.action then | + | data = data or {} |
− | obj.action = 'edit'
| + | local image = mFileLink.new(data.filename or 'Transparent.gif') |
− | elseif Protection.supportedActions[args.action] then
| + | :width(20) |
− | obj.action = args.action | + | :link(data.link) |
− | else | + | :alt(data.alt) |
− | error(string.format( | + | :render() |
− | 'invalid action: %s',
| + | local root = mw.html.create('div') |
− | tostring(args.action)
| + | root |
− | ), 3)
| + | :addClass('metadata topicon nopopups') |
− | end
| + | :attr('id', 'protected-icon') |
| + | :css{display = 'none', right = data.right or '55px'} |
| + | :wikitext(image) |
| + | return tostring(root) |
| + | end |
| | | |
− | -- Set level
| + | -------------------------------------------------------------------------------- |
− | obj.level = args.demolevel or effectiveProtectionLevel(obj.action, obj.title)
| + | -- Banner functions |
− | if not obj.level or (obj.action == 'move' and obj.level == 'autoconfirmed') then
| + | -------------------------------------------------------------------------------- |
− | -- Users need to be autoconfirmed to move pages anyway, so treat
| |
− | -- semi-move-protected pages as unprotected.
| |
− | obj.level = '*'
| |
− | end
| |
| | | |
− | -- Set expiry
| + | function p.makeBanner(protectionLevel, args, bannerConfig) |
− | local effectiveExpiry = effectiveProtectionExpiry(obj.action, obj.title) | + | local data = p.makeBannerData(protectionLevel, args, bannerConfig) |
− | if effectiveExpiry == 'infinity' then | + | return p.renderBanner(data) |
− | obj.expiry = 'indef'
| + | end |
− | elseif effectiveExpiry ~= 'unknown' then
| |
− | obj.expiry = validateDate(effectiveExpiry, 'expiry date')
| |
− | end
| |
| | | |
− | -- Set reason
| + | function p.makeBannerData(protectionLevel, args, bannerConfig) |
− | if args[1] then
| + | end |
− | 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.renderBanner(data) |
− | if args.date then
| + | data = data or {} |
− | obj.protectionDate = validateDate(args.date, 'protection date')
| + | local image = mFileLink.new(data.filename) |
− | end | + | :width(40) |
− |
| + | :caption(data.mouseover) |
− | -- Set banner config
| + | :render() |
− | do
| + | local mbargs = { |
− | obj.bannerConfig = {}
| + | page = data.page, |
− | local configTables = {}
| + | type = 'protection', |
− | if cfg.banners[obj.action] then
| + | image = image, |
− | configTables[#configTables + 1] = cfg.banners[obj.action][obj.reason]
| + | text = string.format( |
− | end | + | "'''%s'''%s", |
− | if cfg.defaultBanners[obj.action] then | + | data.reasonText, |
− | configTables[#configTables + 1] = cfg.defaultBanners[obj.action][obj.level]
| + | data.explanationText and '<br />' .. data.explanationText or '' |
− | configTables[#configTables + 1] = cfg.defaultBanners[obj.action].default
| + | ) |
− | end | + | } |
− | configTables[#configTables + 1] = cfg.masterBanner | + | return mMessageBox.main('mbox', mbargs) |
− | 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 | | end |
| | | |
− | function Protection:isProtected() | + | -------------------------------------------------------------------------------- |
− | return self.level ~= '*'
| + | -- Protection category functions |
| + | -------------------------------------------------------------------------------- |
| + | |
| + | function p.getProtectionCategory(protectionLevel, args) |
| end | | end |
| | | |
− | function Protection:isTemporary() | + | function p.getPagetype(ns) |
− | return type(self.expiry) == 'number' | + | -- Returns a string with the page's type. Takes a namespace number as input. |
| + | 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 |
| + | return pagetype |
| 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 |
| + | 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 | | end |
| + | configOrder[i] = property |
| + | end |
| + | else |
| + | for propertiesKey, t in pairs(properties) do |
| + | configOrder[t.order] = t |
| end | | end |
− | noActive = #active | + | if categoryOrderType == 'string' then |
− | attemptOrder = active
| + | local property = properties[categoryOrder] |
− | for i, t in ipairs(inactive) do
| + | if not property then |
− | attemptOrder[#attemptOrder + 1] = t | + | local msg = '"' |
| + | .. categoryOrder |
| + | .. '" is not a valid value of cfg.reasons.' |
| + | .. reason |
| + | .. '.categoryOrder' |
| + | error(msg) |
| + | end |
| + | toTableEnd(configOrder, property.order) |
| end | | end |
| end | | end |
− |
| + | |
| --[[ | | --[[ |
− | -- Check increasingly generic key combinations until we find a match. If a | + | -- Define the attempt order. Properties with no value defined are moved |
− | -- specific category exists for the combination of key fragments we are | + | -- to the end, where they will later be given the value "all". This is |
− | -- given, that match will be found first. If not, we keep trying different | + | -- to cut down on the number of table lookups in the cats table, which |
− | -- key fragment combinations until we match using the key | + | -- 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 |
| + | |
| + | --[[ |
| + | -- Check increasingly generic key combinations until we find a match. |
| + | -- If a specific category exists for the combination of properties |
| + | -- we are given, that match will be found first. If not, we keep |
| + | -- 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 337: |
| -- 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 359: |
| 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
| |
− | | |
− | --------------------------------------------------------------------------------
| |
− | -- 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
| |
− | -- 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 | | end |
| | | |
| -------------------------------------------------------------------------------- | | -------------------------------------------------------------------------------- |
− | -- BannerTemplate class | + | -- Tracking category functions |
| -------------------------------------------------------------------------------- | | -------------------------------------------------------------------------------- |
| | | |
− | local BannerTemplate = {}
| + | function p.getTrackingCategories(protectionLevel, args) |
− | 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 | | end |
| | | |
− | function BannerTemplate:renderImage()
| + | --[[ |
− | local filename = self._imageFilename
| + | When to add "Category:Wikipedia pages with incorrect protection templates": |
− | or self._cfg.msg['image-filename-default']
| + | * If it uses a type which is incompatible with the actual protection level of a page, or |
− | or 'Transparent.gif'
| + | * If an expiry date is set and is in the past |
− | return makeFileLink{
| |
− | file = filename,
| |
− | size = (self.imageWidth or 20) .. 'px',
| |
− | alt = self._imageAlt,
| |
− | link = self._imageLink,
| |
− | caption = self.imageCaption
| |
− | }
| |
− | end
| |
| | | |
− | --------------------------------------------------------------------------------
| + | When to add "Category:Wikipedia protected pages without expiry": |
− | -- Banner class
| + | * No expiry is set, and |
− | --------------------------------------------------------------------------------
| + | * Expiry can be set, and |
− | | + | * The protection type is not "move" (could change this?), and |
− | local Banner = setmetatable({}, BannerTemplate)
| + | * The reason doesn't have "indefinitely protected" categories (pp-blp, pp-semi-indef and pp-move-indef have these), and |
− | Banner.__index = Banner
| + | * The reason is not the generic pp-protected (could change this?) |
− | | + | (This leaves reasons "dispute", "vandalism", "usertalk", and "sock") |
− | 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',
| |
− | image = self:renderImage(),
| |
− | text = string.format(
| |
− | "'''%s'''%s",
| |
− | reasonText,
| |
− | explanationText and '<br />' .. explanationText or ''
| |
− | )
| |
− | }
| |
− | return makeMessageBox('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
| |
| | | |
| return p | | return p |