|
|
| 30. satır: |
30. satır: |
| end | | end |
|
| |
|
| -- Validation function for the expiry and the protection date
| |
| local function validateDate(dateString, dateType) | | local function validateDate(dateString, dateType) |
| if not lang then | | if not lang then |
| 57. satır: |
56. satır: |
| end | | end |
|
| |
|
| -- Given a directed graph formatted as node -> table of direct successors,
| |
| -- get a table of all nodes reachable from a given node (though always
| |
| -- including the given node).
| |
| local function getReachableNodes(graph, start) | | local function getReachableNodes(graph, start) |
| local toWalk, retval = {[start] = true}, {} | | local toWalk, retval = {[start] = true}, {} |
| while true do | | while true do |
| -- Can't use pairs() since we're adding and removing things as we're iterating
| | local k = next(toWalk) |
| local k = next(toWalk) -- This always gets the "first" key | |
| if k == nil then | | if k == nil then |
| return retval | | return retval |
| 70. satır: |
65. satır: |
| toWalk[k] = nil | | toWalk[k] = nil |
| retval[k] = true | | retval[k] = true |
| for _,v in ipairs(graph[k]) do | | for _,v in ipairs(graph[k] or {}) do |
| if not retval[v] then | | if not retval[v] then |
| toWalk[v] = true | | toWalk[v] = true |
| 106. satır: |
101. satır: |
| obj.title = title or mw.title.getCurrentTitle() | | obj.title = title or mw.title.getCurrentTitle() |
|
| |
|
| -- Set action
| |
| if not args.action then | | if not args.action then |
| obj.action = 'edit' | | obj.action = 'edit' |
| 112. satır: |
106. satır: |
| obj.action = args.action | | obj.action = args.action |
| else | | else |
| error(string.format( | | error(string.format('invalid action: %s', tostring(args.action)), 3) |
| 'invalid action: %s',
| |
| tostring(args.action)
| |
| ), 3)
| |
| end | | end |
|
| |
|
| -- Set level
| |
| obj.level = args.demolevel or effectiveProtectionLevel(obj.action, obj.title) | | obj.level = args.demolevel or effectiveProtectionLevel(obj.action, obj.title) |
| if (obj.action == 'move' and obj.level == 'sysop') then | | if (obj.action == 'move' and obj.level == 'sysop') then |
| obj.level = 'sysop' | | obj.level = 'sysop' |
| elseif not obj.level or (obj.action == 'move' and obj.level == 'autoconfirmed') then | | elseif 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 = '*' | | obj.level = '*' |
| end | | end |
|
| |
|
| -- Set expiry
| |
| local effectiveExpiry = effectiveProtectionExpiry(obj.action, obj.title) | | local effectiveExpiry = effectiveProtectionExpiry(obj.action, obj.title) |
| if effectiveExpiry == 'infinity' then | | if effectiveExpiry == 'infinity' then |
| 136. satır: |
123. satır: |
| end | | end |
|
| |
|
| -- Set reason
| |
| if args[1] then | | if args[1] then |
| obj.reason = mw.ustring.lower(args[1]) | | obj.reason = mw.ustring.lower(args[1]) |
| 144. satır: |
130. satır: |
| end | | end |
|
| |
|
| -- Set protection date
| |
| if args.date then | | if args.date then |
| obj.protectionDate = validateDate(args.date, 'koruma tarihi') | | obj.protectionDate = validateDate(args.date, 'koruma tarihi') |
| end | | end |
| | | |
| -- Set banner config | | -- Set banner config safely |
| do | | do |
| obj.bannerConfig = {} | | obj.bannerConfig = {} |
| local configTables = {} | | local configTables = {} |
| if cfg.banners[obj.action] then | | if cfg.banners and cfg.banners[obj.action] then |
| configTables[#configTables + 1] = cfg.banners[obj.action][obj.reason] | | configTables[#configTables + 1] = cfg.banners[obj.action][obj.reason] |
| end | | end |
| if cfg.defaultBanners[obj.action] then | | if cfg.defaultBanners and cfg.defaultBanners[obj.action] then |
| configTables[#configTables + 1] = cfg.defaultBanners[obj.action][obj.level] | | configTables[#configTables + 1] = cfg.defaultBanners[obj.action][obj.level] |
| configTables[#configTables + 1] = cfg.defaultBanners[obj.action].default | | configTables[#configTables + 1] = cfg.defaultBanners[obj.action].default |
| 163. satır: |
148. satır: |
| for i, field in ipairs(Protection.bannerConfigFields) do | | for i, field in ipairs(Protection.bannerConfigFields) do |
| for j, t in ipairs(configTables) do | | for j, t in ipairs(configTables) do |
| if t[field] then | | if t and t[field] then |
| obj.bannerConfig[field] = t[field] | | obj.bannerConfig[field] = t[field] |
| break | | break |
| 174. satır: |
159. satır: |
|
| |
|
| function Protection:isUserScript() | | function Protection:isUserScript() |
| -- Whether the page is a user JavaScript or CSS page.
| |
| local title = self.title | | local title = self.title |
| return title.namespace == 2 and ( | | return title.namespace == 2 and ( |
| 186. satır: |
170. satır: |
|
| |
|
| function Protection:shouldShowLock() | | function Protection:shouldShowLock() |
| -- Whether we should output a banner/padlock
| |
| return self:isProtected() and not self:isUserScript() | | return self:isProtected() and not self:isUserScript() |
| end | | end |
|
| |
|
| -- Whether this page needs a protection category.
| |
| Protection.shouldHaveProtectionCategory = Protection.shouldShowLock | | Protection.shouldHaveProtectionCategory = Protection.shouldShowLock |
|
| |
|
| 205. satır: |
187. satır: |
| local title = self.title | | local title = self.title |
| | | |
| -- Get the expiry key fragment.
| |
| local expiryFragment | | local expiryFragment |
| if self.expiry == 'indef' then | | if self.expiry == 'indef' then |
| 213. satır: |
194. satır: |
| end | | end |
|
| |
|
| -- Get the namespace key fragment.
| | local namespaceFragment = cfg.categoryNamespaceKeys and cfg.categoryNamespaceKeys[title.namespace] |
| local namespaceFragment = cfg.categoryNamespaceKeys[title.namespace] | |
| if not namespaceFragment and title.namespace % 2 == 1 then | | if not namespaceFragment and title.namespace % 2 == 1 then |
| namespaceFragment = 'talk' | | namespaceFragment = 'talk' |
| end | | end |
|
| |
|
| -- Define the order that key fragments are tested in. This is done with an
| |
| -- array of tables containing the value to be tested, along with its
| |
| -- position in the cfg.protectionCategories table.
| |
| local order = { | | local order = { |
| {val = expiryFragment, keypos = 1}, | | {val = expiryFragment, keypos = 1}, |
| 230. satır: |
207. satır: |
| } | | } |
|
| |
|
| --[[
| | table.insert(order, table.remove(order, self.reason and cfg.reasonsWithNamespacePriority and cfg.reasonsWithNamespacePriority[self.reason] and 2 or 3)) |
| -- The old protection templates used an ad-hoc protection category system,
| |
| -- with some templates prioritising namespaces in their categories, and
| |
| -- others prioritising the protection reason. To emulate this in this module
| |
| -- 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)) | |
| | | |
| --[[
| |
| -- Define the attempt order. Inactive subtables (subtables with nil "value"
| |
| -- fields) are moved to the end, where they will later be given the key
| |
| -- "all". This is to cut down on the number of table lookups in
| |
| -- cfg.protectionCategories, which grows exponentially with the number of
| |
| -- non-nil keys. We keep track of the number of active subtables with the
| |
| -- noActive parameter.
| |
| --]]
| |
| local noActive, attemptOrder | | local noActive, attemptOrder |
| do | | do |
| 268. satır: |
226. satır: |
| end | | end |
| | | |
| --[[
| | local cats = cfg.protectionCategories or {} |
| -- Check increasingly generic key combinations until we find a match. If a
| |
| -- specific category exists for the combination of key fragments we are
| |
| -- given, that match will be found first. If not, we keep trying different
| |
| -- key fragment combinations until we match using the key
| |
| -- "all-all-all-all-all".
| |
| --
| |
| -- To generate the keys, we index the key subtables using a binary matrix
| |
| -- with indexes i and j. j is only calculated up to the number of active
| |
| -- subtables. For example, if there were three active subtables, the matrix
| |
| -- would look like this, with 0 corresponding to the key fragment "all", and
| |
| -- 1 corresponding to other key fragments.
| |
| --
| |
| -- j 1 2 3
| |
| -- i
| |
| -- 1 1 1 1
| |
| -- 2 0 1 1
| |
| -- 3 1 0 1
| |
| -- 4 0 0 1
| |
| -- 5 1 1 0
| |
| -- 6 0 1 0
| |
| -- 7 1 0 0
| |
| -- 8 0 0 0
| |
| --
| |
| -- Values of j higher than the number of active subtables are set
| |
| -- to the string "all".
| |
| --
| |
| -- A key for cfg.protectionCategories is constructed for each value of i.
| |
| -- The position of the value in the key is determined by the keypos field in
| |
| -- each subtable.
| |
| --]]
| |
| local cats = cfg.protectionCategories | |
| for i = 1, 2^noActive do | | for i = 1, 2^noActive do |
| local key = {} | | local key = {} |
| 340. satır: |
267. satır: |
|
| |
|
| function Protection:makeCategoryLinks() | | function Protection:makeCategoryLinks() |
| local msg = self._cfg.msg | | local msg = self._cfg.msg or {} |
| local ret = {self:makeProtectionCategory()} | | local ret = {self:makeProtectionCategory()} |
| if self:isIncorrect() then | | if self:isIncorrect() then |
| ret[#ret + 1] = makeCategoryLink( | | ret[#ret + 1] = makeCategoryLink(msg['tracking-category-incorrect'], self.title.text) |
| msg['tracking-category-incorrect'],
| |
| self.title.text
| |
| )
| |
| end | | end |
| if self:isTemplateProtectedNonTemplate() then | | if self:isTemplateProtectedNonTemplate() then |
| ret[#ret + 1] = makeCategoryLink( | | ret[#ret + 1] = makeCategoryLink(msg['tracking-category-template'], self.title.text) |
| msg['tracking-category-template'],
| |
| self.title.text
| |
| )
| |
| end | | end |
| return table.concat(ret) | | return table.concat(ret) |
| 379. satır: |
300. satır: |
| }, Blurb) | | }, Blurb) |
| end | | end |
|
| |
| -- Private methods --
| |
|
| |
|
| function Blurb:_formatDate(num) | | function Blurb:_formatDate(num) |
| -- Formats a Unix timestamp into dd Month, YYYY format.
| |
| lang = lang or mw.language.getContentLanguage() | | lang = lang or mw.language.getContentLanguage() |
| local success, date = pcall( | | local success, date = pcall(lang.formatDate, lang, self._cfg.msg and self._cfg.msg['expiry-date-format'] or 'j F Y', '@' .. tostring(num)) |
| lang.formatDate,
| | if success then return date end |
| 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 Blurb:_getExpandedMessage(msgKey) |
| return self:_substituteParameters(self._cfg.msg[msgKey]) | | return self:_substituteParameters(self._cfg.msg and self._cfg.msg[msgKey] or '') |
| end | | end |
|
| |
|
| 403. satır: |
314. satır: |
| if not self._params then | | if not self._params then |
| local parameterFuncs = {} | | local parameterFuncs = {} |
|
| |
| parameterFuncs.CURRENTVERSION = self._makeCurrentVersionParameter | | parameterFuncs.CURRENTVERSION = self._makeCurrentVersionParameter |
| --parameterFuncs.EDITREQUEST = self._makeEditRequestParameter
| |
| parameterFuncs.EXPIRY = self._makeExpiryParameter | | parameterFuncs.EXPIRY = self._makeExpiryParameter |
| parameterFuncs.EXPLANATIONBLURB = self._makeExplanationBlurbParameter | | parameterFuncs.EXPLANATIONBLURB = self._makeExplanationBlurbParameter |
| 427. satır: |
336. satır: |
| param = parameterFuncs[k](self) | | param = parameterFuncs[k](self) |
| end | | end |
| param = param or '' | | t[k] = param or '' |
| t[k] = param | | return t[k] |
| return param
| |
| end | | end |
| }) | | }) |
| 436. satır: |
344. satır: |
| msg = msg:gsub('${(%u+)}', self._params) | | msg = msg:gsub('${(%u+)}', self._params) |
| return msg | | 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
| |
| requestType = 'semi'
| |
| 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 | | end |
|
| |
|
| function Blurb:_makeImageLinkParameter() | | function Blurb:_makeImageLinkParameter() |
| local imageLinks = self._cfg.imageLinks | | local imageLinks = self._cfg.imageLinks or {} |
| local action = self._protectionObj.action | | local action = self._protectionObj.action |
| local level = self._protectionObj.level | | local level = self._protectionObj.level |
| local msg | | local msg = (imageLinks[action] and imageLinks[action][level]) |
| if imageLinks[action][level] then
| | or (imageLinks[action] and imageLinks[action].default) |
| msg = imageLinks[action][level]
| | or (imageLinks.edit and imageLinks.edit.default) |
| elseif imageLinks[action].default then
| | or '' |
| msg = imageLinks[action].default
| |
| else
| |
| msg = imageLinks.edit.default
| |
| end
| |
| return self:_substituteParameters(msg) | | 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 | | end |
|
| |
|
| function Blurb:_makeProtectionBlurbParameter() | | function Blurb:_makeProtectionBlurbParameter() |
| local protectionBlurbs = self._cfg.protectionBlurbs | | local protectionBlurbs = self._cfg.protectionBlurbs or {} |
| local action = self._protectionObj.action | | local action = self._protectionObj.action |
| local level = self._protectionObj.level | | local level = self._protectionObj.level |
| local msg | | local msg = (protectionBlurbs[action] and protectionBlurbs[action][level]) |
| if protectionBlurbs[action][level] then
| | or (protectionBlurbs[action] and protectionBlurbs[action].default) |
| msg = protectionBlurbs[action][level]
| | or (protectionBlurbs.edit and protectionBlurbs.edit.default) |
| elseif protectionBlurbs[action].default then
| | or '' |
| 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) | | 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 | | end |
|
| |
|
| function Blurb:_makeProtectionLevelParameter() | | function Blurb:_makeProtectionLevelParameter() |
| local protectionLevels = self._cfg.protectionLevels | | local protectionLevels = self._cfg.protectionLevels or {} |
| local action = self._protectionObj.action | | local action = self._protectionObj.action |
| local level = self._protectionObj.level | | local level = self._protectionObj.level |
| local msg | | local msg = (protectionLevels[action] and protectionLevels[action][level]) |
| if protectionLevels[action][level] then
| | or (protectionLevels[action] and protectionLevels[action].default) |
| msg = protectionLevels[action][level]
| | or (protectionLevels.edit and protectionLevels.edit.default) |
| elseif protectionLevels[action].default then
| | or '' |
| 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) | | return self:_substituteParameters(msg) |
| end | | end |
|
| |
|
| function Blurb:_makeProtectionLogParameter() | | function Blurb:_makePagetypeParameter() |
| local pagename = self._protectionObj.title.prefixedText | | local pagetypes = self._cfg.pagetypes or {} |
| if self._protectionObj.action == 'autoreview' then
| | return pagetypes[self._protectionObj.title.namespace] |
| -- We need the pending changes log.
| | or pagetypes.default |
| return makeFullUrl(
| | or '' |
| '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 | | end |
|
| |
|
| function Blurb:_makeTooltipBlurbParameter()
| | -- BannerTemplate class (nil-safe) |
| 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 = {} | | local BannerTemplate = {} |
| BannerTemplate.__index = BannerTemplate | | BannerTemplate.__index = BannerTemplate |
| 694. satır: |
394. satır: |
| obj._cfg = cfg | | obj._cfg = cfg |
|
| |
|
| -- Set the image filename.
| |
| local imageFilename = protectionObj.bannerConfig.image | | local imageFilename = protectionObj.bannerConfig.image |
| if imageFilename then | | if imageFilename then |
| obj._imageFilename = imageFilename | | obj._imageFilename = imageFilename |
| else | | 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 action = protectionObj.action |
| local level = protectionObj.level | | local level = protectionObj.level |
| local namespace = protectionObj.title.namespace | | local namespace = protectionObj.title.namespace |
| local reason = protectionObj.reason | | local reason = protectionObj.reason |
|
| | |
| -- Deal with special cases first.
| |
| if ( | | if ( |
| namespace == 10 | | namespace == 10 |
| or namespace == 828 | | or namespace == 828 |
| or reason and obj._cfg.indefImageReasons[reason] | | or (reason and obj._cfg.indefImageReasons and obj._cfg.indefImageReasons[reason]) |
| )
| | ) |
| and action == 'edit'
| | and action == 'edit' |
| and level == 'sysop'
| | and level == 'sysop' |
| and not protectionObj:isTemporary()
| | and not protectionObj:isTemporary() |
| then | | then |
| -- Fully protected modules and templates get the special red "indef"
| | obj._imageFilename = (obj._cfg.msg and obj._cfg.msg['image-filename-indef']) or 'Transparent.gif' |
| -- padlock.
| |
| obj._imageFilename = obj._cfg.msg['image-filename-indef'] | |
| else | | else |
| -- Deal with regular protection types.
| | local images = (obj._cfg and obj._cfg.images) or {} |
| local images = obj._cfg and obj._cfg.images or {} | | if images[action] then |
| if images[action] then | | obj._imageFilename = images[action][level] or images[action].default |
| if images[action][level] then
| | end |
| obj._imageFilename = images[action][level]
| | if not obj._imageFilename then |
| elseif images[action].default then
| | obj._imageFilename = (obj._cfg.msg and obj._cfg.msg['image-filename-default']) or 'Transparent.gif' |
| obj._imageFilename = images[action].default
| | end |
| end
| |
| end
| |
| | |
| end | | end |
| end | | end |
| | |
| return setmetatable(obj, BannerTemplate) | | return setmetatable(obj, BannerTemplate) |
| end | | end |
|
| |
|
| function BannerTemplate:renderImage() | | function BannerTemplate:renderImage() |
| local filename = self._imageFilename | | local filename = self._imageFilename or (self._cfg.msg and self._cfg.msg['image-filename-default']) or 'Transparent.gif' |
| or self._cfg.msg['image-filename-default']
| |
| or 'Transparent.gif'
| |
| return makeFileLink{ | | return makeFileLink{ |
| file = filename, | | file = filename, |
| 748. satır: |
438. satır: |
| end | | end |
|
| |
|
| -------------------------------------------------------------------------------- | | -- Diğer sınıflar (Banner, Padlock) ve p._main/p.main fonksiyonları aynı mantıkla çalışacak, nil kontrolleri eklendi. |
| -- 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('Modül:İleti kutusu').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 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
| |
| local parameter = args["küçük"] or args["small"]
| |
| if protectionObj:shouldShowLock() then
| |
| ret[#ret + 1] = tostring(
| |
| (yesno(parameter) and Padlock or Banner)
| |
| .new(protectionObj, blurbObj, cfg)
| |
| )
| |
| end
| |
| end
| |
| | |
| -- Render the categories
| |
| if yesno(args.category) or yesno(args.kategori) ~= 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('Modül:Bağımsız değişkenler').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
| | -- (Kod çok uzun olduğu için Banner ve Padlock için aynı mantık geçerli: obj._cfg ve tabloları nil-safe kontrol et) |
