최신판 |
당신의 편집 |
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 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)
| | -- $1 = "until" or "or until" depending on the expiry |
| if not lang then | | -- $2 = "disputes", with or without a section link |
| lang = mw.language.getContentLanguage() | | -- $3 = the type of the page, e.g. "article", "template", or "page" |
| end | | -- $4 = A blurb "it has been protected for x years, x months and x days." |
| local success, result = pcall(lang.formatDate, lang, 'U', dateString) | | -- $5 = the protection date |
| if success then | | blp = { |
| result = tonumber(result) | | text = 'to promote compliance with' |
| if result then | | .. '[[Wikipedia:Biographies of living persons' |
| return result | | .. "|Wikipedia's policy on the biographies" |
| end | | .. ' of living people]]', |
| end | | tooltip = 'to promote compliance with the policy on biographies of' |
| error(string.format( | | .. ' living people', |
| 'invalid %s: %s', | | categoryOrder = 'reason', |
| dateType, | | }, |
| tostring(dateString) | | dispute = { |
| ), 4) | | text = '$1 editing $2 have been resolved', |
| end
| | tooltip = 'due to editing disputes', |
| | dispute = true, |
| | categoryOrder = 'reason', |
| | }, |
| | office = { |
| | text = 'This $3 is currently under the scrutiny of the' |
| | .. ' [[Wikipedia:Office actions|Wikimedia Foundation Office]]' |
| | .. ' and is protected. $4', |
| | categoryOrder = 'reason', |
| | }, |
| | reset = { |
| | text = 'On $5 this article was reduced to a simplified,' |
| | ..' "bare bones" version so that it may be completely rewritten to' |
| | .. ' ensure it meets the policies of' |
| | .. ' [[WP:NPOV|Neutral Point of View]] and [[WP:V|Verifiability]].' |
| | .. ' Standard Wikipedia policies will apply to its rewriting—which' |
| | .. ' will eventually be open to all editors—and will be strictly' |
| | .. ' enforced. The article has been placed under a level of' |
| | .. ' semi-protection temporarily during the rebuilding of this' |
| | .. ' article.\n\nAny insertion of material directly from' |
| | .. ' pre-protection revisions of the article will be removed, as' |
| | .. ' will any material added to the article that is not properly' |
| | .. ' sourced. The associated talk page(s) were also cleared on the' |
| | .. " same date.\n\n'''Administrators may not override this action" |
| | .. ' without approval from someone from the [[WP:OFFICE|Office]].' |
| | .. " No editor may remove this notice.'''", |
| | categoryOrder = 'reason', |
| | categoryReason = 'office', |
| | }, |
| | sock = { |
| | text = 'to prevent [[Wikipedia:Sock puppetry|sock puppets]] of' |
| | .. ' [[Wikipedia:Blocking policy|blocked]] or' |
| | .. ' [[Wikipedia:List of banned users|banned users]]' |
| | .. ' from editing it', |
| | tooltip = 'to prevent sock puppets of blocked or banned users from' |
| | .. ' editing it', |
| | categoryOrder = 'reason', |
| | }, |
| | 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]].', |
| | categoryReason = 'all', |
| | }, |
| | vandalism = { |
| | text = 'due to [[Wikipedia:Vandalism|vandalism]]', |
| | tooltip = 'due to vandalism', |
| | categoryOrder = 'namespace', |
| | }, |
| | } |
|
| |
|
| local function makeFullUrl(page, query, display)
| | cfg.categories = { |
| return string.format( | | -- The key strings follow this format: |
| '[%s %s]',
| | -- type, level, ns, reason, expiry |
| tostring(mw.uri.fullUrl(page, query)),
| | ['all-all-all-all-all'] = 'Wikipedia protected pages', |
| display
| | ['all-all-all-office-all'] = 'Wikipedia Office-protected pages', |
| ) | | ['edit-all-template-all-all'] = 'Wikipedia protected templates', |
| end
| | ['edit-autoconfirmed-all-all-all'] = 'Wikipedia semi-protected pages', |
| | ['edit-autoconfirmed-all-all-indef'] = 'Wikipedia indefinitely semi-protected pages', |
| | ['edit-autoconfirmed-all-blp-all'] = 'Wikipedia indefinitely semi-protected biographies of living people', |
| | ['edit-autoconfirmed-all-blp-temp'] = 'Wikipedia temporarily semi-protected biographies of living people', |
| | ['edit-autoconfirmed-all-dispute-all'] = 'Wikipedia pages semi-protected due to dispute', |
| | ['edit-autoconfirmed-all-sock-all'] = 'Wikipedia pages semi-protected from banned users', |
| | ['edit-autoconfirmed-all-vandalism-all'] = 'Wikipedia pages semi-protected against vandalism', |
| | ['edit-autoconfirmed-category-all-all'] = 'Wikipedia semi-protected categories', |
| | ['edit-autoconfirmed-file-all-all'] = 'Semi-protected images', |
| | ['edit-autoconfirmed-portal-all-all'] = 'Semi-protected portals', |
| | ['edit-autoconfirmed-project-all-all'] = 'Semi-protected project pages', |
| | ['edit-autoconfirmed-talk-all-all'] = 'Semi-protected talk pages', |
| | ['edit-autoconfirmed-template-all-all'] = 'Wikipedia semi-protected templates', |
| | ['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', |
| | ['autoreview-autoconfirmed-all-all-all'] = 'Wikipedia pending changes protected pages (level 1)', |
| | ['autoreview-reviewer-all-all-all'] = 'Wikipedia pending changes protected pages (level 2)', |
| | } |
|
| |
|
| -- Given a directed graph formatted as node -> table of direct successors,
| | cfg.categoryNamespaces = { |
| -- get a table of all nodes reachable from a given node (though always
| | [2] = 'user', |
| -- including the given node).
| | [3] = 'user', |
| local function getReachableNodes(graph, start)
| | [4] = 'project', |
| local toWalk, retval = {[start] = true}, {} | | [6] = 'file', |
| while true do | | [10] = 'template', |
| -- Can't use pairs() since we're adding and removing things as we're iterating
| | [12] = 'project', |
| local k = next(toWalk) -- This always gets the "first" key
| | [14] = 'category', |
| if k == nil then
| | [100] = 'portal', |
| 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 = {
| | 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 mProtectionLevel = require('Module:Effective protection level')._main |
| elseif Protection.supportedActions[args.action] then
| | local mMessageBox -- only needs to be loaded if we are outputting a banner, so lazily initialise |
| obj.action = args.action
| |
| else
| |
| error(string.format(
| |
| 'invalid action: %s',
| |
| tostring(args.action)
| |
| ), 3)
| |
| end
| |
| | |
| -- Set level
| |
| obj.level = args.demolevel or effectiveProtectionLevel(obj.action, obj.title)
| |
| 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
| |
| local effectiveExpiry = effectiveProtectionExpiry(obj.action, obj.title)
| |
| if effectiveExpiry == 'infinity' then
| |
| obj.expiry = 'indef'
| |
| elseif effectiveExpiry ~= 'unknown' then
| |
| obj.expiry = validateDate(effectiveExpiry, 'expiry date')
| |
| end
| |
|
| |
|
| -- Set reason
| | -- Define often-used functions as local variables. |
| if args[1] then
| | local tconcat = table.concat |
| obj.reason = mw.ustring.lower(args[1])
| | local tinsert = table.insert |
| if obj.reason:find('|') then
| | local tremove = table.remove |
| error('reasons cannot contain the pipe character ("|")', 3)
| | local ceil = math.ceil |
| end
| | local format = string.format |
| end
| |
|
| |
|
| -- Set protection date
| | local function toTableEnd(t, pos) |
| if args.date then
| | -- Sends the value at position pos to the end of array t, and shifts the |
| obj.protectionDate = validateDate(args.date, 'protection date')
| | -- other items down accordingly. |
| end | | return tinsert(t, tremove(t, pos)) |
|
| |
| -- 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 | | end |
|
| |
|
| function Protection:isUserScript()
| | local p = {} |
| -- 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() | | function p.main(frame) |
| return self.level ~= '*' | | local args = mArguments.getArgs(frame) |
| | return p._main(args) |
| end | | end |
|
| |
|
| function Protection:shouldShowLock() | | function p._main(args) |
| -- Whether we should output a banner/padlock | | local title |
| return self:isProtected() and not self:isUserScript() | | if args.page then |
| | title = mw.title.new(args.page) |
| | else |
| | title = mw.title.getCurrentTitle() |
| | end |
| | local protectionData = p.getProtectionData(title) |
| end | | end |
|
| |
|
| -- Whether this page needs a protection category. | | function p.getProtectionData(title) |
| Protection.shouldHaveProtectionCategory = Protection.shouldShowLock
| | -- Gets a table containing protection data for the given title. The data |
| | -- is cached using a metatable, and so can be indexed as needed without |
| | -- a performance loss. |
| | local protectionData = {} |
| | local actions = { |
| | create = true, |
| | edit = true, |
| | move = true, |
| | autoreview = true |
| | } |
| | setmetatable(protectionData, { |
| | __index = function (t, key) |
| | local level |
| | if actions[key] then |
| | 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 |
| | protectionData[key] = level |
| | return level |
| | end |
| | }) |
| | return protectionData |
| | 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) |
| 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 = cfg.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, 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. |
| | --]] |
| | cats = cats or cfg.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 properties table. Each property is a table containing the |
| -- position in the cfg.protectionCategories table. | | -- canonical order that the property is tested in, the position the |
| local order = { | | -- property has in the category key strings, and the property value itself. |
| {val = expiryFragment, keypos = 1}, | | --]] |
| {val = namespaceFragment, keypos = 2}, | | local properties = { |
| {val = self.reason, keypos = 3}, | | expiry = {order = 1, keypos = 5, val = expiry}, |
| {val = self.level, keypos = 4}, | | namespace = {order = 2, keypos = 3, val = p.matchNamespace(namespace)}, |
| {val = self.action, keypos = 5} | | reason = {order = 3, keypos = 4, val = reason}, |
| | level = {order = 4, keypos = 2, val = level}, |
| | action = {order = 5, keypos = 1, val = action} |
| } | | } |
|
| |
|
| --[[ | | --[[ |
| -- The old protection templates used an ad-hoc protection category system, | | -- Load the category order configuration for the reason specified. |
| -- with some templates prioritising namespaces in their categories, and | | -- The configuration is stored in the categoryOrder field of each reason |
| -- others prioritising the protection reason. To emulate this in this module | | -- subtable of cfg.reasons. If the value is a table, then the order is the |
| -- we use the config table cfg.reasonsWithNamespacePriority to set the | | -- values specified in the table. If the value is a string, then the |
| -- reasons for which namespaces have priority over protection reason. | | -- property corresponding to that string is tested last (i.e. it is the most |
| -- If we are dealing with one of those reasons, move the namespace table to | | -- important, because it keeps its specified value the longest) and the |
| -- the end of the order table, i.e. give it highest priority. If not, the | | -- other properties are tested in the canonical order. If the value is of |
| -- reason should have highest priority, so move that to the end of the table | | -- any other type then the canonical order is used. |
| -- instead.
| |
| --]] | | --]] |
| table.insert(order, table.remove(order, self.reason and cfg.reasonsWithNamespacePriority[self.reason] and 2 or 3)) | | local reasonTable = reason and cfg.reasons[reason] |
|
| | local categoryOrder = reasonTable and reasonTable.categoryOrder |
| --[[ | | local categoryOrderType = type(categoryOrder) |
| -- Define the attempt order. Inactive subtables (subtables with nil "value"
| | local configOrder = {} |
| -- fields) are moved to the end, where they will later be given the key
| | if categoryOrderType == 'table' then |
| -- "all". This is to cut down on the number of table lookups in
| | local dupes = {} |
| -- cfg.protectionCategories, which grows exponentially with the number of
| | for i = 1, 5 do |
| -- non-nil keys. We keep track of the number of active subtables with the
| | local propertiesKey = categoryOrder[i] |
| -- noActive parameter.
| | if not propertiesKey then |
| --]]
| | local msg = 'no entry found for key ' |
| local noActive, attemptOrder
| | .. i |
| do
| | .. ' in the cfg.reasons.' |
| local active, inactive = {}, {}
| | .. reason |
| for i, t in ipairs(order) do
| | .. '.categoryOrder table' |
| if t.val then | | error(msg) |
| active[#active + 1] = t | | 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 | | 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 |
| | if categoryOrderType == 'string' then |
| | local property = properties[categoryOrder] |
| | if not property then |
| | local msg = '"' |
| | .. categoryOrder |
| | .. '" is not a valid value of cfg.reasons.' |
| | .. reason |
| | .. '.categoryOrder' |
| | error(msg) |
| | end |
| | 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 |
290번째 줄: |
383번째 줄: |
| -- 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 = {} |
305번째 줄: |
397번째 줄: |
| 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 |
313번째 줄: |
405번째 줄: |
| 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( |
| 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:shouldHaveProtectionCategory()
| |
| 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 | | end |
|
| |
|
| function Blurb:_getExpandedMessage(msgKey) | | function p.renderImageLink(image, size, link, text, alt) |
| return self:_substituteParameters(self._cfg.msg[msgKey])
| | --[[ |
| end
| | -- Renders the image link wikitext All parameters are optional |
| | | -- apart from the display text. |
| function Blurb:_substituteParameters(msg)
| | -- |
| if not self._params then
| | -- @parameters: |
| local parameterFuncs = {}
| | -- image - the image name |
| | | -- size - the image size, as a number |
| parameterFuncs.CURRENTVERSION = self._makeCurrentVersionParameter
| | -- link - page linked to by the image |
| parameterFuncs.EDITREQUEST = self._makeEditRequestParameter
| | -- text - the tooltip text |
| parameterFuncs.EXPIRY = self._makeExpiryParameter
| | -- alt - the alt text |
| parameterFuncs.EXPLANATIONBLURB = self._makeExplanationBlurbParameter
| | -- |
| parameterFuncs.IMAGELINK = self._makeImageLinkParameter
| | -- All parameters are optional apart from the text parameter. |
| parameterFuncs.INTROBLURB = self._makeIntroBlurbParameter
| | --]] |
| parameterFuncs.INTROFRAGMENT = self._makeIntroFragmentParameter
| | image = image or 'Transparent.gif' |
| parameterFuncs.PAGETYPE = self._makePagetypeParameter
| | size = size or 20 |
| parameterFuncs.PROTECTIONBLURB = self._makeProtectionBlurbParameter
| | if link then |
| parameterFuncs.PROTECTIONDATE = self._makeProtectionDateParameter
| | link = '|link=' .. link |
| 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
| |
| | |
| 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 | | end |
| requestType = requestType or 'full' | | text = text or error('No text parameter supplied to p.renderImageLink') |
| | | if alt then |
| -- Get the display value.
| | alt = '|alt=' .. alt |
| 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 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) | | return mMessageBox.main('mbox', mbargs) |
| end | | end |
|
| |
|
| -------------------------------------------------------------------------------- | | --[[ |
| -- Padlock class
| | When to add "Category:Wikipedia pages with incorrect protection templates": |
| --------------------------------------------------------------------------------
| | * If it uses a type which is incompatible with the actual protection level of a page, or |
| | * If an expiry date is set and is in the past |
|
| |
|
| local Padlock = setmetatable({}, BannerTemplate)
| | When to add "Category:Wikipedia protected pages without expiry": |
| Padlock.__index = Padlock
| | * No expiry is set, and |
| | | * Expiry can be set, and |
| function Padlock.new(protectionObj, blurbObj, cfg)
| | * The protection type is not "move" (could change this?), and |
| local obj = BannerTemplate.new(protectionObj, cfg) -- This doesn't need the blurb.
| | * The reason doesn't have "indefinitely protected" categories (pp-blp, pp-semi-indef and pp-move-indef have these), and |
| obj.imageWidth = 20
| | * The reason is not the generic pp-protected (could change this?) |
| obj.imageCaption = blurbObj:makeBannerText('tooltip')
| | (This leaves reasons "dispute", "vandalism", "usertalk", and "sock") |
| 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 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
| |
|
| |
|
| return p | | return p |