Wikipedia:Lua/Modul/TemplatePar/en

Vorlagenprogrammierung	Diskussionen	Lua			Test	Unterseiten
		Modul	Deutsch	English		Modul:	Dokumentation

TemplatePar – Module with support for template programming, focussing on parameters of template transclusion.

While the module name suggests usage with templates, lua modules are supported as well.

• assert – Check single string
• check – Check transclusion of template
• count – Number of template parameters
• countNotEmpty – Number of template parameters which contain more than whitespace
• downcase – All template transclusion parameters in lower case
• match – Combined analysis of parameters and their values
• valid – Test single template parameter value
• verify – Check #invoke parameter set

Functions for templates

The analysis is operating on the template transclusion parameters. Parameters of #invoke are described below; they are controlling the analysis.

assert

Check single string

1

String to be tested

2

Condition (optional but recommended and meaningful)

check

Test for assigned and unexpected parameters at template transclusion; completeness of required values. Details below.

An error message will be returned enclosed in class=error.

If nothing is returned no error was detected.

Parameters (all optional):

all

Names of mandatory parameters (all to be supplied); they are also to be provided with trimmed non-empty value.

Multiple items separated by = equal sign.

If lacking in transclusion a standard message will be triggered. For individual handling it should be mentioned at opt and analysed by template programming.

opt

Names of optional parameters.

Multiple items separated by = equal sign.

low

true: ignore case

count

Number of parameters at template transclusion.

Parameter: None (at #invoke)

The result is a number beginning at 0.

countNotEmpty

Number of parameters at template transclusion which contain more than whitespace.

Parameter: None (at #invoke)

The result is a number beginning at 0.

match

Combined analysis of parameters and their values; is template profile matching current transclusion?

1

Rule in format   1=parameter name=condition

n…

Like 1 – any unnamed parameter in any order imposes further rules on template parameters.

All permitted optional template parameters are to be mentioned, at least by * condition.

An error message will be returned enclosed in class=error. Fatal errors will be visible at following levels: Unknown parameter name – missing parameter – invalid parameter value.

If “nothing” is returned no error was detected.

valid

Check validity of one particular template parameter.

An error message will be returned enclosed in class=error.

If nothing is returned no error was detected.

Parameters (all but 1 optional):

1

Name of analyzed template parameter.

2

Format („Digits only“, „ASCII“, limited character set, Lua-pattern); see below.

min

Minimal length ≥0.

max

Maximal length >0.

From the group 2, min, max at least one condition should be provided for meaningful rules.

low

true: ignore case

Common error handling

All functions described above maintain also the following parameters:

template

Title of template visible to page editors (for error messages).

Might be a different identifier. Mainly intended for sub-templates.

May contain wikilinks.

cat

Title of a maintenance category.

In case of error this will be activated (appended to result).

If the string @@@ is found in title and template is provided, that will be replaced by template.

noError

Suppress error message, if visible value given (noError=1).

Parameter test (check)

Use case on commons:Template:Information example:

{{#invoke:TemplatePar
         |check
         |all= description= source= author=
         |opt= date= permission= other_versions= other_fields=
         |template=Information}}

• Since the name of a template parameter can’t contain an = equal sign, those are used for separation of names. Whitespace before and after names will be ignored; as well as additional equal signs.
• The first three parameters of this example are mandatory and need to be provided including non-empty value.
• Any parameter name appearing in template transclusion, which is neither listed in all= nor in opt= will trigger an error message.
• Unnamed template parameters are identified by their sequence number. Those will be used in the error message.
• There are four error messages:
  1. TemplatePar#invoke: repeated optional parameter
     • On module invocation a name has been listed in both all= and opt=.
     • This might not be suppressed by noError=1 since it has been caused by template programmer and not page author.
  2. Error in template: unknown parameter name
     • On template transclusion a parameter has been used which is not listed at all= nor opt=.
  3. Error in template: mandatory parameter missing
     • On template transclusion a parameter from the all= list is missing.
  4. Error in template: undefined value for mandatory
     • On template transclusion a parameter from the all= list is given with equal sign but no visible value, or an unnamed parameter is empty, leaving a gap between two pipe symbols.

Parameter format (valid)

There are two methods for the optional condition 2:

1. Keyword
   • Makes life easier for template programmers.
   • Only generic formats are subject to this module. Specific formats like DOI, ISBN, URL, or date and time would cause too many changes, extensions and need too many maintenance updates.
2. Lua-Pattern (Ustring)
   • Enclosed in slashes / to distinguish from keyword and detect closing and trailing whitespace on values of unnamed template parameters.
   • The strings | as well as {{ and }} are not possible in template programming. They are to be replaced:
     • | → %!
     • {{ → %((
     • }} → %))

Examples (test page)

A test page illustrates practical use.

Functions for Lua modules (API)

All functions for templates are accessible; for basic functionality see above. Further functions can be used by modules only.

Usage by require():

local lucky, TemplatePar = pcall( require, "Module:TemplatePar" )
if type( TemplatePar ) == "table" then
    TemplatePar = TemplatePar.TemplatePar()
else
    -- error; TemplatePar contains error message
    return "<span class='error'>" .. TemplatePar .. "</span>"
end

TemplatePar.assert(analyze,append,options)

Analyse a string as by valid.

analyze

• string to be analysed

append

• string; append error message; prepend <br /> if not empty
• else: throw error

options

table; Details; options and all components optional

• key

  string; key

• pattern

  string; Lua pattern

• min

  number

• max

  number

• template
• cat
• noError
true: suppress error message.

Return: false, if valid; else error message

TemplatePar.check(options)

options

table; Details; options and all components optional

• mandatory

  table; sequence with names of mandatory parameters

• optional

  table; sequence with names of optional parameters

• low

  true: ignore case

• template
• cat
• noError
true: suppress error message.

Return: false, if valid; else error message

TemplatePar.count()

TemplatePar.countNotEmpty()

TemplatePar.downcase(options)

All template transclusion parameters in lower case

Returns table with .args (number of unnamed, string of named template parameters).

Error message, if the same name occurs in different spellings.

options

table; Details; options and all components optional

• template
• cat
• noError
true: suppress error message.

TemplatePar.valid(seek, options)

seek

Zeichenkette; name of template parameter.

options

table; Details; options and all components optional

• key

  string; key

• pattern

  string; Lua pattern

• min

  number

• max

  number

• low

  true: ignore case

• template
• cat
• noError
true: suppress error message.

Both key and pattern must not be used.

Returns false if valid; else error message

TemplatePar.verify(options)

Like TemplatePar.check(), but parameters of #invoke

TemplatePar()

Returns table with access to functions.

Usage

General library; no limitations.

Dependencies

None.

Internationalization

• Internationalization is prepared.
• The Module looks whether a localization for the current project language is available. If not found, messages are returned in English.

System messages

lua-module-TemplatePar-badPattern	#invoke:TemplatePar pattern syntax error #invoke:TemplatePar Syntaxfehler des pattern
lua-module-TemplatePar-dupOpt	#invoke:TemplatePar repeated optional parameter #invoke:TemplatePar Optionsparameter wiederholt
lua-module-TemplatePar-dupRule	#invoke:TemplatePar parameter conflict key/pattern #invoke:TemplatePar Parameterkonflikt key/pattern
lua-module-TemplatePar-empty	Error in template * undefined value for mandatory Fehler bei Vorlage: Pflichtparameter ohne Wert
lua-module-TemplatePar-invalid	Error in template * invalid parameter Fehler bei Vorlage: Parameter ungültig
lua-module-TemplatePar-invalidPar	#invoke:TemplatePar invalid parameter #invoke:TemplatePar Ungültiger Parameter
lua-module-TemplatePar-minmax	#invoke:TemplatePar min > max #invoke:TemplatePar min > max
lua-module-TemplatePar-multiSpell	Error in template * multiple spelling of parameter Fehler bei Vorlage * Mehrere Parameter-Schreibweisen
lua-module-TemplatePar-noErrorCat	#invoke:TemplatePar noError and missing category #invoke:TemplatePar noError und keine Kategorie
lua-module-TemplatePar-noname	#invoke:TemplatePar missing parameter name #invoke:TemplatePar Parametername nicht angegeben
lua-module-TemplatePar-tooLong	Error in template * parameter too long Fehler bei Vorlage: Parameter zu lang
lua-module-TemplatePar-tooShort	Error in template * parameter too short Fehler bei Vorlage: Parameter zu kurz
lua-module-TemplatePar-undefined	Error in template * mandatory parameter missing Fehler bei Vorlage: Pflichtparameter fehlt
lua-module-TemplatePar-unknown	Error in template * unknown parameter name Fehler bei Vorlage: Parametername unbekannt
lua-module-TemplatePar-unknownRule	#invoke:TemplatePar unknown rule #invoke:TemplatePar Unbekannte Regel