Module:Params
This module is rated as beta, and is ready for widespread use. It is still new and should be used with some caution to ensure the results are as expected. |
See the ChangeLog | |
Last updated: 19:26:44, 21 November 2024 |
The {{#invoke:params}}
module is designed to be adopted by those templates that want to have a deep control of their parameters. It is particularly useful to variadic templates, to which it offers the possibility to count, list, map and propagate the parameters received without knowing their number in advance.
The module offers elegant shortcuts to non variadic templates as well. Outside templates it has virtually no applications; hence, if you plan to make experiments, make sure to do them from within a template, or you will not be able to see much. Under ./testcases you can find helper templates that can be specifically used for testing the module's capabilities in flexible ways (see in particular the {{./testcases/tmulti}} template).
Note: In case your template uses this module, please add
- REDIRECT Template:Template journal inline to its documentation page, so that if breaking changes will be introduced in the future the template will be easily traceable.
General usage
Among the possibilities that the module offers there is that of performing a series of actions after novel arguments have been concatenated to templates' incoming parameters. As this makes it necessary to keep the argument slots clean from interference, instead of named arguments in order to specify options this module uses piping functions (i.e. functions that expect to be piped instead of returning to the caller), or modifiers. This creates a syntax similar to the following example:
<syntaxhighlight lang="wikitext">Script error: The function "[modifier]" does not exist.</syntaxhighlight>
For instance, as the name suggests, the list
function lists the parameters wherewith a template was called. By default it does not add delimiters, but returns an indistinct blob of text in which keys and values are sticked to each other. However, by using the setting
modifier, we are able to declare a key-value delimiter (p
) and an iteration delimiter (i
). And so, if we imagined a template named {{Example template}}
containing the following wikitext,
<syntaxhighlight lang="wikitext"></syntaxhighlight>
and such template were called with the following arguments,
| Beast of Bodmin = A large feline inhabiting Bodmin Moor
| Morgawr = A sea serpent
| Owlman = A giant owl-like creature
}}
the following result would be produced:
- Beast of Bodmin: A large feline inhabiting Bodmin Moor
Morgawr: A sea serpent
Owlman: A giant owl-like creature
We can also do more sophisticated things; for instance, by exploiting the possibility to set a header (h
) and a footer (f
), we can transform the previous code into a generator of definition lists,
<syntaxhighlight lang="wikitext"></syntaxhighlight>
thus yielding:
- Beast of Bodmin
- A large feline inhabiting Bodmin Moor
- Morgawr
- A sea serpent
- Owlman
- A giant owl-like creature
By placing the with_name_matching
modifier before the list
function we will be able to filter some parameters out – such as, for instance, all parameter names that do not end with an “n”:
<syntaxhighlight lang="wikitext"></syntaxhighlight>
Thus, the previous code will produce:
- Beast of Bodmin
- A large feline inhabiting Bodmin Moor
- Owlman
- A giant owl-like creature
This mechanism has the intrinsic advantage that it allows to concatenate infinite modifiers. And so, in order to get the accurate result that we want to obtain we could write:
<syntaxhighlight lang="wikitext"></syntaxhighlight>
The two modifiers sequential
and non-sequential
refer to a technical jargon used in wikitext: given a parameter list, the subgroup of sequential parameters is constituted by the largest group of consecutive numerical parameters starting from Template:Tjp – this is known as the parameters' “sequence”. A parameter list that does not have a first parameter specified does not possess a sequence.
Functions
Here follows the list of functions. You might want to see also § Modifiers.
self
Num. of arguments | 0 |
---|---|
Not affected by | Any modifier |
See also | |
{{FULLPAGENAME}} |
- Brief
- Returns the name of the template that is calling this module
- Syntax
- <syntaxhighlight lang="wikitext" inline>Module:Params/doc</syntaxhighlight>
This argumentless function guarantees that the name of the template invoking this module is shown, regardless if this is transcluded or not.
As a possible example, if a Wikipedia page named Page X
contained only a transclusion of a template named {{Foo bar}}
, and the latter contained the following wikitext,
<syntaxhighlight lang="wikitext">Module:Params/doc
Module:Params</syntaxhighlight>
if we visited Template:Foo bar
we would see,
Template:Foo bar Template:Foo bar
whereas if we visited Page X
we would see:
Template:Foo bar Page X
Therefore by writing
<syntaxhighlight lang="wikitext">Page is being transcluded</syntaxhighlight>
it is possible to understand whether a page is being transcluded or not.
If Page X
transcluded {{Foo bar 2}}
and the latter were a redirect to {{Foo bar}}
, we would still see
Template:Foo bar Page X
A typical use case of this function is that of providing stable links for editing transcluded templates. E.g.:
<syntaxhighlight lang="wikitext">
</syntaxhighlight>Another possible use case is that of transcluding a subtemplate. E.g.:
<syntaxhighlight lang="wikitext">Module:Params/doc/my subtemplate</syntaxhighlight>
count
Num. of arguments | 0 |
---|---|
Often preceeded by | sequential |
Not affected by | all_sorted ,mapping…_by_calling ,mapping…by_invoking ,…blindly_by_calling ,…lindly_by_invoking |
See also | |
{{#invoke:ParameterCount}} |
- Brief
- Count the number of parameters wherewith a template was called
- Syntax
- <syntaxhighlight lang="wikitext" inline>0</syntaxhighlight>
This function does not take arguments.
The number that this function yields depends on the modifiers that precede it. For instance, in a template that is called with both named and unnamed arguments,
<syntaxhighlight lang="wikitext" inline>0</syntaxhighlight>
and
<syntaxhighlight lang="wikitext" inline>0</syntaxhighlight>
will return different results.
concat_and_call
Num. of arguments | Ad libitum |
---|---|
Not affected by | all_sorted |
See also | |
concat_and_invoke , concat_and_magic |
- Brief
- Prepend numerical arguments to the current parameters or impose non-numerical arguments, then propagate everything to a custom template
- Syntax
- <syntaxhighlight lang="wikitext" inline>Lua error: expandTemplate: template "template name" does not exist.</syntaxhighlight>
For example, if our {{Example template}}
had the following code,
<syntaxhighlight lang="wikitext">Lua error: expandTemplate: template "foo bar" does not exist.</syntaxhighlight>
and were called with,
the following call to the {{Foo bar}}
template would be performed:
| elbow
| earth
| room
| 7 = classy
| 8 = one
| 9 = two
| 10 = three
| wind = spicy
| hello = not today
}}
By using the cutting
modifier it is possible to impose numerical parameters instead of prepending them. For instance, the following code echoes all incoming parameters to {{my template}}
, with the exception of |3=
, which is replaced with hello world
:
<syntaxhighlight lang="wikitext">Lua error: expandTemplate: template "my template" does not exist.</syntaxhighlight>
If no other argument besides the template name are provided this function simply echoes the current parameters to another template.
Note: All arguments passed to this function except the template name are not trimmed of their leading and trailing spaces. The concat_and_call
function name itself, however, will be trimmed of its surrounding spaces.
concat_and_invoke
Num. of arguments | Ad libitum |
---|---|
Not affected by | all_sorted |
See also | |
concat_and_call , concat_and_magic |
- Brief
- Prepend numerical arguments to the current parameters, or impose non-numerical arguments; then propagate everything to a custom module
- Syntax
- <syntaxhighlight lang="wikitext" inline>Lua error in package.lua at line 80: module 'Module:module name' not found.</syntaxhighlight>
Exactly like concat_and_call
, but invokes a module instead of calling a template.
Note: All arguments passed to this function except the module name and the function name are not trimmed of their leading and trailing spaces. The concat_and_invoke
function name itself, however, will be trimmed of its surrounding spaces.
concat_and_magic
Num. of arguments | Ad libitum |
---|---|
Not affected by | all_sorted |
See also | |
concat_and_call , concat_and_invoke |
- Brief
- Prepend numerical arguments to the current parameters, or impose non-numerical arguments; then propagate everything to a custom parser function
- Syntax
- <syntaxhighlight lang="wikitext" inline>Lua error: callParserFunction: function "parser function" was not found.</syntaxhighlight>
Exactly like concat_and_call
, but calls a parser function instead of a template.
Note: All arguments passed to this function except the magic word are not trimmed of their leading and trailing spaces. The concat_and_magic
function name itself, however, will be trimmed of its surrounding spaces.
value_of
Num. of arguments | 1 |
---|---|
Relevant runtime variables | h , f , n |
Not affected by | all_sorted |
See also | |
list_values |
- Brief
- Get the value of a single parameter
- Syntax
- <syntaxhighlight lang="wikitext" inline></syntaxhighlight>
Without modifiers this function is similar to writing <syntaxhighlight lang="wikitext" inline></syntaxhighlight>. With modifiers, however, it allows to reach parameters that would be unreachable without knowing their number in advance. For instance, writing
<syntaxhighlight lang="wikitext"></syntaxhighlight>
will expand to the value of the second-last sequential parameter, independently of how many parameters the template was called with. If no matching parameter is found this function expands to nothing. A header (h
), a footer (f
), and a fallback text (n
) can be declared via the setting
modifier – the strings assigned to the key-value pair delimiter (p
), the iteration delimiter (i
) and the last iteration delimiter (l
) will be ignored.
list
Num. of arguments | Ad libitum |
---|---|
Sortable | Yes |
Relevant runtime variables | h , p , i , l , f , n |
See also | |
list_values |
- Brief
- List the template parameters (both their names and their values)
- Syntax
- <syntaxhighlight lang="wikitext" inline></syntaxhighlight>
This function does not take arguments.
If the setting
modifier was not placed earlier, this function will not add delimiters, but will return an indistinct blob of text in which keys and values are sticked to each other. A header (h
), a key-value pair delimiter (p
), an iteration delimiter (i
), a last iteration delimiter (l
), a footer (f
), and a fallback text (n
) can be declared via setting
.
For example, the following code
<syntaxhighlight lang="wikitext">No parameters were passed</syntaxhighlight>
will generate an output similar to the following.
- Parameters passed: Owlman (A giant owl-like creature); Beast of Bodmin (A large feline inhabiting Bodmin Moor); Morgawr (A sea serpent)
list_values
Num. of arguments | Ad libitum |
---|---|
Sortable | Yes |
Often preceeded by | sequential |
Relevant runtime variables | h , i , l , f , n |
See also | |
list , value_of , {{#invoke:separated entries}} |
- Brief
- List the values of the incoming parameters
- Syntax
- <syntaxhighlight lang="wikitext" inline></syntaxhighlight>
This function does not take arguments.
The sequential
modifier often accompanies this function. If the setting
modifier was not placed earlier, this function will not add delimiters, but will return an indistinct blob of text in which values are sticked to each other. A header (h
), an iteration delimiter (i
), a last iteration delimiter (l
), a footer (f
), and a fallback text (n
) can be declared via setting
– the string assigned to the key-value pair delimiter (p
) will be ignored.
For example, the following code
<syntaxhighlight lang="wikitext">No parameters were passed</syntaxhighlight>
will generate an output similar to the following.
- Values of parameters passed: A giant owl-like creature; A large feline inhabiting Bodmin Moor; A sea serpent.
call_for_each
Num. of arguments | Ad libitum |
---|---|
Sortable | Yes |
Relevant runtime variables | h , i , l , f , n |
See also | |
call_for_each_value , invoke_for_each , magic_for_each , {{#invoke:for loop}} , {{for loop}} |
- Brief
- For each parameter passed to the caller template, call a custom template with at least two parameters (key and value)
- Syntax
- <syntaxhighlight lang="wikitext" inline></syntaxhighlight>
All unnamed parameters following the template name will be placed after the key-value pair. Named parameters will be passed verbatim. A header (h
), an iteration delimiter (i
), a last iteration delimiter (l
), a footer (f
), and a fallback text (n
) can be declared via the setting
modifier – the string assigned to the key-value pair delimiter (p
) will be ignored.
Calling a template for each key-value pair with
<syntaxhighlight lang="wikitext"></syntaxhighlight>
will be different from writing
<syntaxhighlight lang="wikitext"></syntaxhighlight>
In the first example each key-value pair will be passed to the {{foobar}} template, while in the second example the $#
and $@
tokens will be expanded after the {{foobar}} template has been called. In most cases this will make no difference, however there are several situations where it will lead to nonsensical results.
Note: All arguments passed to this function except the template name are not trimmed of their leading and trailing spaces. The call_for_each
function name itself, however, will be trimmed of its surrounding spaces.
invoke_for_each
Num. of arguments | Ad libitum |
---|---|
Sortable | Yes |
Relevant runtime variables | h , i , l , f , n |
See also | |
invoke_for_each_value , call_for_each , magic_for_each |
- Brief
- For each parameter passed to the caller template, invoke a custom module function with at least two arguments (key and value)
- Syntax
- <syntaxhighlight lang="wikitext" inline>Lua error in package.lua at line 80: module 'Module:module name' not found.</syntaxhighlight>
Exactly like call_for_each
, but invokes a module instead of calling a template.
Invoking a module function for each key-value pair with
<syntaxhighlight lang="wikitext">Lua error in package.lua at line 80: module 'Module:foobar' not found.</syntaxhighlight>
will be different from writing
<syntaxhighlight lang="wikitext"></syntaxhighlight>
In the first example each key-value pair will be passed to the {{#invoke:foobar|main}} module function, while in the second example the $#
and $@
tokens will be expanded after the module function has been invoked. There might be cases in which this will make no difference, however there are several situations where it will lead to nonsensical results.
Note: All arguments passed to this function except the module name and the function name are not trimmed of their leading and trailing spaces. The invoke_for_each
function name itself, however, will be trimmed of its surrounding spaces.
magic_for_each
Num. of arguments | Ad libitum |
---|---|
Sortable | Yes |
Relevant runtime variables | h , i , l , f , n |
See also | |
magic_for_each_value , call_for_each , invoke_for_each |
- Brief
- For each parameter passed to the caller template, call a magic word with at least two arguments (key and value)
- Syntax
- <syntaxhighlight lang="wikitext" inline></syntaxhighlight>
Exactly like call_for_each
, but calls a parser function instead of a template.
Note: All arguments passed to this function except the magic word are not trimmed of their leading and trailing spaces. The magic_for_each
function name itself, however, will be trimmed of its surrounding spaces.
call_for_each_value
Num. of arguments | Ad libitum |
---|---|
Sortable | Yes |
Often preceeded by | sequential |
Relevant runtime variables | h , i , l , f , n |
See also | |
call_for_each , invoke_for_each_value , magic_for_each_value , {{#invoke:for loop}} , {{for loop}} |
- Brief
- For each parameter passed to the caller template, call a custom template with at least one parameter (i.e. the parameter's value)
- Syntax
- <syntaxhighlight lang="wikitext" inline></syntaxhighlight>
The sequential
modifier often accompanies this function. All unnamed parameters following the template name will be appended after the value parameter. Named parameters will be passed verbatim. A header (h
), an iteration delimiter (i
), a last iteration delimiter (l
), a footer (f
), and a fallback text (n
) can be declared via the setting
modifier – the string assigned to the key-value pair delimiter (p
) will be ignored.
For example, calling {{tl}} with each parameter can be done by writing
<syntaxhighlight lang="wikitext"></syntaxhighlight>
This will be different from writing
<syntaxhighlight lang="wikitext"></syntaxhighlight>
In the first example each value will be passed to the {{tl}} template, while in the second example the $@
token will be expanded after the {{tl}} template has been called. Here this will make no difference, however there are several situations where it will lead to nonsensical results.
Note: All arguments passed to this function except the template name are not trimmed of their leading and trailing spaces. The call_for_each_value
function name itself, however, will be trimmed of its surrounding spaces.
invoke_for_each_value
Num. of arguments | Ad libitum |
---|---|
Sortable | Yes |
Often preceeded by | sequential |
Relevant runtime variables | h , i , l , f , n |
See also | |
call_for_each_value , invoke_for_each , magic_for_each_value |
- Brief
- For each parameter passed to the caller template, invoke a custom module function with at least one argument (i.e. the parameter's value)
- Syntax
- <syntaxhighlight lang="wikitext" inline>Lua error in package.lua at line 80: module 'Module:module name' not found.</syntaxhighlight>
Exactly like call_for_each_value
, but invokes a module instead of calling a template.
Invoking a module function for each value with
<syntaxhighlight lang="wikitext">Lua error in package.lua at line 80: module 'Module:foobar' not found.</syntaxhighlight>
will be different from writing
<syntaxhighlight lang="wikitext"></syntaxhighlight>
In the first example each value will be passed to the {{#invoke:foobar|main}} module function, while in the second example the $@
token will be expanded after the module function has been invoked. There might be cases in which this will make no difference, however there are several situations where it will lead to nonsensical results.
Note: All arguments passed to this function except the module name and the function name are not trimmed of their leading and trailing spaces. The invoke_for_each_value
function name itself, however, will be trimmed of its surrounding spaces.
magic_for_each_value
Num. of arguments | Ad libitum |
---|---|
Sortable | Yes |
Often preceeded by | sequential |
Relevant runtime variables | h , i , l , f , n |
See also | |
call_for_each_value , invoke_for_each_value , magic_for_each |
- Brief
- For each parameter passed to the caller template, call a magic word with at least one argument (i.e. the parameter's value)
- Syntax
- <syntaxhighlight lang="wikitext" inline></syntaxhighlight>
Exactly like call_for_each_value
, but calls a parser function instead of a template.
For example, if a template had the following code,
<syntaxhighlight lang="wikitext"></syntaxhighlight>
and were transcluded as <syntaxhighlight lang="wikitext" inline>Template:Example template</syntaxhighlight>, the {{urlencode:...|QUERY}}
parser function would be called for each incoming parameter as first argument and with QUERY
as second argument, and finally the returned text would be prefixed with &preloadparams%5b%5d=
. This would generate,
&preloadparams%5b%5d=hello+world&preloadparams%5b%5d=%C3%A0%C3%A8%C3%AC%C3%B2%C3%B9&preloadparams%5b%5d=foo+bar
which can be used to allow the creation of pages with preloaded text and parameters.
Note: All arguments passed to this function except the magic word are not trimmed of their leading and trailing spaces. The magic_for_each_value
function name itself, however, will be trimmed of its surrounding spaces.
for_each
Num. of arguments | 1 |
---|---|
Sortable | Yes |
Relevant runtime variables | h , i , l , f , n |
See also | |
list , list_values , {{#invoke:for nowiki}} , {{for nowiki}} |
- Brief
- For each parameter passed to the caller template, expand all occurrences of
$#
and$@
within a given text as key and value respectively - Syntax
- <syntaxhighlight lang="wikitext" inline></syntaxhighlight>
Example:
<syntaxhighlight lang="wikitext"></syntaxhighlight>
The text returned by this function is not expanded further (currently this module does not offer an expand_for_each
function). If you need wikitext expansion, use concat_and_call
to propagate the incoming parameters altogether to the {{for nowiki}} template. Example:
<syntaxhighlight lang="wikitext"></syntaxhighlight>
Note: The argument passed to this function is not trimmed of its leading and trailing spaces. The for_each
function name itself, however, will be trimmed of its surrounding spaces.
Modifiers (piping functions)
The following are modifiers, i.e. functions that expect to be piped instead of returning to the caller. Each of them can be followed by either another modifier or a non-piping function. The actions that modifiers do are done sequentially, in the same order chosen during the invocation of this module. Some modifiers, however, after signaling their presence to the modifiers that might follow, add their action to the queue of actions that will be done last (e.g. sequential
, non-sequential
, all_sorted
).
sequential
Num. of arguments | 0 |
---|---|
Repeatable | No |
Conflicts with | non-sequential , all_sorted |
See also | |
non-sequential , all_sorted , squeezing |
- Brief
- Reduce the parameter list to the subgroup of consecutive parameters that follow Template:Tjp
- Syntax
- <syntaxhighlight lang="wikitext" inline>Lua error: Module:Params: The function ‘pipe function name’ does not exist.</syntaxhighlight>
Example:
<syntaxhighlight lang="wikitext">0</syntaxhighlight>
This modifier does not take arguments besides the name of the function that will follow.
Using sequential
together with non-sequential
will generate an error.
Note: Like non-sequential
, the sequential
modifier permanently marks a query. For instance, writing <syntaxhighlight lang="wikitext" inline>Lua error: Module:Params: The function ‘...’ does not exist.</syntaxhighlight> will first mark the query as “sequential”, then will discard the first element from the sequence (leaving all the others intact). And so, no matter how many other parameters will be present, nothing will be shown.
non-sequential
Num. of arguments | 0 |
---|---|
Repeatable | No |
Conflicts with | sequential |
See also | |
sequential , all_sorted |
- Brief
- Reduce the parameter list by discarding the subgroup of consecutive parameters that follow Template:Tjp
- Syntax
- <syntaxhighlight lang="wikitext" inline>Lua error: Module:Params: The function ‘pipe function name’ does not exist.</syntaxhighlight>
Example:
<syntaxhighlight lang="wikitext"></syntaxhighlight>
This modifier does not take arguments besides the name of the function that will follow.
Using non-sequential
together with sequential
will generate an error.
Note: Like sequential
, the non-sequential
modifier permanently marks a query, and no matter what transformations will follow (see squeezing
) the parameters' “sequence” will not be shown.
all_sorted
Num. of arguments | 0 |
---|---|
Repeatable | No |
Conflicts with | sequential |
Has no effects on | count , value_of , concat_and_call , concat_and_invoke , concat_and_magic |
See also | |
sequential |
- Brief
- When the time will come, all parameters will be dispatched sorted: first the numerical ones, then the rest in alphabetical order
- Syntax
- <syntaxhighlight lang="wikitext" inline>Lua error: Module:Params: The function ‘pipe function name’ does not exist.</syntaxhighlight>
Example:
<syntaxhighlight lang="wikitext"></syntaxhighlight>
This modifier does not take arguments besides the name of the function that will follow.
Normally only sequential parameters are dispatched sorted, whereas non-sequential ones are dispatched randomly. The all_sorted
modifier ensures that nothing is left out of (alphabetical) order. Attention must be paid to the fact that parameters whose name is a negative number will appear first. To avoid this the squeezing
modifier can be used.[1]
The all_sorted
modifier only affects the way parameters are shown, but has no effects on functions that do not iterate or cannot impose an order, such as:
Note: The all_sorted
modifier cannot be used with functions that propagate several parameters together in a single call, like concat_and_call
, concat_and_invoke
, and concat_and_magic
, because during a call the order of arguments is always lost. For the same reason, it is not possible to guess the order of named parameters a template was invoked with.
setting
Num. of arguments | 2–7 (variable) | ||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Repeatable | Yes | ||||||||||||
Memory slots | |||||||||||||
|
- Brief
- Define glue strings
- Syntax
- <syntaxhighlight lang="wikitext" inline>Lua error: Module:Params, ‘setting’: Unknown slot "d".</syntaxhighlight>
This modifier allows to set some internal variables that will be used by functions. It takes a variable number of arguments, relying on the first argument to understand how many other arguments to read. A few examples will introduce it better than words:
- <syntaxhighlight lang="wikitext" inline></syntaxhighlight>
- ↳ Set the value of iteration delimiter to
|
, then list all values
- ↳ Set the value of iteration delimiter to
- <syntaxhighlight lang="wikitext" inline></syntaxhighlight>
- ↳ Set the value of both header text and iteration delimiter to
|
, then list all values
- ↳ Set the value of both header text and iteration delimiter to
- <syntaxhighlight lang="wikitext" inline></syntaxhighlight>
- ↳ Set the value of both header text and iteration delimiter to
|
, set key-value pair delimiter to=
, then list all parameters
- ↳ Set the value of both header text and iteration delimiter to
- <syntaxhighlight lang="wikitext" inline>No parameters were passed</syntaxhighlight>
- ↳ Set the value of both header text and iteration delimiter to
|
, set key-value pair delimiter to=
, set fallback text toNo parameters were passed
, then list all parameters
- ↳ Set the value of both header text and iteration delimiter to
The first argument is a slash-separated list of lists of slots to assign; one slot is referred by exactly one character and each list of slots maps exactly one argument. A slot indicates which internal variable to set. If more than one slot is aggregated within the same slash-separated list the same text will be assigned to more than one variable.
The slots available are the following:
Slots | Variable | Description |
---|---|---|
p
|
Key-value pair delimiter | The string of text that will be placed between each parameter name and its value; it is never inserted by functions that only iterate between values, or by functions that pass the key-value pairs to external calls. |
i
|
Iteration delimiter | The string of text that will be placed between each iteration; it is never inserted unless there are two or more parameters to show when l is not given, or three or more parameters when l is given.
|
l
|
Last iteration delimiter | The string of text that will be placed between the second last and the last iteration; it is never inserted unless there are two or more parameters to show; if omitted defaults to i .
|
h
|
Header text | The string of text that will be placed before the iteration begins; it is never inserted if there are no parameters to show. |
f
|
Footer text | The string of text that will be placed after the iteration is over; it is never inserted if there are no parameters to show. |
n
|
Fallback text | The string of text that will be placed if there are no parameters to show. |
All space characters in the directives arguments are discarded. Therefore writing <syntaxhighlight lang="wikitext" inline>Lua error: Module:Params: You must specify a function to call.</syntaxhighlight> is equivalent to writing
<syntaxhighlight lang="wikitext">Lua error: Module:Params: You must specify a function to call.</syntaxhighlight>
In theory, instead of assigning different slots at once (i.e. <syntaxhighlight lang="wikitext" inline>Template:...</syntaxhighlight>), it is possible to write separate invocations of setting
for each variable, as in <syntaxhighlight lang="wikitext" inline>Template:...</syntaxhighlight>. This method however will be slightly less efficient.
Sometimes it might be necessary to make the values assigned depend on conditional expressions. For instance, the following imaginary {{Foobar see also}}
template uses the #ifexpr
parser function to properly show the “and” conjunction and possibly an Oxford comma when more than two page names are provided:
You can find this example at {{./doc/examples/Oxford comma}}. E.g., <syntaxhighlight lang="wikitext" inline>Module:Params/doc/examples/Oxford comma</syntaxhighlight> will generate
Module:Params/doc/examples/Oxford comma
Note: The setting
modifier will be trimmed of its surrounding spaces. The directives argument will be stripped of all space characters, including internal spaces. All the other arguments passed to this modifier will be parsed verbatim (i.e. leading and trailing spaces will not be removed).
squeezing
Num. of arguments | 0 |
---|---|
Repeatable | Yes |
See also | |
sequential |
- Brief
- Rearrange all parameters that have numerical names to form a compact sequence starting from 1, keeping the same order
- Syntax
- <syntaxhighlight lang="wikitext" inline>Lua error: Module:Params: The function ‘pipe function name’ does not exist.</syntaxhighlight>
Example:
<syntaxhighlight lang="wikitext"></syntaxhighlight>
This modifier does not take arguments besides the name of the function that will follow.
The following three concatenations will lead to the same result of discarding all parameters with numerical names:
- <syntaxhighlight lang="wikitext" inline>Template:...</syntaxhighlight>
- <syntaxhighlight lang="wikitext" inline>Template:...</syntaxhighlight>
- <syntaxhighlight lang="wikitext" inline>Template:...</syntaxhighlight>
cutting
Num. of arguments | 2 |
---|---|
Repeatable | Yes |
See also | |
sequential , squeezing |
- Brief
- Remove zero or more parameters from the beginning and the end of the parameter list
- Syntax
- <syntaxhighlight lang="wikitext" inline>Lua error: Module:Params, ‘cutting’: Left cut must be a number.</syntaxhighlight>
The first argument indicates how many sequential parameters must be removed from the beginning of the parameter list, the second argument indicates how many sequential parameters must be removed from the end of the parameter list. If any of the two arguments contains a negative number its absolute value indicates what must be left on the other side – i.e. <syntaxhighlight lang="wikitext" inline></syntaxhighlight> indicates that the last three arguments must not be discarded.
Example:
<syntaxhighlight lang="wikitext"></syntaxhighlight>
If the absolute value of the sum of the two arguments (left and right cut) is greater than the number of sequential parameters available, the behavior will be the same as if the sum had been equal to the number of sequential parameters available, both when this is a positive value and when it is a negative value (with opposite results). After the desired sequential parameters have been discarded, all numerical parameters will be shifted accordingly.
In some cases it might be necessary to concatenate more than one invocation of the cutting
modifier. For instance, the following code prints the last unnamed parameter passed, but only if at least two parameters were passed:
<syntaxhighlight lang="wikitext"></syntaxhighlight>
Suggestion: Although <syntaxhighlight lang="wikitext" inline>Lua error: Module:Params: The function ‘...’ does not exist.</syntaxhighlight> de facto gets rid of all sequential parameters, it is clearer and more idiomatic to write <syntaxhighlight lang="wikitext" inline>Lua error: Module:Params: The function ‘...’ does not exist.</syntaxhighlight> to obtain the same effect. Writing instead <syntaxhighlight lang="wikitext" inline>Lua error: Module:Params: The function ‘...’ does not exist.</syntaxhighlight> will leave zero arguments to show.
with_name_matching
Num. of arguments | Ad libitum |
---|---|
Repeatable | Yes |
See also | |
with_name_not_matching , with_value_matching , with_value_not_matching |
- Brief
- Discard all parameters whose name does not match any of the given patterns
- Syntax
- <syntaxhighlight lang="wikitext" inline>Lua error: Module:Params: The function ‘[plain flag 1]’ does not exist.</syntaxhighlight>
Internally this modifier uses Lua's string.find()
function to find whether parameter names match against given patterns; therefore, unless a target string is set to plain
, please use the same syntax of Lua patterns. The plain flag can be either plain
or omitted. When omitted it is assumed that the target string is a Lua pattern.
To express a logical OR the or
keyword is available. To express a logical AND instead, concatenate more invocations of with_name_matching
.
For the sake of argument we will imagine that we are invoking with_name_matching
from within the {{Infobox artery}} template, and this is being called with the following parameters:
| Name = Pulmonary artery
| Latin = truncus pulmonalis, arteria pulmonalis
| Image = {{Heart diagram 250px}}
| Caption = Anterior (frontal) view of the opened heart. (Pulmonary artery upper right.)
| Image2 = Alveoli diagram.png
| Caption2 = Diagram of the alveoli with both cross-section and external view.
| BranchFrom = [[right ventricle]]
| BranchTo =
| Vein = [[pulmonary vein]]
| Precursor = truncus arteriosus
| Supplies =
}}
Test cases:
- List only the parameters whose names match against the
^Image
pattern:- ↳ <syntaxhighlight lang="wikitext" inline></syntaxhighlight>
- ↳ |Image={{Heart diagram 250px}}|Image2=Alveoli diagram.png
- ↳ <syntaxhighlight lang="wikitext" inline></syntaxhighlight>
- List the parameters whose names match against both patterns
^Image
and%d+$
:- ↳ <syntaxhighlight lang="wikitext" inline></syntaxhighlight>
- ↳ |Image2=Alveoli diagram.png
- ↳ <syntaxhighlight lang="wikitext" inline></syntaxhighlight>
- List the parameters whose names match against either the
^Name
or the^Latin$
pattern:- ↳ <syntaxhighlight lang="wikitext" inline></syntaxhighlight>
- ↳ |Latin=truncus pulmonalis, arteria pulmonalis|Name=Pulmonary artery
- ↳ <syntaxhighlight lang="wikitext" inline></syntaxhighlight>
- List the parameters whose names match against either the
ma
plain string or theme$
pattern:- ↳ <syntaxhighlight lang="wikitext" inline></syntaxhighlight>
- ↳ |Image={{Heart diagram 250px}}|Name=Pulmonary artery|Image2=Alveoli diagram.png
- ↳ <syntaxhighlight lang="wikitext" inline></syntaxhighlight>
Using with_name_matching
it is easy to emulate the behaviour of Module:Enumerate (or similar modules). For instance, the following examples creates a bullet list of all the parameters passed of type |foobar1
, |foobar2
… |foobarN
:
<syntaxhighlight lang="wikitext"></syntaxhighlight>
It is possible to see this example live at {{./doc/examples/enumerate}}.
Note: The pattern arguments passed to this function are not trimmed of their leading and trailing spaces. The or
and plain
keywords, and the with_name_matching
function name itself, however, will be trimmed of their surrounding spaces.
with_name_not_matching
Num. of arguments | Ad libitum |
---|---|
Repeatable | Yes |
See also | |
with_name_matching , with_value_matching , with_value_not_matching |
- Brief
- Discard all parameters whose name matches all the given patterns
- Syntax
- <syntaxhighlight lang="wikitext" inline>Lua error: Module:Params: The function ‘[plain flag 1]’ does not exist.</syntaxhighlight>
Internally this modifier uses Lua's string.find()
function to find whether parameter names match against given patterns; therefore, unless a target string is set to plain
, please use the same syntax of Lua patterns. The plain flag can be either plain
or omitted. When omitted it is assumed that the target string is a Lua pattern.
To express a logical OR the or
keyword is available. To express a logical AND instead, concatenate more invocations of with_name_not_matching
.
For the sake of argument we will imagine that we are invoking with_name_not_matching
from within the {{Infobox artery}} template, and this is being transcluded using the same parameters that we had imagined in the previous example at with_name_matching
:
- List only the parameters whose names do not match against the
a
pattern:- <syntaxhighlight lang="wikitext" inline></syntaxhighlight>
- ↳ |Precursor=truncus arteriosus|Supplies=|Vein=pulmonary vein
- <syntaxhighlight lang="wikitext" inline></syntaxhighlight>
- List the parameters whose names do not match against the
a
plain string and do not match against thel
plain string either:- <syntaxhighlight lang="wikitext" inline></syntaxhighlight>
- ↳ |Precursor=truncus arteriosus|Vein=pulmonary vein
- <syntaxhighlight lang="wikitext" inline></syntaxhighlight>
- List the parameters whose names do not match against either the
a
plain string or then
plain string:- <syntaxhighlight lang="wikitext" inline></syntaxhighlight>
- ↳ |Precursor=truncus arteriosus|Supplies=|Image={{Heart diagram 250px}}|Name=Pulmonary artery|Image2=Alveoli diagram.png|Vein=pulmonary vein
- <syntaxhighlight lang="wikitext" inline></syntaxhighlight>
It is possible to use this function to check for unknown parameters:
<syntaxhighlight lang="wikitext">Everything is good: do something</syntaxhighlight>
For simple cases like this, however, specialized modules are available; you might want to have a look at:
- {{#invoke:Check for unknown parameters|check}}
- {{#invoke:Check for deprecated parameters|check}}
- {{#invoke:Check for clobbered parameters|check}}
- {{#invoke:Parameter validation|validateparams}}
- {{#invoke:TemplatePar|valid}}
Note: The pattern arguments passed to this function are not trimmed of their leading and trailing spaces. The or
and plain
keywords, and the with_name_not_matching
function name itself, however, will be trimmed of their surrounding spaces.
with_value_matching
Num. of arguments | Ad libitum |
---|---|
Repeatable | Yes |
See also | |
with_name_matching , with_name_not_matching , with_value_not_matching |
- Brief
- Discard all parameters whose value does not match any of the given patterns
- Syntax
- <syntaxhighlight lang="wikitext" inline>Lua error: Module:Params: The function ‘[plain flag 1]’ does not exist.</syntaxhighlight>
Exactly like with_name_matching
, but applied to parameter values instead of names.
Internally this modifier uses Lua's string.find()
function to find whether parameter names match against given patterns; therefore, unless a target string is set to plain
, please use the same syntax of Lua patterns. The plain flag can be either plain
or omitted. When omitted it is assumed that the target string is a Lua pattern.
Example:
<syntaxhighlight lang="wikitext">0</syntaxhighlight>
Note: The pattern arguments passed to this function are not trimmed of their leading and trailing spaces. The or
and plain
keywords, and the with_value_matching
function name itself, however, will be trimmed of their surrounding spaces.
with_value_not_matching
Num. of arguments | Ad libitum |
---|---|
Repeatable | Yes |
See also | |
with_name_matching , with_name_not_matching , with_value_matching |
- Brief
- Discard all parameters whose value matches all the given patterns
- Syntax
- <syntaxhighlight lang="wikitext" inline>Lua error: Module:Params: The function ‘[plain flag 1]’ does not exist.</syntaxhighlight>
Exactly like with_name_not_matching
, but applied to parameter values instead of names.
Internally this modifier uses Lua's string.find()
function to find whether parameter names match against given patterns; therefore, unless a target string is set to plain
, please use the same syntax of Lua patterns. The plain flag can be either plain
or omitted. When omitted it is assumed that the target string is a Lua pattern.
For instance, before calling list
, the following code will get rid of all blank parameters (i.e. parameters whose values contain only zero or more spaces):
<syntaxhighlight lang="wikitext"></syntaxhighlight>
Note: The pattern arguments passed to this function are not trimmed of their leading and trailing spaces. The or
and plain
keywords, and the with_value_not_matching
function name itself, however, will be trimmed of their surrounding spaces.
trimming_values
Num. of arguments | 0 |
---|---|
Repeatable | No |
- Brief
- Remove leading and trailing spaces from values
- Syntax
- <syntaxhighlight lang="wikitext" inline>Lua error: Module:Params: The function ‘pipe function name’ does not exist.</syntaxhighlight>
This modifier does not take arguments besides the name of the function that will follow.
Most modifiers are order-dependent, therefore placing trimming_values
in different positions can generate different results. For instance, imagining our {{Example template}}
being called with the following spaced arguments: <syntaxhighlight lang="wikitext" inline>Template:Example template</syntaxhighlight>. If {{Example template}}
contained the following code,
<syntaxhighlight lang="wikitext"></syntaxhighlight>
the following text would be printed: 1=wanna|2=be|3=my|4=friend|5=?
. But if instead it contained the following code,
<syntaxhighlight lang="wikitext"></syntaxhighlight>
no arguments would be shown.
Order affects also performance, and how many values will be trimmed of their leading and trailing spaces will depend on where trimming_values
is placed. For instance, if a template were invoked with 50 parameters and its code contained <syntaxhighlight lang="wikitext" inline></syntaxhighlight>, first all its values would be trimmed of leading and trailing blank spaces and then its first 49 parameters would be discarded. On the other hand, writing <syntaxhighlight lang="wikitext" inline></syntaxhighlight> would first discard 49 parameters and then trim the only value left, resulting in a more efficient code. As a general rule, placing trimming_values
as the last modifier is usually the best choice.
Placing trimming_values
together with non-sequential
will result in an empty call with no effects, because non-sequential parameters are stripped of their leading and trailing spaces by default.
Using trimming_values
makes this module behave like many Wikipedia modules behave. For example, if we wanted to emulate {{#invoke:Separated entries|main}}, writing
<syntaxhighlight lang="wikitext"></syntaxhighlight>
will be equivalent to writing,
<syntaxhighlight lang="wikitext"></syntaxhighlight>
whereas writing
<syntaxhighlight lang="wikitext"></syntaxhighlight>
will be equivalent to writing
<syntaxhighlight lang="wikitext"></syntaxhighlight>
The {{./doc/trim and call}} example template shows how to call any arbitrary template trimming all parameters beforehand.
mapping_values_by_calling
Num. of arguments | Ad libitum |
---|---|
Repeatable | Yes |
See also | |
mapping_values_by_invoking , mapping_values_blindly_by_calling , mapping_values_blindly_by_invoking |
- Brief
- Map all parameter values, replacing their content with the expansion of a given template repeatedly called with at least two arguments (the parameter's name and value)
- Syntax
- <syntaxhighlight lang="wikitext" inline>Lua error: Module:Params: The function ‘[number of additional arguments]’ does not exist.</syntaxhighlight>
This modifier (temporarily) changes the contents of the parameters the current template is being called with, replacing each of them with the text returned by another template. The latter will be repeatedly called with at least two parameters: key and value. If the template name is followed by a number, this will be parsed as the amount of additional parameters to pass. For instance, before listing all parameters,
<syntaxhighlight lang="wikitext"></syntaxhighlight>
will replace each value with the expansion of <syntaxhighlight lang="wikitext" inline>Template:Foobar</syntaxhighlight> (where NAME
and VALUE
indicate each different name and value).
On the other hand,
<syntaxhighlight lang="wikitext"></syntaxhighlight>
will do the same, but using the expansion of <syntaxhighlight lang="wikitext" inline>Template:Foobar</syntaxhighlight>.
There are no mechanisms for passing non-sequential or non-numeric additional parameters to the mapping template. A similar function, mapping_values_blindly_by_calling
, omits the first parameter (i.e. the parameter's name).
Note: All arguments passed to this modifier except the template name and the number of additional arguments are not trimmed of their leading and trailing spaces. The mapping_values_by_calling
modifier name itself, however, will be trimmed of its surrounding spaces.
mapping_values_by_invoking
Num. of arguments | Ad libitum |
---|---|
Repeatable | Yes |
See also | |
mapping_values_by_calling , mapping_values_blindly_by_calling , mapping_values_blindly_by_invoking |
- Brief
- Map all parameter values, replacing their content with the text returned by a given module function repeatedly invoked with at least two arguments (the parameter's name and value)
- Syntax
- <syntaxhighlight lang="wikitext" inline>Lua error in package.lua at line 80: module 'Module:template name' not found.</syntaxhighlight>
This modifier (temporarily) changes the contents of the parameters the current template is being called with, replacing each of them with text returned by a custom module function. The latter will be repeatedly invoked with at least two arguments: key and value. If the function name is followed by a number, this will be parsed as the amount of additional arguments to pass. For instance, before listing all parameters,
<syntaxhighlight lang="wikitext">Lua error in package.lua at line 80: module 'Module:foobar' not found.</syntaxhighlight>
will replace each value with the expansion of <syntaxhighlight lang="wikitext" inline>Script error: No such module "foobar".</syntaxhighlight> (where NAME
and VALUE
indicate each different name and value).
On the other hand,
<syntaxhighlight lang="wikitext">Lua error in package.lua at line 80: module 'Module:foobar' not found.</syntaxhighlight>
will do the same, but using the expansion of <syntaxhighlight lang="wikitext" inline>Script error: No such module "foobar".</syntaxhighlight>.
There are no mechanisms for passing non-sequential or non-numeric additional arguments to the mapping module. A similar function, mapping_values_blindly_by_invoking
, omits the first argument (i.e. the parameter's name).
Note: All arguments passed to this modifier except the module name, the function name and the number of additional arguments are not trimmed of their leading and trailing spaces. The mapping_values_by_invoking
modifier name itself, however, will be trimmed of its surrounding spaces.
mapping_values_blindly_by_calling
Num. of arguments | Ad libitum |
---|---|
Repeatable | Yes |
See also | |
mapping_values_by_calling , mapping_values_by_invoking , mapping_values_blindly_by_invoking |
- Brief
- Map all parameter values, replacing their content with the expansion of a given template repeatedly called with at least one argument (the parameter's value)
- Syntax
- <syntaxhighlight lang="wikitext" inline>Lua error: Module:Params: The function ‘[number of additional arguments]’ does not exist.</syntaxhighlight>
This modifier (temporarily) changes the contents of the parameters the current template is being called with, replacing each of them with the text returned by another template. The latter will be repeatedly called with at least one parameter: the parameter's value. If the template name is followed by a number, this will be parsed as the amount of additional parameters to pass. For instance, before listing all parameters,
<syntaxhighlight lang="wikitext"></syntaxhighlight>
will replace each value with the expansion of <syntaxhighlight lang="wikitext" inline>Template:Foobar</syntaxhighlight> (where VALUE
indicates each different value).
On the other hand,
<syntaxhighlight lang="wikitext"></syntaxhighlight>
will do the same, but using the expansion of <syntaxhighlight lang="wikitext" inline>Template:Foobar</syntaxhighlight>.
There are no mechanisms for passing non-sequential or non-numeric additional parameters to the mapping template. A similar function, mapping_values_by_calling
, passes the parameter's name as well, as first argument.
Note: All arguments passed to this modifier except the template name and the number of additional arguments are not trimmed of their leading and trailing spaces. The mapping_values_blindly_by_calling
modifier name itself, however, will be trimmed of its surrounding spaces.
mapping_values_blindly_by_invoking
Num. of arguments | Ad libitum |
---|---|
Repeatable | Yes |
See also | |
mapping_values_by_calling , mapping_values_by_invoking , mapping_values_blindly_by_calling |
- Brief
- Map all parameter values, replacing their content with the text returned by a given module function repeatedly invoked with at least one argument (the parameter's value)
- Syntax
- <syntaxhighlight lang="wikitext" inline>Lua error in package.lua at line 80: module 'Module:template name' not found.</syntaxhighlight>
This modifier (temporarily) changes the contents of the parameters the current template is being called with, replacing each of them with text returned by a custom module function. The latter will be repeatedly invoked with at least one argument: the parameter's value. If the function name is followed by a number, this will be parsed as the amount of additional arguments to pass. For instance, before listing all parameters,
<syntaxhighlight lang="wikitext">Lua error in package.lua at line 80: module 'Module:foobar' not found.</syntaxhighlight>
will replace each value with the expansion of <syntaxhighlight lang="wikitext" inline>Script error: No such module "foobar".</syntaxhighlight> (where VALUE
indicates each different value).
On the other hand,
<syntaxhighlight lang="wikitext">Lua error in package.lua at line 80: module 'Module:foobar' not found.</syntaxhighlight>
will do the same, but using the expansion of <syntaxhighlight lang="wikitext" inline>Script error: No such module "foobar".</syntaxhighlight>.
There are no mechanisms for passing non-sequential or non-numeric additional arguments to the mapping module. A similar function, mapping_values_by_invoking
, passes the parameter's name as well, as first argument.
Note: All arguments passed to this modifier except the module name, the function name and the number of additional arguments are not trimmed of their leading and trailing spaces. The mapping_values_blindly_by_invoking
modifier name itself, however, will be trimmed of its surrounding spaces.
Subpages
- Module:Params/ChangeLog – Record of the most important changes in the module's code
- Module:Params/testcases – Testing the module's capabilities
Notes
- ↑ To be precise, the order will not be strictly alphabetical, because this would imply that a template called with the following parameters <syntaxhighlight lang="wikitext" inline>Template:Foobar</syntaxhighlight> would see them reordered as follows: <syntaxhighlight lang="wikitext" inline>Template:Foobar</syntaxhighlight> (with the dot in the middle between negative and positive numbers). To avoid this, numbers are always displayd first (i.e. <syntaxhighlight lang="wikitext" inline>Template:Foobar</syntaxhighlight>).
See also
- {{#invoke:TemplatePar}}
- {{#invoke:ParameterCount}}
- {{#invoke:Separated entries|main}}
- {{#invoke:Enumerate|main}}
- {{#invoke:Check for unknown parameters|check}}
- {{#invoke:Check for deprecated parameters|check}}
- {{#invoke:Check for clobbered parameters|check}}
- {{#invoke:Parameter validation}}
- {{#invoke:Expand wikitext|main}}
- {{#invoke:For loop|main}} and {{For loop}}
- {{#invoke:For nowiki|main}} and {{For nowiki}}
- Project:TemplateData
--- --- --- LOCAL ENVIRONMENT --- --- ________________________________ --- --- --- -- Special user-given keywords (functions and modifiers MUST avoid these names) local mkeywords = { -- ['pattern'] = false, ['plain'] = true, ['or'] = 0 } -- Set directives local memoryslots = { i = 'itersep', l = 'lastsep', p = 'pairsep', h = 'header', f = 'footer', n = 'ifngiven' } -- The private table of functions local library = {} -- Return a copy or a reference to a table local function copy_or_ref_table(src, refonly) if refonly then return src end newtab = {} for key, val in pairs(src) do newtab[key] = val end return newtab end -- Prepare the context local function context_init(frame, funcname, refpipe, refparams) local ctx = {} ctx.luaname = 'Module:Params' --[[ or `frame:getTitle()` ]]-- ctx.iterfunc = pairs ctx.pipe = copy_or_ref_table(frame.args, refpipe) ctx.frame = frame:getParent() ctx.params = copy_or_ref_table(ctx.frame.args, refparams) return funcname(ctx) end -- Move to the next action within the user-given list local function context_iterate(ctx, n_forward) local nextfn if ctx.pipe[n_forward] ~= nil then nextfn = ctx.pipe[n_forward]:match'^%s*(.*%S)' end if nextfn == nil then error(ctx.luaname .. ': You must specify a function to call', 0) end if library[nextfn] == nil then error(ctx.luaname .. ': The function ‘' .. nextfn .. '’ does not exist', 0) end for idx = n_forward, 1, -1 do table.remove(ctx.pipe, idx) end return library[nextfn](ctx) end -- Concatenate the numerical keys from the table of parameters to the numerical -- keys from the table of options; non-numerical keys from the table of options -- will prevail over colliding non-numerical keys from the table of parameters local function concat_params(ctx) local shift = table.maxn(ctx.pipe) local newargs = {} if ctx.subset == 1 then -- We need only the sequence for key, val in ipairs(ctx.params) do newargs[key + shift] = val end else if ctx.subset == -1 then for key, val in ipairs(ctx.params) do ctx.params[key] = nil end end for key, val in pairs(ctx.params) do if type(key) == 'number' then newargs[key + shift] = val else newargs[key] = val end end end for key, val in pairs(ctx.pipe) do newargs[key] = val end return newargs end local function flush_params(ctx, fn) local tbl = ctx.params if ctx.subset == 1 then for key, val in ipairs(tbl) do fn(key, val) end return end if ctx.subset == -1 then for key, val in ipairs(tbl) do tbl[key] = nil end end if ctx.dosort then local nums = {} local words = {} local nlen = 0 local wlen = 0 for key, val in pairs(tbl) do if type(key) == 'number' then nlen = nlen + 1 nums[nlen] = key else wlen = wlen + 1 words[wlen] = key end end table.sort(nums) table.sort(words) for idx = 1, nlen do fn(nums[idx], tbl[nums[idx]]) end for idx = 1, wlen do fn(words[idx], tbl[words[idx]]) end return end if ctx.subset ~= -1 then for key, val in ipairs(tbl) do fn(key, val) tbl[key] = nil end end for key, val in pairs(tbl) do fn(key, val) end end -- Parse the arguments of the `with_*_matching` class of modifiers local function parse_match_args(opts, ptns, fname) local state = 0 local cnt = 1 local keyw local nptns = 0 for _, val in ipairs(opts) do if state == 0 then nptns = nptns + 1 ptns[nptns] = { val, false } state = -1 else keyw = val:match'^%s*(.*%S)' if keyw == nil or mkeywords[keyw] == nil then break else state = mkeywords[keyw] if state ~= 0 then ptns[nptns][2] = state end end end cnt = cnt + 1 end if state == 0 then error(ctx.luaname .. ', ‘' .. fname .. '’: No pattern was given', 0) end return cnt end --[[ Library's modifiers ]]-- -------------------------------- -- See iface.sequential() library.sequential = function(ctx) if ctx.subset == -1 then error(ctx.luaname .. ': The two directives ‘non-sequential’ and ‘sequential’ are in contradiction with each other', 0) end if ctx.dosort then error(ctx.luaname .. ': The ‘all_sorted’ directive is redundant when followed by ‘sequential’', 0) end ctx.iterfunc = ipairs ctx.subset = 1 return context_iterate(ctx, 1) end -- See iface['non-sequential']() library['non-sequential'] = function(ctx) if ctx.subset == 1 then error(ctx.luaname .. ': The two directives ‘sequential’ and ‘non-sequential’ are in contradiction with each other', 0) end ctx.iterfunc = pairs ctx.subset = -1 return context_iterate(ctx, 1) end -- See iface.all_sorted() library.all_sorted = function(ctx) if ctx.subset == 1 then error(ctx.luaname .. ': The ‘all_sorted’ directive is redundant after ‘sequential’', 0) end ctx.dosort = true return context_iterate(ctx, 1) end -- See iface.setting() library.setting = function(ctx) local opts = ctx.pipe local cmd if opts[1] ~= nil then cmd = opts[1]:gsub('%s+', ''):gsub('/+', '/'):match'^/*(.*[^/])' end if cmd == nil then error(ctx.luaname .. ', ‘setting’: No directive was given', 0) end local sep = string.byte('/') local argc = 2 local dest = {} local vname local chr for idx = 1, #cmd do chr = cmd:byte(idx) if chr == sep then for key, val in ipairs(dest) do ctx[val] = opts[argc] dest[key] = nil end argc = argc + 1 else vname = memoryslots[string.char(chr)] if vname == nil then error(ctx.luaname .. ', ‘setting’: Unknown slot "' .. string.char(chr) .. '"', 0) end table.insert(dest, vname) end end for key, val in ipairs(dest) do ctx[val] = opts[argc] end return context_iterate(ctx, argc + 1) end -- See iface.squeezing() library.squeezing = function(ctx) local tbl = ctx.params local store = {} local indices = {} local newlen = 0 for key, val in pairs(tbl) do if type(key) == 'number' then newlen = newlen + 1 indices[newlen] = key store[key] = val tbl[key] = nil end end table.sort(indices) for idx = 1, newlen do tbl[idx] = store[indices[idx]] end return context_iterate(ctx, 1) end -- See iface.cutting() library.cutting = function(ctx) local lcut = tonumber(ctx.pipe[1]) if lcut == nil then error(ctx.luaname .. ', ‘cutting’: Left cut must be a number', 0) end local rcut = tonumber(ctx.pipe[2]) if rcut == nil then error(ctx.luaname .. ', ‘cutting’: Right cut must be a number', 0) end local tbl = ctx.params local len = #tbl if lcut < 0 then lcut = len + lcut end if rcut < 0 then rcut = len + rcut end local tot = lcut + rcut if tot > 0 then local cache = {} if tot >= len then for key, val in ipairs(tbl) do tbl[key] = nil end tot = len else for idx = len - rcut + 1, len, 1 do tbl[idx] = nil end for idx = 1, lcut, 1 do tbl[idx] = nil end end for key, val in pairs(tbl) do if type(key) == 'number' and key > 0 then if key > len then cache[key - tot] = val else cache[key - lcut] = val end tbl[key] = nil end end for key, val in pairs(cache) do tbl[key] = val end end return context_iterate(ctx, 3) end -- See iface.with_name_matching() library.with_name_matching = function(ctx) local tbl = ctx.params local patterns = {} local argc = parse_match_args(ctx.pipe, patterns, 'with_name_matching') local nomatch for key in pairs(tbl) do nomatch = true for _, ptn in ipairs(patterns) do if string.find(key, ptn[1], 1, ptn[2]) then nomatch = false break end end if nomatch then tbl[key] = nil end end return context_iterate(ctx, argc) end -- See iface.with_name_not_matching() library.with_name_not_matching = function(ctx) local tbl = ctx.params local patterns = {} local argc = parse_match_args(ctx.pipe, patterns, 'with_name_not_matching') local yesmatch for key in pairs(tbl) do yesmatch = true for _, ptn in ipairs(patterns) do if not string.find(key, ptn[1], 1, ptn[2]) then yesmatch = false break end end if yesmatch then tbl[key] = nil end end return context_iterate(ctx, argc) end -- See iface.with_value_matching() library.with_value_matching = function(ctx) local tbl = ctx.params local patterns = {} local argc = parse_match_args(ctx.pipe, patterns, 'with_value_matching') local nomatch for key, val in pairs(tbl) do nomatch = true for _, ptn in ipairs(patterns) do if string.find(val, ptn[1], 1, ptn[2]) then nomatch = false break end end if nomatch then tbl[key] = nil end end return context_iterate(ctx, argc) end -- See iface.with_value_not_matching() library.with_value_not_matching = function(ctx) local tbl = ctx.params local patterns = {} local argc = parse_match_args(ctx.pipe, patterns, 'with_value_not_matching') local yesmatch for key, val in pairs(tbl) do yesmatch = true for _, ptn in ipairs(patterns) do if not string.find(val, ptn[1], 1, ptn[2]) then yesmatch = false break end end if yesmatch then tbl[key] = nil end end return context_iterate(ctx, argc) end -- See iface.trimming_values() library.trimming_values = function(ctx) local tbl = ctx.params for key, val in pairs(tbl) do tbl[key] = val:match'^%s*(.-)%s*$' end return context_iterate(ctx, 1) end -- See iface.mapping_values_by_calling() library.mapping_values_by_calling = function(ctx) local opts = ctx.pipe local tname if opts[1] ~= nil then tname = opts[1]:match'^%s*(.*%S)' end if tname == nil then error(ctx.luaname .. ', ‘mapping_values_by_calling’: No template name was provided', 0) end local nargs local margs = {} local tmp = tonumber(opts[2]) if tmp == nil then nargs = 1 elseif tmp < 1 then nargs = 2 else nargs = tmp + 2 for idx = 3, nargs do margs[idx] = opts[idx] end end local model = { title = tname, args = margs } local tbl = ctx.params if ctx.subset == 1 then for key, val in ipairs(tbl) do margs[1] = key margs[2] = val tbl[key] = ctx.frame:expandTemplate(model) end elseif ctx.subset == -1 then tmp = {} for key, val in pairs(tbl) do tmp[key] = true end for key, val in ipairs(tmp) do tmp[key] = nil end for key in pairs(tmp) do margs[1] = key margs[2] = tbl[key] tbl[key] = ctx.frame:expandTemplate(model) end else for key, val in pairs(tbl) do margs[1] = key margs[2] = val tbl[key] = ctx.frame:expandTemplate(model) end end return context_iterate(ctx, nargs + 1) end -- See iface.mapping_values_by_invoking() library.mapping_values_by_invoking = function(ctx) local opts = ctx.pipe local mname local fname if opts[1] ~= nil then mname = opts[1]:match'^%s*(.*%S)' end if mname == nil then error(ctx.luaname .. ', ‘mapping_values_by_invoking’: No module name was provided', 0) end if opts[2] ~= nil then fname = opts[2]:match'^%s*(.*%S)' end if fname == nil then error(ctx.luaname .. ', ‘mapping_values_by_invoking’: No function name was provided', 0) end local nargs local margs = {} local tmp = tonumber(opts[3]) if tmp == nil then nargs = 2 elseif tmp < 1 then nargs = 3 else nargs = tmp + 3 for idx = 4, nargs do margs[idx - 1] = opts[idx] end end local model = { title = 'Module:' .. mname, args = margs } local mfunc = require(model.title)[fname] local tbl = ctx.params if ctx.subset == 1 then for key, val in ipairs(tbl) do margs[1] = key margs[2] = val tbl[key] = mfunc(ctx.frame:newChild(model)) end elseif ctx.subset == -1 then tmp = {} for key, val in pairs(tbl) do tmp[key] = true end for key, val in ipairs(tmp) do tmp[key] = nil end for key in pairs(tmp) do margs[1] = key margs[2] = tbl[key] tbl[key] = mfunc(ctx.frame:newChild(model)) end else for key, val in pairs(tbl) do margs[1] = key margs[2] = val tbl[key] = mfunc(ctx.frame:newChild(model)) end end return context_iterate(ctx, nargs + 1) end -- See iface.mapping_values_blindly_by_calling() library.mapping_values_blindly_by_calling = function(ctx) local opts = ctx.pipe local tname if opts[1] ~= nil then tname = opts[1]:match'^%s*(.*%S)' end if tname == nil then error(ctx.luaname .. ', ‘mapping_values_blindly_by_calling’: No template name was provided', 0) end local nargs local margs = {} local tmp = tonumber(opts[2]) if tmp == nil then nargs = 1 elseif tmp < 1 then nargs = 2 else nargs = tmp + 2 for idx = 3, nargs do margs[idx - 1] = opts[idx] end end local model = { title = tname, args = margs } local tbl = ctx.params if ctx.subset == 1 then for key, val in ipairs(tbl) do margs[1] = val tbl[key] = ctx.frame:expandTemplate(model) end elseif ctx.subset == -1 then tmp = {} for key, val in pairs(tbl) do tmp[key] = true end for key, val in ipairs(tmp) do tmp[key] = nil end for key in pairs(tmp) do margs[1] = tbl[key] tbl[key] = ctx.frame:expandTemplate(model) end else for key, val in pairs(tbl) do margs[1] = val tbl[key] = ctx.frame:expandTemplate(model) end end return context_iterate(ctx, nargs + 1) end -- See iface.mapping_values_blindly_by_invoking() library.mapping_values_blindly_by_invoking = function(ctx) local opts = ctx.pipe local mname local fname if opts[1] ~= nil then mname = opts[1]:match'^%s*(.*%S)' end if mname == nil then error(ctx.luaname .. ', ‘mapping_values_blindly_by_invoking’: No module name was provided', 0) end if opts[2] ~= nil then fname = opts[2]:match'^%s*(.*%S)' end if fname == nil then error(ctx.luaname .. ', ‘mapping_values_blindly_by_invoking’: No function name was provided', 0) end local nargs local margs = {} local tmp = tonumber(opts[3]) if tmp == nil then nargs = 2 elseif tmp < 1 then nargs = 3 else nargs = tmp + 3 for idx = 4, nargs do margs[idx - 2] = opts[idx] end end local model = { title = 'Module:' .. mname, args = margs } local mfunc = require(model.title)[fname] local tbl = ctx.params if ctx.subset == 1 then for key, val in ipairs(tbl) do margs[1] = val tbl[key] = mfunc(ctx.frame:newChild(model)) end elseif ctx.subset == -1 then tmp = {} for key, val in pairs(tbl) do tmp[key] = true end for key, val in ipairs(tmp) do tmp[key] = nil end for key in pairs(tmp) do margs[1] = tbl[key] tbl[key] = mfunc(ctx.frame:newChild(model)) end else for key, val in pairs(tbl) do margs[1] = val tbl[key] = mfunc(ctx.frame:newChild(model)) end end return context_iterate(ctx, nargs + 1) end --[[ Library's functions ]]-- ------------------------------------ -- See iface.count() library.count = function(ctx) local count = 0 for _ in ctx.iterfunc(ctx.params) do count = count + 1 end if ctx.subset == -1 then count = count - #ctx.params end return count end -- See iface.concat_and_call() library.concat_and_call = function(ctx) local opts = ctx.pipe local tname if opts[1] ~= nil then tname = opts[1]:match'^%s*(.*%S)' end if tname == nil then error(ctx.luaname .. ', ‘concat_and_call’: No template name was provided', 0) end table.remove(opts, 1) return ctx.frame:expandTemplate{ title = tname, args = concat_params(ctx) } end -- See iface.concat_and_invoke() library.concat_and_invoke = function(ctx) local opts = ctx.pipe local mname local fname if opts[1] ~= nil then mname = opts[1]:match'^%s*(.*%S)' end if mname == nil then error(ctx.luaname .. ', ‘concat_and_invoke’: No module name was provided', 0) end if opts[2] ~= nil then fname = opts[2]:match'^%s*(.*%S)' end if fname == nil then error(ctx.luaname .. ', ‘concat_and_invoke’: No function name was provided', 0) end table.remove(opts, 2) table.remove(opts, 1) return require('Module:' .. mname)[fname](ctx.frame:newChild{ title = 'Module:' .. fname, args = concat_params(ctx) }) end -- See iface.concat_and_magic() library.concat_and_magic = function(ctx) local opts = ctx.pipe local magic if opts[1] ~= nil then magic = opts[1]:match'^%s*(.*%S)' end if magic == nil then error(ctx.luaname .. ', ‘concat_and_magic’: No parser function was provided', 0) end table.remove(opts, 1) return ctx.frame:callParserFunction(magic, concat_params(ctx)) end -- See iface.value_of() library.value_of = function(ctx) local opts = ctx.pipe local keystr if opts[1] ~= nil then keystr = opts[1]:match'^%s*(.*%S)' end if keystr == nil then error(ctx.luaname .. ', ‘value_of’: No parameter name was provided', 0) end local keynum = tonumber(keystr) local len = #ctx.params if ( ctx.subset == -1 and keynum ~= nil and len >= keynum ) or ( ctx.subset == 1 and (keynum == nil or len < keynum) ) then return (ctx.ifngiven or '') end local val = ctx.params[keynum or keystr] if val == nil then return (ctx.ifngiven or '') end return (ctx.header or '') .. val .. (ctx.footer or '') end -- See iface.list() library.list = function(ctx) local kvs = ctx.pairsep or '' local pps = ctx.itersep or '' local ret = {} local nss = 0 flush_params( ctx, function(key, val) ret[nss + 1] = pps ret[nss + 2] = key ret[nss + 3] = kvs ret[nss + 4] = val nss = nss + 4 end ) if nss > 0 then if nss > 4 and ctx.lastsep ~= nil then ret[nss - 3] = ctx.lastsep end ret[1] = ctx.header or '' if ctx.footer ~= nil then ret[nss + 1] = ctx.footer end return table.concat(ret) end return ctx.ifngiven or '' end -- See iface.list_values() library.list_values = function(ctx) local pps = ctx.itersep or '' local ret = {} local nss = 0 flush_params( ctx, function(key, val) ret[nss + 1] = pps ret[nss + 2] = val nss = nss + 2 end ) if nss > 0 then if nss > 2 and ctx.lastsep ~= nil then ret[nss - 1] = ctx.lastsep end ret[1] = ctx.header or '' if ctx.footer ~= nil then ret[nss + 1] = ctx.footer end return table.concat(ret) end return ctx.ifngiven or '' end -- See iface.for_each() library.for_each = function(ctx) local txt = ctx.pipe[1] or '' local pps = ctx.itersep or '' local ret = {} local nss = 0 flush_params( ctx, function(key, val) ret[nss + 1] = pps ret[nss + 2] = txt:gsub('%$#', key):gsub('%$@', val) nss = nss + 2 end ) if nss > 0 then if nss > 2 and ctx.lastsep ~= nil then ret[nss - 1] = ctx.lastsep end ret[1] = ctx.header or '' if ctx.footer ~= nil then ret[nss + 1] = ctx.footer end return table.concat(ret) end return ctx.ifngiven or '' end -- See iface.call_for_each() library.call_for_each = function(ctx) local opts = ctx.pipe local tname if opts[1] ~= nil then tname = opts[1]:match'^%s*(.*%S)' end if tname == nil then error(ctx.luaname .. ', ‘call_for_each’: No template name was provided', 0) end local model = { title = tname, args = opts } local ccs = ctx.itersep or '' local ret = {} local nss = 0 table.insert(opts, 1, true) flush_params( ctx, function(key, val) opts[1] = key opts[2] = val ret[nss + 1] = ccs ret[nss + 2] = ctx.frame:expandTemplate(model) nss = nss + 2 end ) if nss > 0 then if nss > 2 and ctx.lastsep ~= nil then ret[nss - 1] = ctx.lastsep end ret[1] = ctx.header or '' if ctx.footer ~= nil then ret[nss + 1] = ctx.footer end return table.concat(ret) end return ctx.ifngiven or '' end -- See iface.invoke_for_each() library.invoke_for_each = function(ctx) local opts = ctx.pipe local mname local fname if opts[1] ~= nil then mname = opts[1]:match'^%s*(.*%S)' end if mname == nil then error(ctx.luaname .. ', ‘invoke_for_each’: No module name was provided', 0) end if opts[2] ~= nil then fname = opts[2]:match'^%s*(.*%S)' end if fname == nil then error(ctx.luaname .. ', ‘invoke_for_each’: No function name was provided', 0) end local model = { title = 'Module:' .. mname, args = opts } local mfunc = require(model.title)[fname] local ccs = ctx.itersep or '' local ret = {} local nss = 0 flush_params( ctx, function(key, val) opts[1] = key opts[2] = val ret[nss + 1] = ccs ret[nss + 2] = mfunc(ctx.frame:newChild(model)) nss = nss + 2 end ) if nss > 0 then if nss > 2 and ctx.lastsep ~= nil then ret[nss - 1] = ctx.lastsep end ret[1] = ctx.header or '' if ctx.footer ~= nil then ret[nss + 1] = ctx.footer end return table.concat(ret) end return ctx.ifngiven or '' end -- See iface.magic_for_each() library.magic_for_each = function(ctx) local opts = ctx.pipe local magic if opts[1] ~= nil then magic = opts[1]:match'^%s*(.*%S)' end if magic == nil then error(ctx.luaname .. ', ‘magic_for_each’: No parser function was provided', 0) end local ccs = ctx.itersep or '' local ret = {} local nss = 0 table.insert(opts, 1, true) flush_params( ctx, function(key, val) opts[1] = key opts[2] = val ret[nss + 1] = ccs ret[nss + 2] = ctx.frame:callParserFunction(magic, opts) nss = nss + 2 end ) if nss > 0 then if nss > 2 and ctx.lastsep ~= nil then ret[nss - 1] = ctx.lastsep end ret[1] = ctx.header or '' if ctx.footer ~= nil then ret[nss + 1] = ctx.footer end return table.concat(ret) end return ctx.ifngiven or '' end -- See iface.call_for_each_value() library.call_for_each_value = function(ctx) local opts = ctx.pipe local tname if opts[1] ~= nil then tname = opts[1]:match'^%s*(.*%S)' end if tname == nil then error(ctx.luaname .. ', ‘call_for_each_value’: No template name was provided', 0) end local model = { title = tname, args = opts } local ccs = ctx.itersep or '' local ret = {} local nss = 0 flush_params( ctx, function(key, val) opts[1] = val ret[nss + 1] = ccs ret[nss + 2] = ctx.frame:expandTemplate(model) nss = nss + 2 end ) if nss > 0 then if nss > 2 and ctx.lastsep ~= nil then ret[nss - 1] = ctx.lastsep end ret[1] = ctx.header or '' if ctx.footer ~= nil then ret[nss + 1] = ctx.footer end return table.concat(ret) end return ctx.ifngiven or '' end -- See iface.invoke_for_each_value() library.invoke_for_each_value = function(ctx) local opts = ctx.pipe local mname local fname if opts[1] ~= nil then mname = opts[1]:match'^%s*(.*%S)' end if mname == nil then error(ctx.luaname .. ', ‘invoke_for_each_value’: No module name was provided', 0) end if opts[2] ~= nil then fname = opts[2]:match'^%s*(.*%S)' end if fname == nil then error(ctx.luaname .. ', ‘invoke_for_each_value’: No function name was provided', 0) end local model = { title = 'Module:' .. mname, args = opts } local mfunc = require(model.title)[fname] local ccs = ctx.itersep or '' local ret = {} local nss = 0 table.remove(opts, 1) flush_params( ctx, function(key, val) opts[1] = val ret[nss + 1] = ccs ret[nss + 2] = mfunc(ctx.frame:newChild(model)) nss = nss + 2 end ) if nss > 0 then if nss > 2 and ctx.lastsep ~= nil then ret[nss - 1] = ctx.lastsep end ret[1] = ctx.header or '' if ctx.footer ~= nil then ret[nss + 1] = ctx.footer end return table.concat(ret) end return ctx.ifngiven or '' end -- See iface.magic_for_each_value() library.magic_for_each_value = function(ctx) local opts = ctx.pipe local magic if opts[1] ~= nil then magic = opts[1]:match'^%s*(.*%S)' end if magic == nil then error(ctx.luaname .. ', ‘magic_for_each_value’: No parser function was provided', 0) end local ccs = ctx.itersep or '' local ret = {} local nss = 0 flush_params( ctx, function(key, val) opts[1] = val ret[nss + 1] = ccs ret[nss + 2] = ctx.frame:callParserFunction(magic, opts) nss = nss + 2 end ) if nss > 0 then if nss > 2 and ctx.lastsep ~= nil then ret[nss - 1] = ctx.lastsep end ret[1] = ctx.header or '' if ctx.footer ~= nil then ret[nss + 1] = ctx.footer end return table.concat(ret) end return ctx.ifngiven or '' end -- See iface.self() library.self = function(ctx) return ctx.frame:getTitle() end --- --- --- PUBLIC ENVIRONMENT --- --- ________________________________ --- --- --- -- The public table of functions local iface = {} --[[ Modifiers ]]-- ------------------------------------ -- Syntax: #invoke:params|sequential|function name iface.sequential = function(frame) return context_init(frame, library.sequential, false, false) end -- Syntax: #invoke:params|non-sequential|function name iface['non-sequential'] = function(frame) return context_init(frame, library['non-sequential'], false, false) end -- Syntax: #invoke:params|sort|function name iface.all_sorted = function(frame) return context_init(frame, library.all_sorted, false, false) end -- Syntax: #invoke:params|setting|directives|...|function name iface.setting = function(frame) return context_init(frame, library.setting, false, false) end -- Syntax: #invoke:params|squeezing|function name iface.squeezing = function(frame) return context_init(frame, library.squeezing, false, false) end -- Syntax: #invoke:params|cutting|left cut|right cut|function name iface.cutting = function(frame) return context_init(frame, library.cutting, false, false) end -- Syntax: #invoke:params|with_name_matching|pattern 1|[plain flag 1]|[or] -- |[pattern 2]|[plain flag 2]|[or]|[...]|[pattern N]|[plain flag -- N]|function name iface.with_name_matching = function(frame) return context_init(frame, library.with_name_matching, false, false) end -- Syntax: #invoke:params|with_name_not_matching|pattern 1|[plain flag 1] -- |[and]|[pattern 2]|[plain flag 2]|[and]|[...]|[pattern N]|[plain -- flag N]|function name iface.with_name_not_matching = function(frame) return context_init(frame, library.with_name_not_matching, false, false) end -- Syntax: #invoke:params|with_value_matching|pattern 1|[plain flag 1]|[or] -- |[pattern 2]|[plain flag 2]|[or]|[...]|[pattern N]|[plain flag -- N]|function name iface.with_value_matching = function(frame) return context_init(frame, library.with_value_matching, false, false) end -- Syntax: #invoke:params|with_value_not_matching|pattern 1|[plain flag 1] -- |[and]|[pattern 2]|[plain flag 2]|[and]|[...]|[pattern N]|[plain -- flag N]|function name iface.with_value_not_matching = function(frame) return context_init(frame, library.with_value_not_matching, false, false) end -- Syntax: #invoke:params|trimming_values|function name iface.trimming_values = function(frame) return context_init(frame, library.trimming_values, false, false) end -- Syntax: #invoke:params|mapping_values_by_calling|template name|[number of additional -- arguments]|[argument 1]|[argument 2]|[...]|[argument N]|function -- name iface.mapping_values_by_calling = function(frame) return context_init(frame, library.mapping_values_by_calling, false, false) end -- Syntax: #invoke:params|mapping_values_by_invoking|module name|function name|[number of -- additional arguments]|[argument 1]|[argument 2]|[...]|[argument -- N]|function name iface.mapping_values_by_invoking = function(frame) return context_init(frame, library.mapping_values_by_invoking, false, false) end -- Syntax: #invoke:params|mapping_values_blindly_by_calling|template name|[number of -- additional arguments]|[argument 1]|[argument 2]|[...]|[argument -- N]|function name iface.mapping_values_blindly_by_calling = function(frame) return context_init(frame, library.mapping_values_blindly_by_calling, false, false) end -- Syntax: #invoke:params|mapping_values_blindly_by_invoking|module name|function name -- |[number of additional arguments]|[argument 1]|[argument 2]|[...] -- |[argument N]|function name iface.mapping_values_blindly_by_invoking = function(frame) return context_init(frame, library.mapping_values_blindly_by_invoking, false, false) end --[[ Functions ]]-- ---------------------------------------- -- Syntax: #invoke:params|count iface.count = function(frame) return context_init(frame, library.count, true, true) end -- Syntax: #invoke:args|concat_and_call|template name|[prepend 1]|[prepend 2] -- |[...]|[item n]|[named item 1=value 1]|[...]|[named item n=value -- n]|[...] iface.concat_and_call = function(frame) return context_init(frame, library.concat_and_call, false, true) end -- Syntax: #invoke:args|concat_and_invoke|module name|function name|[prepend -- 1]|[prepend 2]|[...]|[item n]|[named item 1=value 1]|[...]|[named -- item n=value n]|[...] iface.concat_and_invoke = function(frame) return context_init(frame, library.concat_and_invoke, false, true) end -- Syntax: #invoke:args|concat_and_magic|parser function|[prepend 1]|[prepend -- 2]|[...]|[item n]|[named item 1=value 1]|[...]|[named item n= -- value n]|[...] iface.concat_and_magic = function(frame) return context_init(frame, library.concat_and_magic, false, true) end -- Syntax: #invoke:params|value_of|parameter name iface.value_of = function(frame) return context_init(frame, library.value_of, true, true) end -- Syntax: #invoke:params|list iface.list = function(frame) return context_init(frame, library.list, true, false) end -- Syntax: #invoke:params|list_values iface.list_values = function(frame) return context_init(frame, library.list_values, true, false) end -- Syntax: #invoke:params|for_each|wikitext iface.for_each = function(frame) return context_init(frame, library.for_each, true, false) end -- Syntax: #invoke:params|call_for_each|template name|[append 1]|[append 2] -- |[...]|[append n]|[named param 1=value 1]|[...]|[named param -- n=value n]|[...] iface.call_for_each = function(frame) return context_init(frame, library.call_for_each, false, false) end -- Syntax: #invoke:params|invoke_for_each|module name|module function|[append -- 1]|[append 2]|[...]|[append n]|[named param 1=value 1]|[...] -- |[named param n=value n]|[...] iface.invoke_for_each = function(frame) return context_init(frame, library.invoke_for_each, false, false) end -- Syntax: #invoke:params|magic_for_each|parser function|[append 1]|[append 2] -- |[...]|[append n]|[named param 1=value 1]|[...]|[named param -- n=value n]|[...] iface.magic_for_each = function(frame) return context_init(frame, library.magic_for_each, false, false) end -- Syntax: #invoke:params|call_for_each_value|template name|[append 1]|[append -- 2]|[...]|[append n]|[named param 1=value 1]|[...]|[named param -- n=value n]|[...] iface.call_for_each_value = function(frame) return context_init(frame, library.call_for_each_value, false, false) end -- Syntax: #invoke:params|invoke_for_each_value|module name|[append 1]|[append -- 2]|[...]|[append n]|[named param 1=value 1]|[...]|[named param -- n=value n]|[...] iface.invoke_for_each_value = function(frame) return context_init(frame, library.invoke_for_each_value, false, false) end -- Syntax: #invoke:params|magic_for_each_value|parser function|[append 1] -- |[append 2]|[...]|[append n]|[named param 1=value 1]|[...]|[named -- param n=value n]|[...] iface.magic_for_each_value = function(frame) return context_init(frame, library.magic_for_each_value, false, false) end -- Syntax: #invoke:params|self iface.self = function(frame) return frame:getParent():getTitle() end return iface