Brighter Shores:Lua/Helper modules
Jump to navigation
Jump to search
This is a table of modules and functions that were created specifically for facilitating the creation of other modules. Documentation for modules here is done in the source code with Template:Helper module. In all below descriptions, optional arguments have square brackets around them with default values after a pipe, if appropriate. i.e. foo( x, [y|1] ) means function foo has one required argument, and the second argument is optional and will default to 1.
| Module | Function | Type | Use | Example |
|---|---|---|---|---|
| Array | all( arr, [fn] ) | arr: any[] fn?: any -> boolean | Behaviour depends on the value of fn:
| |
any( arr, [fn] ) | arr: any[] fn?: any -> boolean | Behaviour depends on the value of fn:
| ||
clean( arr ) | arr: any[] -> any[] | Recursively removes all metatables. | ||
clone( arr, [deep] ) | arr: any[] deep?: boolean -> any[] | Make a copy of the input table. Preserves metatables. | ||
contains( arr, val ) | arr: any[] val: any -> boolean | Check if arr contains val. | ||
containsAny( arr, t ) | arr: any[] t: any[] -> boolean | Check if arr contains any of the values in the table t. | ||
containsAll( arr, t ) | arr: any[] t: any[] -> boolean | Check if arr contains all values in the table t. | ||
convolve( x, y ) | x: number[] y: number[] -> number[] | Convolute two number arrays. | ||
condenseSparse( arr ) | arr: any[] -> any[] | Remove nil values from arr while preserving order. | ||
count( arr, fn ) | arr: any[] fn: any -> integer | Behaviour depends on value of val:
| ||
diff( arr, [order|1] ) | arr: number[] order?: number -> number[] | Differentiates arr. The length of the result is #arr - order long. | ||
each( arr, fn ) | arr: any[] fn: fun(elem: any, i?: integer) | Loops over the array part of arr and passes each element as the first argument to fn. This function returns nothing. | ||
filter( arr, fn ) | arr: any[] fn: fun(elem: any, i?: integer): boolean-> any[] | Makes a copy of arr with only elements for which fn returned true. | ||
find( arr, fn, [default] ) | arr: any[] fn: any default?: any -> any?, integer? | Behaviour depends on the value of fn:
| ||
find_index( arr, fn, [default] ) | arr: any[] fn: any default?: any -> integer? | Behaviour depends on the value of fn:
| ||
get( arr, indexes ) | arr: any[] indexes: integer|integer[] -> any[] | Extracts a subset of arr. | ||
int( arr, [start|1], [stop|#arr] ) | arr: number[] start?: number stop?: number -> number[] | Integrates arr from index start to stop. Effectively does . | ||
intersect( arr1, arr2 ) | arr1: any[] arr2: any[] -> any[] | Returns an array with elements that are present in both tables. | ||
intersects( arr1, arr2 ) | arr1: any[] arr2: any[] -> boolean | Checks if the two inputs have at least one element in common. | ||
insert( arr, val, [index], [unpackVal] )insert( arr, val, [unpackVal] ) | arr: any[] val: any index?: integer unpackVal?: boolean -> any[] | Inserts values into arr. If val is an array and unpackVal is true then the individual elements of val are inserted. index is the location to start the insertion. Default is at the end of arr. | ||
last( arr ) | arr: any[] -> any | Returns the last element of arr. | ||
len( arr ) | arr: any[] -> integer | Returns the length of the array but it also works on proxy arrays like mw.loadData or mw.loadJsonData. | ||
map( arr, fn ) | arr: any[] fn: fun(elem: any, i?: integer): any-> any[] | Returns a new table were each element of arr is modified by fn. | ||
max_by( arr, fn ) | arr: any[] fn: fun(elem: any): any-> any, integer | Find the element for which fn returned the largest value. The returned value of fn needs to be comparable using the < operator. Returns three values: The element with the largest fn value, its fn result, and its index. | ||
max( arr ) | arr: any[] -> any, integer | Find the largest value in the array. The values need to be comparable using the < operator. Returns two values: the element and its index. | ||
min( arr ) | arr: any[] -> any, integer | Find the smallest value in the array. The values need to be comparable using the < operator. Returns two values: the element and its index. | ||
new( [arr|{}] ) | arr?: any[] -> any[] | Turn the input table into an Array. This makes it possible to use the colon : operator to access the Array methods. It also enables the use of math operators with the array.
local x = arr.new{ 1, 2, 3 }
local y = arr{ 4, 5, 6 } -- Alternative notation
mw.logObject( -x ) --> { -1, -2, -3 }
mw.logObject( x + 2 ) --> { 3, 4, 5 }
mw.logObject( x - 2 ) --> { -1, 0, 1 }
mw.logObject( x * 2 ) --> { 2, 4, 6 }
mw.logObject( x / 2 ) --> { 0.5, 1, 1.5 }
mw.logObject( x ^ 2 ) --> { 1, 4, 9 }
mw.logObject( x + y ) --> { 5, 7, 9 }
mw.logObject( x .. y ) --> { 1, 2, 3, 4, 5, 6 }
mw.logObject( (x .. y):reject{3, 4, 5} ) --> { 1, 2, 6 }
mw.logObject( x:sum() ) --> 6
mw.logObject( x:update( {1, 3}, y:get{2, 3} * 2 ) ) --> { 10, 2, 12 }
| ||
newIncrementor( [start|1], [step|1] ) | start?: number step?: number -> Incrementor | Returns a new incrementor function. Every time this incrementor function is called it returns a number step higher than the previous call. The current value can be obtained with inc.n or set inc.n = number where inc is an incrementor function. The step size can be changed with inc.step = number. | ||
range( stop )range( start, stop, [step|1] ) | start: number stop: number step?: number -> number[] | Returns a table containing a sequence of numbers from start to stop (both inclusive if ints, end-exclusive if floats) by step. range(4) produces {1, 2, 3, 4} (start defaults to 1). range(0, 4) produces {0, 1, 2, 3, 4}. When step is given, it specifies the increment (or decrement). | ||
reduce( arr, fn, [accumulator|arr[1]] ) | arr: any[] fn: fun(elem: any, acc: any, i?: integer): anyaccumulator?: any -> any | Condenses the array into a single value.
For each element If no local t = { 1, 2, 3, 4 }
local sum = arr.reduce( t, function(elem, acc) return acc + elem end ) -- sum == 10
| ||
reject( arr, val ) | arr: any[] val: any -> any[] | Make a copy off arr with certain values removed.
Behaviour for different values of
| ||
rep( val, n ) | val: any n: number -> any[] | Returns a table with n copies of val. | ||
scan( arr, fn, [accumulator|arr[1]] ) | arr: any[] fn: fun(elem: any, acc: any, i?: integer): anyaccumulator?: any -> any[] | Condenses the array into a single value while saving every accumulator value.
For each element If no local t = { 1, 2, 3, 4 }
local x = arr.scan( t, function(elem, acc) return acc + elem end ) -- x = { 1, 3, 6, 10 }
| ||
set( arr, indexes, values ) | arr: any[] indexes: integer|integer[] values: any|any[] -> any[] | Update a range of index with a range of values.
If if only one value is given but multiple indexes than that value is set for all those indexes. Ifvalues is a table then it must of the same length as indexes. | ||
slice( arr, [start|1], [stop|#arr] )slice( arr, stop ) | arr: any[] start?: number stop?: number -> any[] | Returns a table containing all the elements of arr between the start and stop indices. The start and stop indices are inclusive. If start or stop are negative values then they are referenced to the end of the table. | ||
split( arr, index ) | arr: any[] index: number -> any[], any[] | Split arr into two arrays. Retuns two tables. The first contains elements from [1, index], and the second from [index + 1, #arr]. | ||
sum( arr ) | arr: number[] -> number | Returns the sum of all elements of arr. | ||
take( arr, count, [start|1] ) | arr: any[] count: number start?: number -> any[] | Extract a subtable from arr of count elements long starting from the start index. | ||
take_every( arr, n, [start|1], [count|#arr] ) | arr: any[] n: integer start?: integer count?: integer -> any[] | Extract a subtable from arr.
local t = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }
local x = arr.take_every( t, 2 ) --> x = { 1, 3, 5, 7, 9 }
local x = arr.take_every( t, 2, 3 ) --> x = { 3, 5, 7, 9 }
local x = arr.take_every( t, 2, 3, 2 ) --> x = { 3, 5 }
| ||
unique( arr, [fn] ) | arr: any[] fn?: fun(elem: any): any-> any[] | Return a new table with all duplicates removed. fn is an optional function to generate an id for each element. The result will then contain elements that generated unique ids. The order of first occurance is preserved. | ||
zip( ... ) | ...any[] -> any[][] | Combine elements with the same index from multiple arrays.
local x = {1, 2, 3}
local y = {4, 5, 6, 7}
local z = arr.zip( x, y ) --> z = { { 1, 4 }, { 2, 5 }, { 3, 6 }, { 7 } }
| ||
| Clean image | clean{ file = [string|'no'], width = [string|nil], height = [string|nil], link = [string|nil], align = [string|nil] } | table | Used to clean up user input; extracts only the file name of the input and returns its own formatted link.
Input is a table with fields:
| |
| DPLlua | ask( ... ) | tables | ask takes a series of tables each containing the settings for a DPL query; it will return the same number of result tables as input tables. All formatting settings are stripped from the config. If the config does not contains include, the result will be a simple list of page names.
{
<pagename#1>,
<pagename#2>,
<pagename#3>,
}
A query with an {
['include'] = {
['template#1'] = {
[1] = val#1,
[2] = val#2,
['param1'] = val#3,
['param2'] = val#4,
},
['template#2'] = {
[3] = val#5,
['param1'] = val#6,
},
['%0'] = val#7
},
['title'] = <pagename>
}
You can also do If the config value The output contains a If the DPL throws an error it will be available in the Differences with normal DPL:
|notcategory = val#1 |notcategory = val#2Note of warning, if you include content containing § symbols the result may be unreliable. If you include a whole template (e.g. include = '{some template}'), content inside strip markers (not nowiki) can't be cleaned up inside lua so pipe characters (|) will be replaced with § characters and the { and } characters are replaced by ❴ (U+2774) and ❵ (U+2775). Use include = '{some template}, {some template}:1:2:3' instead for the problem parameters. | |
| Mw.html extension | addClassIf(cond, class) | boolean, string | If cond = true it behaves the same as the normal addClass function, otherwise it's a no-op. Ex.: mw.html.create('div'):addClassIf(true, 'align-left-1') | |
attrIf(cond, name, value) | boolean, string/table, string/nil | Similar to addClassIf | ||
cssIf(cond, name, value) | boolean, string/table, string/nil | Similar to addClassIf | ||
doneIf(cond) | boolean | Similar to addClassIf | ||
tagIf(cond, tag) | boolean, string | Similar to addClassIf | ||
wikitextIf(cond, text) | boolean, string | Similar to addClassIf | ||
na() | N/A | Shortcut for :tag('td'):attr('data-sort-value', 0):attr('class','table-na'):wikitext('<small>N/A</small>'):done() | ||
naIf(cond) | boolean | Similar to addClassIf | ||
tr([settings]) | table/nil | Shortcut for :tag('tr') but also auto closes the previous 'tr', 'th' or 'td' tag (so you don't need to add :done() before it). settings is a table with keys:
| ||
th([settings]) | string/table/nil | Shortcut for :tag('th'):wikitext(settings) if settings is a string. Also auto closes the previous 'th' or 'td' tag. settings can also be a table with keys:
| ||
td([settings]) | string/table/nil | Same as :th(). Example:
local tbl = mw.html.create('table')
tbl:tr{ class='sortable' }
:th{'foo', attr={'data-sort-type', 'number'}}
:th('bar')
:tr()
:td('buz')
:attr('data-sort-value', 10)
:td{'N/A', class='table-na'}
| ||
IF(cond) | boolean | Allows for if-blocks without breaking the chain. If the condition is true it is a no-op, if false everything inside the balanced IF-END block will be ignored. Can be nested. Ex.:
mw.html.create('div')
:IF(true)
:wikitext('Conditional text')
:END()
:...
Note: This only prevents elements from being added to your html object, it does not protect against statements that throw errors. I.e mw.html.create('div')
:IF(false)
:wikitext(5 * nil) -- This will still throw an error
:END()
| ||
ELSEIF(cond) | boolean | Used together with IF(). | ||
ELSE() | N/A | Used together with IF(). | ||
END() | N/A | Used together with IF(). Make sure the IF-END tags are balanced, it wont throw an error if they are not. | ||
exec(func, ...) | function, any | Call a function without breaking the chain. See module docs for more info. | ||
addFunction(func, name) | function, string | Add a function to the mw.html class that can then be used on mw.html object. See module docs for more info. | ||
| Paramtest | is_empty(arg) | String | Returns true if arg is not defined or contains only whitespace | |
has_content(arg) | String | Returns true if arg exists and does not only contain whitespace | ||
default_to(arg1,arg2) | String, Any value | If arg1 exists and does not only contain whitespace, the function returns arg1, otherwise returns arg2 | ||
defaults{ {arg1,arg2},...} | {String, Any value}... | Does the same as default_to() run over every table passed; for technical reasons, all nil are replaced with false | ||
| Yesno | (arg) | Any value | Reads arg for yes/no and returns the appropriate boolean or nil | |
(arg1,arg2) | Any value, Any value | Reads arg1 for yes/no and returns the appropriate boolean; returns arg2 if arg1 was not an applicable value |