최신판 |
당신의 편집 |
1번째 줄: |
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 categories = { |
| if cat then | | -- The key strings follow this format: |
| return string.format(
| | -- type, level, ns, reason, expiry |
| '[[%s:%s|%s]]',
| | ['edit-autoconfirmed-user-all-all'] = 'Wikipedia semi-protected user and user talk pages', |
| mw.site.namespaces[14].name,
| | ['edit-autoconfirmed-project-all-all'] = 'Semi-protected project pages', |
| cat,
| | ['edit-autoconfirmed-file-all-all'] = 'Semi-protected images', |
| sort
| | ['edit-autoconfirmed-template-all-all'] = 'Wikipedia semi-protected templates', |
| )
| | ['edit-autoconfirmed-portal-all-all'] = 'Semi-protected portals', |
| end | | ['edit-autoconfirmed-talk-all-all'] = 'Semi-protected talk pages', |
| end
| | ['edit-autoconfirmed-all-vandalism-all'] = 'Wikipedia pages semi-protected against vandalism', |
| | ['edit-sysop-user-all-all'] = 'Wikipedia protected user and user talk pages', |
| | ['edit-sysop-file-all-all'] = 'Protected images', |
| | ['edit-sysop-project-all-all'] = 'Protected project pages', |
| | ['edit-sysop-template-all-all'] = 'Wikipedia protected templates', |
| | ['edit-sysop-talk-all-all'] = 'Protected talk pages', |
| | ['edit-sysop-all-vandalism-all'] = 'Wikipedia pages protected against vandalism', |
| | ['edit-autoconfirmed-all-dispute-all'] = 'Wikipedia pages semi-protected due to dispute', |
| | ['edit-sysop-all-dispute-all'] = 'Wikipedia pages protected due to dispute', |
| | ['move-sysop-all-dispute-all'] = 'Wikipedia pages move-protected due to dispute', |
| | ['move-sysop-user-all-all'] = 'Wikipedia move-protected user and user talk pages', |
| | ['move-sysop-project-all-all'] = 'Wikipedia move-protected project pages', |
| | ['move-sysop-portal-all-all'] = 'Wikipedia move-protected portals', |
| | ['move-sysop-all-vandalism-all'] = 'Wikipedia pages move-protected due to vandalism', |
| | ['edit-autoconfirmed-template-all-all'] = 'Wikipedia semi-protected templates', |
| | ['move-sysop-template-all-all'] = 'Wikipedia move-protected templates', |
| | ['edit-all-template-all-all'] = 'Wikipedia protected templates', |
| | ['move-sysop-portal-all-all'] = 'Wikipedia move-protected portals', |
| | ['edit-autoconfirmed-all-sock-all'] = 'Wikipedia pages semi-protected from banned users', |
| | ['edit-sysop-all-sock-all'] = 'Wikipedia pages protected from banned users', |
| | ['edit-autoconfirmed-all-blp-temp'] = 'Wikipedia temporarily semi-protected biographies of living people', |
| | ['edit-sysop-all-blp-temp'] = 'Wikipedia temporarily protected biographies of living people', |
| | ['edit-autoconfirmed-all-blp-all'] = 'Wikipedia indefinitely semi-protected biographies of living people', |
| | ['edit-sysop-all-blp-all'] = 'Wikipedia indefinitely protected biographies of living people', |
| | ['edit-autoconfirmed-all-all-indef'] = 'Wikipedia indefinitely semi-protected pages', |
| | ['edit-autoconfirmed-category-all-all'] = 'Wikipedia semi-protected categories', |
| | ['edit-sysop-category-all-all'] = 'Wikipedia protected categories', |
| | ['move-sysop-talk-all-all'] = 'Wikipedia move-protected talk pages', |
| | ['move-sysop-all-all-indef'] = 'Wikipedia indefinitely move-protected pages', |
| | ['edit-autoconfirmed-all-all-all'] = 'Wikipedia semi-protected pages', |
| | ['move-sysop-all-all-all'] = 'Wikipedia move-protected 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)', |
| | ['all-all-all-office-all'] = 'Wikipedia Office-protected pages', |
| | ['all-all-all-all-all'] = 'Wikipedia protected pages', |
| | } |
|
| |
|
| -- Validation function for the expiry and the protection date
| | local categoryNamespaces = { |
| local function validateDate(dateString, dateType) | | [2] = 'user', |
| if not lang then | | [3] = 'user', |
| lang = mw.language.getContentLanguage()
| | [4] = 'project', |
| end | | [6] = 'file', |
| local success, result = pcall(lang.formatDate, lang, 'U', dateString) | | [10] = 'template', |
| if success then | | [12] = 'project', |
| result = tonumber(result)
| | [14] = 'category', |
| if result then
| | [100] = 'portal', |
| return result
| | } |
| end
| |
| end | |
| error(string.format( | |
| 'invalid %s: %s',
| |
| dateType,
| |
| tostring(dateString)
| |
| ), 4) | |
| end
| |
|
| |
|
| local function makeFullUrl(page, query, display) | | local behaviors = { |
| return string.format( | | vandalism = 'namespaceFirst', |
| '[%s %s]',
| | dispute = 'reasonFirst', |
| tostring(mw.uri.fullUrl(page, query)),
| | blp = 'reasonFirst', |
| display
| | sock = 'reasonFirst', |
| ) | | office = 'reasonFirst', |
| end
| | } |
|
| |
|
| -- Given a directed graph formatted as node -> table of direct successors,
| | local pagetypeNamespaces = { |
| -- get a table of all nodes reachable from a given node (though always
| | [0] = 'article', |
| -- including the given node).
| | [6] = 'file', |
| local function getReachableNodes(graph, start) | | [10] = 'template', |
| local toWalk, retval = {[start] = true}, {} | | [14] = 'category', |
| while true do | | [828] = 'module', |
| -- Can't use pairs() since we're adding and removing things as we're iterating
| | default = 'page' |
| 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
| |
| | |
| --------------------------------------------------------------------------------
| |
| -- Protection class
| |
| --------------------------------------------------------------------------------
| |
| | |
| local Protection = {}
| |
| Protection.__index = Protection
| |
| | |
| Protection.supportedActions = {
| |
| edit = true,
| |
| move = true, | |
| autoreview = true, | |
| upload = true
| |
| } | | } |
|
| |
|
| 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 |
| end
| | if not pagetype then |
|
| | error('the page type could not be found; please define a name for the key "default"') |
| -- 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 | | end |
| return setmetatable(obj, Protection) | | return pagetype |
| end
| |
| | |
| function Protection:isUserScript()
| |
| -- Whether the page is a user JavaScript or CSS page.
| |
| local title = self.title
| |
| return title.namespace == 2 and (
| |
| title.contentModel == 'javascript' or title.contentModel == 'css'
| |
| )
| |
| end
| |
| | |
| function Protection:isProtected()
| |
| return self.level ~= '*'
| |
| end
| |
| | |
| function Protection:shouldShowLock()
| |
| -- Whether we should output a banner/padlock
| |
| return self:isProtected() and not self:isUserScript()
| |
| end
| |
| | |
| -- Whether this page needs a protection category.
| |
| Protection.shouldHaveProtectionCategory = Protection.shouldShowLock
| |
| | |
| function Protection:isTemporary()
| |
| return type(self.expiry) == 'number'
| |
| end | | end |
|
| |
|
| function Protection:makeProtectionCategory() | | function p.matchNamespace(ns) |
| if not self:shouldHaveProtectionCategory() then | | -- Matches a namespace number to a string that can be passed to the |
| return '' | | -- namespace parameter of p.getCategoryName. |
| | if not ns or type(ns) ~= 'number' then |
| | return nil |
| end | | end |
| | | local nskey = categoryNamespaces[ns] |
| local cfg = self._cfg
| | if not nskey and ns % 2 == 1 then |
| local title = self.title | | nskey = 'talk' |
|
| |
| -- Get the expiry key fragment.
| |
| local expiryFragment
| |
| 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, protType, protLevel, 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. |
| | --]] |
| | cats = cats or categories |
|
| |
|
| -- 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 | | -- Define the initial order to test properties in. The subtable position |
| -- position in the cfg.protectionCategories table. | | -- is the order the properties will be tested in, and the pos value in |
| local order = { | | -- each subtable is the position of the value in the category key. |
| {val = expiryFragment, keypos = 1}, | | --]] |
| {val = namespaceFragment, keypos = 2}, | | local properties = { |
| {val = self.reason, keypos = 3}, | | {pos = 5, val = expiry}, |
| {val = self.level, keypos = 4}, | | {pos = 3, val = p.matchNamespace(namespace)}, |
| {val = self.action, keypos = 5} | | {pos = 4, val = reason}, |
| | {pos = 2, val = protLevel}, |
| | {pos = 1, val = protType} |
| } | | } |
|
| |
|
| --[[ | | --[[ |
| -- The old protection templates used an ad-hoc protection category system, | | -- Validate reason, and if it is specified as a "namespaceFirst" reason, |
| -- with some templates prioritising namespaces in their categories, and
| | -- move the namespace subtable to the end of the properties table. |
| -- others prioritising the protection reason. To emulate this in this module
| | -- This is necessary to accommodate reasons like "vandalism", as the old |
| -- we use the config table cfg.reasonsWithNamespacePriority to set the | | -- {{pp-vandalism}} template used namespace categories rather than |
| -- reasons for which namespaces have priority over protection reason.
| | -- vandalism categories if they were available. |
| -- 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 behavior |
|
| | if not reason then |
| | behavior = 'reasonFirst' |
| | else |
| | behavior = behaviors[reason] |
| | end |
| | if behavior == 'namespaceFirst' then |
| | toTableEnd(properties, 2) -- move namespace to end |
| | elseif behavior == 'reasonFirst' then |
| | toTableEnd(properties, 3) -- move reason to end |
| | else |
| | error(reason .. ' is not a valid reason') |
| | end |
| | |
| --[[ | | --[[ |
| -- Define the attempt order. Inactive subtables (subtables with nil "value" | | -- Define the attempt order. Properties with no value defined are moved |
| -- fields) are moved to the end, where they will later be given the key | | -- to the end, where they will later be given the value "all". This is |
| -- "all". This is to cut down on the number of table lookups in
| | -- to cut down on the number of table lookups in the cats table, which |
| -- cfg.protectionCategories, which grows exponentially with the number of | | -- grows exponentially with the number of properties with valid values. |
| -- non-nil keys. We keep track of the number of active subtables with the | | -- We keep track of the number of active properties with the noActive |
| -- noActive parameter. | | -- parameter. |
| --]] | | --]] |
| local noActive, attemptOrder | | local active, inactive = {}, {} |
| do
| | for i, t in ipairs(properties) do |
| local active, inactive = {}, {}
| | if t.val then |
| for i, t in ipairs(order) do
| | active[#active + 1] = t |
| if t.val then
| | else |
| active[#active + 1] = t
| | inactive[#inactive + 1] = t |
| else
| |
| inactive[#inactive + 1] = t
| |
| end
| |
| end
| |
| noActive = #active
| |
| attemptOrder = active
| |
| for i, t in ipairs(inactive) do
| |
| attemptOrder[#attemptOrder + 1] = t
| |
| end | | end |
| 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 | | -- 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 |
290번째 줄: |
224번째 줄: |
| -- 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 = {} |
| for j, t in ipairs(attemptOrder) do | | for j, t in ipairs(attemptOrder) do |
| | local pos = t.pos |
| | local val = t.val |
| if j > noActive then | | if j > noActive then |
| key[t.keypos] = 'all' | | key[pos] = 'all' |
| 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[pos] = val |
| else | | else |
| key[t.keypos] = 'all' | | key[pos] = 'all' |
| end | | end |
| end | | end |
| end | | end |
| key = table.concat(key, '|') | | key = tconcat(key, '-') |
| | mw.log(key) -- for debugging |
| 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:shouldHaveProtectionCategory()
| | -- 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 |
| -- Get explanation blurb table keys | | -- right - the "right" css property value, as a string |
| local action = self._protectionObj.action | | -- |
| local level = self._protectionObj.level | | -- Both parameters are optional. |
| local talkKey = self._protectionObj.title.isTalkPage and 'talk' or 'subject' | | --]] |
| | | local root = mw.html.create('div') |
| -- Find the message in the explanation blurb table and substitute any | | root |
| -- parameters. | | :addClass('metadata topicon nopopups') |
| local explanations = self._cfg.explanationBlurbs | | :attr('id', 'protected-icon') |
| local msg
| | :css{display = 'none', right = right or '55px'} |
| if explanations[action][level] and explanations[action][level][talkKey] then
| | :wikitext(image) |
| msg = explanations[action][level][talkKey]
| | return tostring(root) |
| 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 mw.getCurrentFrame():expandTemplate{
| |
| title="vandal-m",
| |
| args={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)
| |
| 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
| | return mMessageBox.main('mbox', mbargs) |
| | |
| 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 not yesno(args.catonly) and (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:shouldShowLock() 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 |