Module:Namespace detect

Module documentation[view] [edit] [history] [purge]

This module allows you to output different text depending on thenamespacethat a given page is in. It is aLuaimplementation of the {{namespace detect}} template, with a few improvements: all namespaces and all namespace aliases are supported, and namespace names are detected automatically for the local wiki.

Usage

{{#invoke: Namespace detect | main
| main = <!-- text to return for the main namespace -->
| talk = <!-- text to return for talk namespaces -->

<!-- text to return for specific subject namespaces -->
| portal =
| category =
| user =
| wikisource =
| ws =
| index =
| page =
| mediawiki =
| author =
| translation =
| template =
| special =
| media =
| file =
| image =
| help =
| module =

| other = <!-- text to return for unspecified namespaces -->
| demopage = <!-- page to detect namespace for, if not the current page -->
| demospace = <!-- namespace to display text for -->

| subjectns = <!-- set to "yes" to treat talk pages as the corresponding subject page -->
}}

Parameters

• main- text to return if the page is in the main namespace.
• talk- text to return if the page is in a talk namespace. This can be any talk namespace - it will match any of "Talk:", "Wikipedia talk:", "User talk:", etc.
• Subject namespace parameters, e.g.wikipedia,user,file... - the text to return if the page is in the corresponding namespace. This module accepts all subject namespaces as parameters, includingnamespace aliasesandvirtual namespaces.See below for a list of supported values.
• other- text to return if no parameters for the page's namespace were specified. This text is also returned if|demospace=is set to an invalid namespace value.
• subjectns- if on a talk page, use the corresponding subject page. Can be set with values of "yes", "y", "true" or "1".
• demopage- specifies a page to detect the namespace of. If not specified, and if the|demospace=parameter is not set, then the module uses the current page.
• demospace- force the module to behave as if the page was in the specified namespace. Often used for demonstrations.

Namespace parameters

Possible values for subject namespace parameters are as follows:

Namespace	Aliases
main
user
wikisource	project,ws
file	image
mediawiki
template
help	h
category
portal
author
page
index
translation
timedtext
module

Table function

Use the following to display a table with the different possible namespace parameters:

{{#invoke:Namespace detect|table|talk=yes}}

To include the parameter for talk namespaces, use|talk=yes.

Porting to different wikis

This module is designed to be portable. To use it on a different wiki, all you need to do is to change the values inModule:Namespace detect/config.Instructions are available on that page.

Technical details

The module uses a data page atModule:Namespace detect/data.This page is loaded withmw.loadData,which means it is processed once per page rather than once per #invoke. This was done for performance reasons.

The abovedocumentationistranscludedfromModule:Namespace detect/doc.(edit|history)
Editors can experiment in this module'ssandbox(edit|diff)and testcases(create)pages.
Subpages of this module.

--[[
--------------------------------------------------------------------------------
-- --
-- NAMESPACE DETECT --
-- --
-- This module implements the {{namespace detect}} template in Lua, with a --
-- few improvements: all namespaces and all namespace aliases are supported, --
-- 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 --
-- by altering the values in the "cfg" table in --
-- Module:Namespace detect/config. --
-- --
--------------------------------------------------------------------------------
--]]

localdata=mw.loadData('Module:Namespace detect/data')
localargKeys=data.argKeys
localcfg=data.cfg
localmappings=data.mappings

localyesno=require('Module:Yesno')
localmArguments-- Lazily initialise Module:Arguments
localmTableTools-- Lazily initilalise Module:TableTools
localustringLower=mw.ustring.lower

localp={}

localfunctionfetchValue(t1,t2)
-- Fetches a value from the table t1 for the first key in array t2 where
-- a non-nil value of t1 exists.
fori,keyinipairs(t2)do
localvalue=t1[key]
ifvalue~=nilthen
returnvalue
end
end
returnnil
end

localfunctionequalsArrayValue(t,value)
-- Returns true if value equals a value in the array t. Otherwise
-- returns false.
fori,arrayValueinipairs(t)do
ifvalue==arrayValuethen
returntrue
end
end
returnfalse
end

functionp.getPageObject(page)
-- Get the page object, passing the function through pcall in case of
-- errors, e.g. being over the expensive function count limit.
ifpagethen
localsuccess,pageObject=pcall(mw.title.new,page)
ifsuccessthen
returnpageObject
else
returnnil
end
else
returnmw.title.getCurrentTitle()
end
end

-- Provided for backward compatibility with other modules
functionp.getParamMappings()
returnmappings
end

localfunctiongetNamespace(args)
-- This function gets the namespace name from the page object.
localpage=fetchValue(args,argKeys.demopage)
ifpage==''then
page=nil
end
localdemospace=fetchValue(args,argKeys.demospace)
ifdemospace==''then
demospace=nil
end
localsubjectns=fetchValue(args,argKeys.subjectns)
localret
ifdemospacethen
-- Handle "demospace = main" properly.
ifequalsArrayValue(argKeys.main,ustringLower(demospace))then
ret=mw.site.namespaces[0].name
else
ret=demospace
end
else
localpageObject=p.getPageObject(page)
ifpageObjectthen
ifpageObject.isTalkPagethen
-- Get the subject namespace if the option is set,
-- otherwise use "talk".
ifyesno(subjectns)then
ret=mw.site.namespaces[pageObject.namespace].subject.name
else
ret='talk'
end
else
ret=pageObject.nsText
end
else
returnnil-- return nil if the page object doesn't exist.
end
end
ret=ret:gsub('_',' ')
returnustringLower(ret)
end

functionp._main(args)
-- Check the parameters stored in the mappings table for any matches.
localnamespace=getNamespace(args)or'other'-- "other" avoids nil table keys
localparams=mappings[namespace]or{}
localret=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.
--]]
ifret==nilthen
ret=fetchValue(args,argKeys.other)
end
returnret
end

functionp.main(frame)
mArguments=require('Module:Arguments')
localargs=mArguments.getArgs(frame,{removeBlanks=false})
localret=p._main(args)
returnretor''
end

functionp.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')
localnamespaces=mw.site.namespaces
localcfg=data.cfg
localuseTalk=type(frame)=='table'
andtype(frame.args)=='table'
andyesno(frame.args.talk)-- Whether to use the talk parameter.

-- Get the header names.
localfunctioncheckValue(value,default)
iftype(value)=='string'then
returnvalue
else
returndefault
end
end
localnsHeader=checkValue(cfg.wikitableNamespaceHeader,'Namespace')
localaliasesHeader=checkValue(cfg.wikitableAliasesHeader,'Aliases')

-- Put the namespaces in order.
localmappingsOrdered={}
fornsname,paramsinpairs(mappings)do
ifuseTalkornsname~='talk'then
localnsid=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.
localret='{| class= "wikitable" '
..'\n|-'
..'\n!'..nsHeader
..'\n!'..aliasesHeader
fori,paramsinipairs(mappingsOrdered)do
forj,paraminipairs(params)do
ifj==1then
ret=ret..'\n|-'
..'\n| <code>'..param..'</code>'
..'\n| '
elseifj==2then
ret=ret..'<code>'..param..'</code>'
else
ret=ret..', <code>'..param..'</code>'
end
end
end
ret=ret..'\n|-'
..'\n|}'
returnret
end

returnp