|
en>Edokter |
| Line 1: |
Line 1: |
| --[[
| | <span class="nowrap">{{#iferror:{{#expr:{{{1|1}}}}} |
| --------------------------------------------------------------------------------
| | |{{#switch:{{{1}}} |
| -- --
| | |fig=  |
| -- NAMESPACE DETECT --
| | |en=  |
| -- --
| | |em=  |
| -- This module implements the {{namespace detect}} template in Lua, with a --
| | |thin=  |
| -- few improvements: all namespaces and all namespace aliases are supported, --
| | |hair=  |
| -- and namespace names are detected automatically for the local wiki. The --
| | | |
| -- module can also use the corresponding subject namespace value if it is --
| | }} |
| -- used on a talk page. Parameter names can be configured for different wikis --
| | |{{#invoke:String|rep|{{#switch:{{{2}}} |
| -- by altering the values in the "cfg" table in --
| | |fig=  |
| -- Module:Namespace detect/config. --
| | |en=  |
| -- --
| | |em=  |
| --------------------------------------------------------------------------------
| | |thin=  |
| --]]
| | |hair=  |
| | | | |
| local data = mw.loadData('Module:Namespace detect/data')
| | }}|{{{1|1}}}}} |
| local argKeys = data.argKeys
| | }}</span><noinclude> |
| local cfg = data.cfg
| | {{documentation}} |
| local mappings = data.mappings
| | </noinclude> |
| | |
| local yesno = require('Module:Yesno')
| |
| local mArguments -- Lazily initialise Module:Arguments
| |
| local mTableTools -- Lazily initilalise Module:TableTools
| |
| local ustringLower = mw.ustring.lower
| |
| | |
| local p = {}
| |
| | |
| local function fetchValue(t1, t2)
| |
| -- Fetches a value from the table t1 for the first key in array t2 where
| |
| -- a non-nil value of t1 exists.
| |
| for i, key in ipairs(t2) do
| |
| local value = t1[key]
| |
| if value ~= nil then
| |
| return value
| |
| end
| |
| end
| |
| return nil
| |
| end
| |
| | |
| local function equalsArrayValue(t, value)
| |
| -- Returns true if value equals a value in the array t. Otherwise
| |
| -- returns false.
| |
| for i, arrayValue in ipairs(t) do
| |
| if value == arrayValue then
| |
| return true
| |
| end
| |
| end
| |
| return false
| |
| end
| |
| | |
| function p.getPageObject(page)
| |
| -- Get the page object, passing the function through pcall in case of
| |
| -- errors, e.g. being over the expensive function count limit.
| |
| if page then
| |
| local success, pageObject = pcall(mw.title.new, page)
| |
| if success then
| |
| return pageObject
| |
| else
| |
| return nil
| |
| end
| |
| else
| |
| return mw.title.getCurrentTitle()
| |
| end
| |
| end
| |
| | |
| -- Provided for backward compatibility with other modules
| |
| function p.getParamMappings()
| |
| return mappings
| |
| end
| |
| | |
| local function getNamespace(args)
| |
| -- This function gets the namespace name from the page object.
| |
| local page = fetchValue(args, argKeys.demopage)
| |
| if page == '' then
| |
| page = nil
| |
| end
| |
| local demospace = fetchValue(args, argKeys.demospace)
| |
| if demospace == '' then
| |
| demospace = nil
| |
| end
| |
| local subjectns = fetchValue(args, argKeys.subjectns)
| |
| local ret
| |
| if demospace then
| |
| -- Handle "demospace = main" properly.
| |
| if equalsArrayValue(argKeys.main, ustringLower(demospace)) then
| |
| ret = mw.site.namespaces[0].name
| |
| else
| |
| ret = demospace
| |
| end
| |
| else
| |
| local pageObject = p.getPageObject(page)
| |
| if pageObject then
| |
| if pageObject.isTalkPage then
| |
| -- Get the subject namespace if the option is set,
| |
| -- otherwise use "talk".
| |
| if yesno(subjectns) then
| |
| ret = mw.site.namespaces[pageObject.namespace].subject.name
| |
| else
| |
| ret = 'talk'
| |
| end
| |
| else
| |
| ret = pageObject.nsText
| |
| end
| |
| else
| |
| return nil -- return nil if the page object doesn't exist.
| |
| end
| |
| end
| |
| ret = ret:gsub('_', ' ')
| |
| return ustringLower(ret)
| |
| end
| |
| | |
| function p._main(args)
| |
| -- Check the parameters stored in the mappings table for any matches.
| |
| local namespace = getNamespace(args) or 'other' -- "other" avoids nil table keys
| |
| local params = mappings[namespace] or {}
| |
| local ret = fetchValue(args, params)
| |
| --[[
| |
| -- If there were no matches, return parameters for other namespaces.
| |
| -- This happens if there was no text specified for the namespace that
| |
| -- was detected or if the demospace parameter is not a valid
| |
| -- namespace. Note that the parameter for the detected namespace must be
| |
| -- completely absent for this to happen, not merely blank.
| |
| --]]
| |
| if ret == nil then
| |
| ret = fetchValue(args, argKeys.other)
| |
| end
| |
| return ret
| |
| end
| |
| | |
| function p.main(frame)
| |
| mArguments = require('Module:Arguments')
| |
| local args = mArguments.getArgs(frame, {removeBlanks = false})
| |
| local ret = p._main(args)
| |
| return ret or ''
| |
| end
| |
| | |
| function p.table(frame)
| |
| --[[
| |
| -- Create a wikitable of all subject namespace parameters, for
| |
| -- documentation purposes. The talk parameter is optional, in case it
| |
| -- needs to be excluded in the documentation.
| |
| --]]
| |
|
| |
| -- Load modules and initialise variables.
| |
| mTableTools = require('Module:TableTools')
| |
| local namespaces = mw.site.namespaces
| |
| local cfg = data.cfg
| |
| local useTalk = type(frame) == 'table'
| |
| and type(frame.args) == 'table'
| |
| and yesno(frame.args.talk) -- Whether to use the talk parameter.
| |
|
| |
| -- Get the header names.
| |
| local function checkValue(value, default)
| |
| if type(value) == 'string' then
| |
| return value
| |
| else
| |
| return default
| |
| end
| |
| end
| |
| local nsHeader = checkValue(cfg.wikitableNamespaceHeader, 'Namespace')
| |
| local aliasesHeader = checkValue(cfg.wikitableAliasesHeader, 'Aliases')
| |
| | |
| -- Put the namespaces in order.
| |
| local mappingsOrdered = {}
| |
| for nsname, params in pairs(mappings) do
| |
| if useTalk or nsname ~= 'talk' then
| |
| local nsid = namespaces[nsname].id
| |
| -- Add 1, as the array must start with 1; nsid 0 would be lost otherwise.
| |
| nsid = nsid + 1
| |
| mappingsOrdered[nsid] = params
| |
| end
| |
| end
| |
| mappingsOrdered = mTableTools.compressSparseArray(mappingsOrdered)
| |
| | |
| -- Build the table.
| |
| local ret = '{| class="wikitable"'
| |
| .. '\n|-'
| |
| .. '\n! ' .. nsHeader
| |
| .. '\n! ' .. aliasesHeader
| |
| for i, params in ipairs(mappingsOrdered) do
| |
| for j, param in ipairs(params) do
| |
| if j == 1 then
| |
| ret = ret .. '\n|-'
| |
| .. '\n| <code>' .. param .. '</code>'
| |
| .. '\n| '
| |
| elseif j == 2 then
| |
| ret = ret .. '<code>' .. param .. '</code>'
| |
| else
| |
| ret = ret .. ', <code>' .. param .. '</code>'
| |
| end
| |
| end
| |
| end
| |
| ret = ret .. '\n|-'
| |
| .. '\n|}'
| |
| return ret
| |
| end
| |
| | |
| return p
| |
.svg){kind=link}