From WikiProjectMed
Jump to navigation Jump to search

This module provides easy processing of arguments passed from #invoke. It is a meta-module, meant for use by other modules, and should not be called from #invoke directly. Its features include:

  • Easy trimming of arguments and removal of blank arguments.
  • Arguments can be passed by both the current frame and by the parent frame at the same time. (More details below.)
  • Arguments can be passed in directly from another Lua module or from the debug console.
  • Most features can be customized.

Basic use

First, you need to load the module. It contains one function, named getArgs.

local getArgs = require('Module:Arguments').getArgs

In the most basic scenario, you can use getArgs inside your main function. The variable args is a table containing the arguments from #invoke. (See below for details.)

local getArgs = require('Module:Arguments').getArgs
local p = {}

function p.main(frame)
	local args = getArgs(frame)
	-- Main module code goes here.

return p

However, the recommended practice is to use a function just for processing arguments from #invoke. This means that if someone calls your module from another Lua module you don't have to have a frame object available, which improves performance.

local getArgs = require('Module:Arguments').getArgs
local p = {}

function p.main(frame)
	local args = getArgs(frame)
	return p._main(args)

function p._main(args)
	-- Main module code goes here.

return p

If you want multiple functions to use the arguments, and you also want them to be accessible from #invoke, you can use a wrapper function.

local getArgs = require('Module:Arguments').getArgs

local p = {}

local function makeInvokeFunc(funcName)
	return function (frame)
		local args = getArgs(frame)
		return p[funcName](args)

p.func1 = makeInvokeFunc('_func1')

function p._func1(args)
	-- Code for the first function goes here.

p.func2 = makeInvokeFunc('_func2')

function p._func2(args)
	-- Code for the second function goes here.

return p


The following options are available. They are explained in the sections below.

local args = getArgs(frame, {
	trim = false,
	removeBlanks = false,
	valueFunc = function (key, value)
		-- Code for processing one argument
	frameOnly = true,
	parentOnly = true,
	parentFirst = true,
	wrappers = {
		'Template:A wrapper template',
		'Template:Another wrapper template'
	readOnly = true,
	noOverwrite = true

Trimming and removing blanks

Blank arguments often trip up coders new to converting MediaWiki templates to Lua. In template syntax, blank strings and strings consisting only of whitespace are considered false. However, in Lua, blank strings and strings consisting of whitespace are considered true. This means that if you don't pay attention to such arguments when you write your Lua modules, you might treat something as true that should actually be treated as false. To avoid this, by default this module removes all blank arguments.

Similarly, whitespace can cause problems when dealing with positional arguments. Although whitespace is trimmed for named arguments coming from #invoke, it is preserved for positional arguments. Most of the time this additional whitespace is not desired, so this module trims it off by default.

However, sometimes you want to use blank arguments as input, and sometimes you want to keep additional whitespace. This can be necessary to convert some templates exactly as they were written. If you want to do this, you can set the trim and removeBlanks arguments to false.

local args = getArgs(frame, {
	trim = false,
	removeBlanks = false

Custom formatting of arguments

Sometimes you want to remove some blank arguments but not others, or perhaps you might want to put all of the positional arguments in lower case. To do things like this you can use the valueFunc option. The input to this option must be a function that takes two parameters, key and value, and returns a single value. This value is what you will get when you access the field key in the args table.

Example 1: this function preserves whitespace for the first positional argument, but trims all other arguments and removes all other blank arguments.

local args = getArgs(frame, {
	valueFunc = function (key, value)
		if key == 1 then
			return value
		elseif value then
			value = mw.text.trim(value)
			if value ~= '' then
				return value
		return nil

Example 2: this function removes blank arguments and converts all arguments to lower case, but doesn't trim whitespace from positional parameters.

local args = getArgs(frame, {
	valueFunc = function (key, value)
		if not value then
			return nil
		value = mw.ustring.lower(value)
		if mw.ustring.find(value, '%S') then
			return value
		return nil

Note: the above functions will fail if passed input that is not of type string or nil. This might be the case if you use the getArgs function in the main function of your module, and that function is called by another Lua module. In this case, you will need to check the type of your input. This is not a problem if you are using a function specially for arguments from #invoke (i.e. you have p.main and p._main functions, or something similar).

Examples 1 and 2 with type checking

Example 1:

local args = getArgs(frame, {
	valueFunc = function (key, value)
		if key == 1 then
			return value
		elseif type(value) == 'string' then
			value = mw.text.trim(value)
			if value ~= '' then
				return value
				return nil
			return value

Example 2:

local args = getArgs(frame, {
	valueFunc = function (key, value)
		if type(value) == 'string' then
			value = mw.ustring.lower(value)
			if mw.ustring.find(value, '%S') then
				return value
				return nil
			return value

Also, please note that the valueFunc function is called more or less every time an argument is requested from the args table, so if you care about performance you should make sure you aren't doing anything inefficient with your code.

Frames and parent frames

Arguments in the args table can be passed from the current frame or from its parent frame at the same time. To understand what this means, it is easiest to give an example. Let's say that we have a module called Module:ExampleArgs. This module prints the first two positional arguments that it is passed.

Module:ExampleArgs code
local getArgs = require('Module:Arguments').getArgs
local p = {}

function p.main(frame)
	local args = getArgs(frame)
	return p._main(args)

function p._main(args)
	local first = args[1] or ''
	local second = args[2] or ''
	return first .. ' ' .. second

return p

Module:ExampleArgs is then called by Template:ExampleArgs, which contains the code {{#invoke:ExampleArgs|main|firstInvokeArg}}. This produces the result "firstInvokeArg".

Now if we were to call Template:ExampleArgs, the following would happen:

Code Result
{{ExampleArgs}} firstInvokeArg
{{ExampleArgs|firstTemplateArg}} firstInvokeArg
{{ExampleArgs|firstTemplateArg|secondTemplateArg}} firstInvokeArg secondTemplateArg

There are three options you can set to change this behaviour: frameOnly, parentOnly and parentFirst. If you set frameOnly then only arguments passed from the current frame will be accepted; if you set parentOnly then only arguments passed from the parent frame will be accepted; and if you set parentFirst then arguments will be passed from both the current and parent frames, but the parent frame will have priority over the current frame. Here are the results in terms of Template:ExampleArgs:

Code Result
{{ExampleArgs}} firstInvokeArg
{{ExampleArgs|firstTemplateArg}} firstInvokeArg
{{ExampleArgs|firstTemplateArg|secondTemplateArg}} firstInvokeArg
Code Result
{{ExampleArgs|firstTemplateArg}} firstTemplateArg
{{ExampleArgs|firstTemplateArg|secondTemplateArg}} firstTemplateArg secondTemplateArg
Code Result
{{ExampleArgs}} firstInvokeArg
{{ExampleArgs|firstTemplateArg}} firstTemplateArg
{{ExampleArgs|firstTemplateArg|secondTemplateArg}} firstTemplateArg secondTemplateArg


  1. If you set both the frameOnly and parentOnly options, the module won't fetch any arguments at all from #invoke. This is probably not what you want.
  2. In some situations a parent frame may not be available, e.g. if getArgs is passed the parent frame rather than the current frame. In this case, only the frame arguments will be used (unless parentOnly is set, in which case no arguments will be used) and the parentFirst and frameOnly options will have no effect.


The wrappers option is used to specify a limited number of templates as wrapper templates, that is, templates whose only purpose is to call a module. If the module detects that it is being called from a wrapper template, it will only check for arguments in the parent frame; otherwise it will only check for arguments in the frame passed to getArgs. This allows modules to be called by either #invoke or through a wrapper template without the loss of performance associated with having to check both the frame and the parent frame for each argument lookup.

For example, the only content of Template:Side box (excluding content in <noinclude>...</noinclude> tags) is {{#invoke:Side box|main}}. There is no point in checking the arguments passed directly to the #invoke statement for this template, as no arguments will ever be specified there. We can avoid checking arguments passed to #invoke by using the parentOnly option, but if we do this then #invoke will not work from other pages either. If this were the case, the |text=Some text in the code {{#invoke:Side box|main|text=Some text}} would be ignored completely, no matter what page it was used from. By using the wrappers option to specify 'Template:Side box' as a wrapper, we can make {{#invoke:Side box|main|text=Some text}} work from most pages, while still not requiring that the module check for arguments on the Template:Side box page itself.

Wrappers can be specified either as a string, or as an array of strings.

local args = getArgs(frame, {
	wrappers = 'Template:Wrapper template'

local args = getArgs(frame, {
	wrappers = {
		'Template:Wrapper 1',
		'Template:Wrapper 2',
		-- Any number of wrapper templates can be added here.


  1. The module will automatically detect if it is being called from a wrapper template's /sandbox subpage, so there is no need to specify sandbox pages explicitly.
  2. The wrappers option effectively changes the default of the frameOnly and parentOnly options. If, for example, parentOnly were explicitly set to false with wrappers set, calls via wrapper templates would result in both frame and parent arguments being loaded, though calls not via wrapper templates would result in only frame arguments being loaded.
  3. If the wrappers option is set and no parent frame is available, the module will always get the arguments from the frame passed to getArgs.

Writing to the args table

Sometimes it can be useful to write new values to the args table. This is possible with the default settings of this module. (However, bear in mind that it is usually better coding style to create a new table with your new values and copy arguments from the args table as needed.) = 'some value'

It is possible to alter this behaviour with the readOnly and noOverwrite options. If readOnly is set then it is not possible to write any values to the args table at all. If noOverwrite is set, then it is possible to add new values to the table, but it is not possible to add a value if it would overwrite any arguments that are passed from #invoke.

Ref tags

This module uses metatables to fetch arguments from #invoke. This allows access to both the frame arguments and the parent frame arguments without using the pairs() function. This can help if your module might be passed <ref>...</ref> tags as input.

As soon as <ref>...</ref> tags are accessed from Lua, they are processed by the MediaWiki software and the reference will appear in the reference list at the bottom of the article. If your module proceeds to omit the reference tag from the output, you will end up with a phantom reference – a reference that appears in the reference list but without any number linking to it. This has been a problem with modules that use pairs() to detect whether to use the arguments from the frame or the parent frame, as those modules automatically process every available argument.

This module solves this problem by allowing access to both frame and parent frame arguments, while still only fetching those arguments when it is necessary. The problem will still occur if you use pairs(args) elsewhere in your module, however.

Known limitations

The use of metatables also has its downsides. Most of the normal Lua table tools won't work properly on the args table, including the # operator, the next() function, and the functions in the table library. If using these is important for your module, you should use your own argument processing function instead of this module.

  1 -- This module provides easy processing of arguments passed to Scribunto from
  2 -- #invoke. It is intended for use by other Lua modules, and should not be
  3 -- called from #invoke directly.
  5 local libraryUtil = require('libraryUtil')
  6 local checkType = libraryUtil.checkType
  8 local arguments = {}
 10 -- Generate four different tidyVal functions, so that we don't have to check the
 11 -- options every time we call it.
 13 local function tidyValDefault(key, val)
 14 	if type(val) == 'string' then
 15 		val = val:match('^%s*(.-)%s*$')
 16 		if val == '' then
 17 			return nil
 18 		else
 19 			return val
 20 		end
 21 	else
 22 		return val
 23 	end
 24 end
 26 local function tidyValTrimOnly(key, val)
 27 	if type(val) == 'string' then
 28 		return val:match('^%s*(.-)%s*$')
 29 	else
 30 		return val
 31 	end
 32 end
 34 local function tidyValRemoveBlanksOnly(key, val)
 35 	if type(val) == 'string' then
 36 		if val:find('%S') then
 37 			return val
 38 		else
 39 			return nil
 40 		end
 41 	else
 42 		return val
 43 	end
 44 end
 46 local function tidyValNoChange(key, val)
 47 	return val
 48 end
 50 local function matchesTitle(given, title)
 51 	local tp = type( given )
 52 	return (tp == 'string' or tp == 'number') and given ).prefixedText == title
 53 end
 55 local translate_mt = { __index = function(t, k) return k end }
 57 function arguments.getArgs(frame, options)
 58 	checkType('getArgs', 1, frame, 'table', true)
 59 	checkType('getArgs', 2, options, 'table', true)
 60 	frame = frame or {}
 61 	options = options or {}
 63 	--[[
 64 	-- Set up argument translation.
 65 	--]]
 66 	options.translate = options.translate or {}
 67 	if getmetatable(options.translate) == nil then
 68 		setmetatable(options.translate, translate_mt)
 69 	end
 70 	if options.backtranslate == nil then
 71 		options.backtranslate = {}
 72 		for k,v in pairs(options.translate) do
 73 			options.backtranslate[v] = k
 74 		end
 75 	end
 76 	if options.backtranslate and getmetatable(options.backtranslate) == nil then
 77 		setmetatable(options.backtranslate, {
 78 			__index = function(t, k)
 79 				if options.translate[k] ~= k then
 80 					return nil
 81 				else
 82 					return k
 83 				end
 84 			end
 85 		})
 86 	end
 88 	--[[
 89 	-- Get the argument tables. If we were passed a valid frame object, get the
 90 	-- frame arguments (fargs) and the parent frame arguments (pargs), depending
 91 	-- on the options set and on the parent frame's availability. If we weren't
 92 	-- passed a valid frame object, we are being called from another Lua module
 93 	-- or from the debug console, so assume that we were passed a table of args
 94 	-- directly, and assign it to a new variable (luaArgs).
 95 	--]]
 96 	local fargs, pargs, luaArgs
 97 	if type(frame.args) == 'table' and type(frame.getParent) == 'function' then
 98 		if options.wrappers then
 99 			--[[
100 			-- The wrappers option makes Module:Arguments look up arguments in
101 			-- either the frame argument table or the parent argument table, but
102 			-- not both. This means that users can use either the #invoke syntax
103 			-- or a wrapper template without the loss of performance associated
104 			-- with looking arguments up in both the frame and the parent frame.
105 			-- Module:Arguments will look up arguments in the parent frame
106 			-- if it finds the parent frame's title in options.wrapper;
107 			-- otherwise it will look up arguments in the frame object passed
108 			-- to getArgs.
109 			--]]
110 			local parent = frame:getParent()
111 			if not parent then
112 				fargs = frame.args
113 			else
114 				local title = parent:getTitle():gsub('/sandbox$', '')
115 				local found = false
116 				if matchesTitle(options.wrappers, title) then
117 					found = true
118 				elseif type(options.wrappers) == 'table' then
119 					for _,v in pairs(options.wrappers) do
120 						if matchesTitle(v, title) then
121 							found = true
122 							break
123 						end
124 					end
125 				end
127 				-- We test for false specifically here so that nil (the default) acts like true.
128 				if found or options.frameOnly == false then
129 					pargs = parent.args
130 				end
131 				if not found or options.parentOnly == false then
132 					fargs = frame.args
133 				end
134 			end
135 		else
136 			-- options.wrapper isn't set, so check the other options.
137 			if not options.parentOnly then
138 				fargs = frame.args
139 			end
140 			if not options.frameOnly then
141 				local parent = frame:getParent()
142 				pargs = parent and parent.args or nil
143 			end
144 		end
145 		if options.parentFirst then
146 			fargs, pargs = pargs, fargs
147 		end
148 	else
149 		luaArgs = frame
150 	end
152 	-- Set the order of precedence of the argument tables. If the variables are
153 	-- nil, nothing will be added to the table, which is how we avoid clashes
154 	-- between the frame/parent args and the Lua args.
155 	local argTables = {fargs}
156 	argTables[#argTables + 1] = pargs
157 	argTables[#argTables + 1] = luaArgs
159 	--[[
160 	-- Generate the tidyVal function. If it has been specified by the user, we
161 	-- use that; if not, we choose one of four functions depending on the
162 	-- options chosen. This is so that we don't have to call the options table
163 	-- every time the function is called.
164 	--]]
165 	local tidyVal = options.valueFunc
166 	if tidyVal then
167 		if type(tidyVal) ~= 'function' then
168 			error(
169 				"bad value assigned to option 'valueFunc'"
170 					.. '(function expected, got '
171 					.. type(tidyVal)
172 					.. ')',
173 				2
174 			)
175 		end
176 	elseif options.trim ~= false then
177 		if options.removeBlanks ~= false then
178 			tidyVal = tidyValDefault
179 		else
180 			tidyVal = tidyValTrimOnly
181 		end
182 	else
183 		if options.removeBlanks ~= false then
184 			tidyVal = tidyValRemoveBlanksOnly
185 		else
186 			tidyVal = tidyValNoChange
187 		end
188 	end
190 	--[[
191 	-- Set up the args, metaArgs and nilArgs tables. args will be the one
192 	-- accessed from functions, and metaArgs will hold the actual arguments. Nil
193 	-- arguments are memoized in nilArgs, and the metatable connects all of them
194 	-- together.
195 	--]]
196 	local args, metaArgs, nilArgs, metatable = {}, {}, {}, {}
197 	setmetatable(args, metatable)
199 	local function mergeArgs(tables)
200 		--[[
201 		-- Accepts multiple tables as input and merges their keys and values
202 		-- into one table. If a value is already present it is not overwritten;
203 		-- tables listed earlier have precedence. We are also memoizing nil
204 		-- values, which can be overwritten if they are 's' (soft).
205 		--]]
206 		for _, t in ipairs(tables) do
207 			for key, val in pairs(t) do
208 				if metaArgs[key] == nil and nilArgs[key] ~= 'h' then
209 					local tidiedVal = tidyVal(key, val)
210 					if tidiedVal == nil then
211 						nilArgs[key] = 's'
212 					else
213 						metaArgs[key] = tidiedVal
214 					end
215 				end
216 			end
217 		end
218 	end
220 	--[[
221 	-- Define metatable behaviour. Arguments are memoized in the metaArgs table,
222 	-- and are only fetched from the argument tables once. Fetching arguments
223 	-- from the argument tables is the most resource-intensive step in this
224 	-- module, so we try and avoid it where possible. For this reason, nil
225 	-- arguments are also memoized, in the nilArgs table. Also, we keep a record
226 	-- in the metatable of when pairs and ipairs have been called, so we do not
227 	-- run pairs and ipairs on the argument tables more than once. We also do
228 	-- not run ipairs on fargs and pargs if pairs has already been run, as all
229 	-- the arguments will already have been copied over.
230 	--]]
232 	metatable.__index = function (t, key)
233 		--[[
234 		-- Fetches an argument when the args table is indexed. First we check
235 		-- to see if the value is memoized, and if not we try and fetch it from
236 		-- the argument tables. When we check memoization, we need to check
237 		-- metaArgs before nilArgs, as both can be non-nil at the same time.
238 		-- If the argument is not present in metaArgs, we also check whether
239 		-- pairs has been run yet. If pairs has already been run, we return nil.
240 		-- This is because all the arguments will have already been copied into
241 		-- metaArgs by the mergeArgs function, meaning that any other arguments
242 		-- must be nil.
243 		--]]
244 		if type(key) == 'string' then
245 			key = options.translate[key]
246 		end
247 		local val = metaArgs[key]
248 		if val ~= nil then
249 			return val
250 		elseif metatable.donePairs or nilArgs[key] then
251 			return nil
252 		end
253 		for _, argTable in ipairs(argTables) do
254 			local argTableVal = tidyVal(key, argTable[key])
255 			if argTableVal ~= nil then
256 				metaArgs[key] = argTableVal
257 				return argTableVal
258 			end
259 		end
260 		nilArgs[key] = 'h'
261 		return nil
262 	end
264 	metatable.__newindex = function (t, key, val)
265 		-- This function is called when a module tries to add a new value to the
266 		-- args table, or tries to change an existing value.
267 		if type(key) == 'string' then
268 			key = options.translate[key]
269 		end
270 		if options.readOnly then
271 			error(
272 				'could not write to argument table key "'
273 					.. tostring(key)
274 					.. '"; the table is read-only',
275 				2
276 			)
277 		elseif options.noOverwrite and args[key] ~= nil then
278 			error(
279 				'could not write to argument table key "'
280 					.. tostring(key)
281 					.. '"; overwriting existing arguments is not permitted',
282 				2
283 			)
284 		elseif val == nil then
285 			--[[
286 			-- If the argument is to be overwritten with nil, we need to erase
287 			-- the value in metaArgs, so that __index, __pairs and __ipairs do
288 			-- not use a previous existing value, if present; and we also need
289 			-- to memoize the nil in nilArgs, so that the value isn't looked
290 			-- up in the argument tables if it is accessed again.
291 			--]]
292 			metaArgs[key] = nil
293 			nilArgs[key] = 'h'
294 		else
295 			metaArgs[key] = val
296 		end
297 	end
299 	local function translatenext(invariant)
300 		local k, v = next(invariant.t, invariant.k)
301 		invariant.k = k
302 		if k == nil then
303 			return nil
304 		elseif type(k) ~= 'string' or not options.backtranslate then
305 			return k, v
306 		else
307 			local backtranslate = options.backtranslate[k]
308 			if backtranslate == nil then
309 				-- Skip this one. This is a tail call, so this won't cause stack overflow
310 				return translatenext(invariant)
311 			else
312 				return backtranslate, v
313 			end
314 		end
315 	end
317 	metatable.__pairs = function ()
318 		-- Called when pairs is run on the args table.
319 		if not metatable.donePairs then
320 			mergeArgs(argTables)
321 			metatable.donePairs = true
322 		end
323 		return translatenext, { t = metaArgs }
324 	end
326 	local function inext(t, i)
327 		-- This uses our __index metamethod
328 		local v = t[i + 1]
329 		if v ~= nil then
330 			return i + 1, v
331 		end
332 	end
334 	metatable.__ipairs = function (t)
335 		-- Called when ipairs is run on the args table.
336 		return inext, t, 0
337 	end
339 	return args
340 end
342 return arguments