Module:string: Difference between revisions

 

        an empty string being returned rather than an error message.

 

    error_category: If an error occurs, specifies the name of a category to

        include with the error message. The default category is

        [Category:Errors reported by Module String].

 

        is generated.

 

Unit tests for this module are available at Module:String/tests.

 

local str = {}

{{#invoke:String|len|target_string|}}

{{#invoke:String|len|s=target_string}}

function str.len( frame )

local new_args = str._getParameters( frame.args, {'s'} );

local s = new_args['s'] or '';

return mw.ustring.len( s )

{{#invoke:String|sub|target_string|start_index|end_index}}

{{#invoke:String|sub|s=target_string|i=start_index|j=end_index}}

 

function str.sub( frame )

local new_args = str._getParameters( frame.args, { 's', 'i', 'j' } );

local s = new_args['s'] or '';

local i = tonumber( new_args['i'] ) or 1;

local j = tonumber( new_args['j'] ) or -1;

 

local len = mw.ustring.len( s );

 

 

if i > len or j > len or i < 1 or j < 1 then

return str._error( 'String subset index out of range' );

return str._error( 'String subset indices out of order' );

 

return mw.ustring.sub( s, i, j )

function str.sublength( frame )

local i = tonumber( frame.args.i ) or 0

local len = tonumber( frame.args.len )

return mw.ustring.sub( frame.args.s, i + 1, len and ( i + len ) )

{{#invoke:String|match|source_string|pattern_string|start_index|match_number|plain_flag|nomatch}}

{{#invoke:String|pos|s=source_string|pattern=pattern_string|start=start_index

* https://www.lua.org/manual/5.1/manual.html#5.4.1

* https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual#Patterns

* https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual#Ustring_patterns

function str._match( s, pattern, start, match_index, plain, nomatch )

return str._error( 'Target string is empty' );

return str._error( 'Pattern string is empty' );

if math.abs(start) < 1 or math.abs(start) > mw.ustring.len( s ) then

return str._error( 'Requested start is out of range' );

return str._error( 'Match index is out of range' );

pattern = str._escapePattern( pattern );

 

result = mw.ustring.match( s, pattern, start )

s = mw.ustring.sub( s, start );

 

local iterator = mw.ustring.gmatch(s, pattern);

 

result = result_table[ count + match_index ];

 

return str._error( 'Match not found' );

{{#invoke:String|pos|target_string|index_value}}

{{#invoke:String|pos|target=target_string|pos=index_value}}

function str.pos( frame )

local new_args = str._getParameters( frame.args, {'target', 'pos'} );

local pos = tonumber( new_args['pos'] ) or 0;

 

if pos == 0 or math.abs(pos) > mw.ustring.len( target_str ) then

return str._error( 'String index out of range' );

 

return mw.ustring.sub( target_str, pos, pos );

function str.str_find( frame )

local new_args = str._getParameters( frame.args, {'source', 'target'} );

 

 

local start = mw.ustring.find( source_str, target_str, 1, true )

 

{{#invoke:String|find|source_str|target_string|start_index|plain_flag}}

{{#invoke:String|find|source=source_str|target=target_str|start=start_index|plain=plain_flag}}

function returns 0.  If either "source" or "target" are missing / empty, this

function also returns 0.

function str.find( frame )

local new_args = str._getParameters( frame.args, {'source', 'target', 'start', 'plain' } );

local source_str = new_args['source'] or '';

local pattern = new_args['target'] or '';

local start_pos = tonumber(new_args['start']) or 1;

local plain = new_args['plain'] or true;

 

if source_str == '' or pattern == '' then

return 0;

 

plain = str._getBoolean( plain );

 

local start = mw.ustring.find( source_str, pattern, start_pos, plain )

if start == nil then

 

{{#invoke:String|replace|source_str|pattern_string|replace_string|replacement_count|plain_flag}}

{{#invoke:String|replace|source=source_string|pattern=pattern_string|replace=replace_string|

function str.replace( frame )

local new_args = str._getParameters( frame.args, {'source', 'pattern', 'replace', 'count', 'plain' } );

local count = tonumber( new_args['count'] );

 

plain = str._getBoolean( plain );

 

pattern = str._escapePattern( pattern );

replace = mw.ustring.gsub( replace, "%%", "%%%%" ); --Only need to escape replacement sequences.

 

return result;

function str.rep( frame )

local repetitions = tonumber( frame.args[2] )

return str._error( 'function rep expects a number as second parameter, received "' .. ( frame.args[2] or '' ) .. '"' )

return string.rep( frame.args[1] or '', repetitions )

This function escapes special characters from a Lua string pattern. See [1]

for details on how patterns work.

[1] https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual#Patterns

Usage:

{{#invoke:String|escapePattern|pattern_string}}

    pattern_string: The pattern string to escape.

function str.escapePattern( frame )

local pattern_str = frame.args[1]

if not pattern_str then

return str._error( 'No pattern string specified' );

local result = str._escapePattern( pattern_str )

function str._getParameters( frame_args, arg_list )

 

for i,arg in ipairs( arg_list ) do

 

function str._error( error_str )

 

 

if error_category ~= '' and not str._getBoolean( no_category ) then

 

function str._getBoolean( boolean_str )

 

if type( boolean_str ) == 'string' then

elseif type( boolean_str ) == 'boolean' then

error( 'No boolean value found' );

Helper function that escapes all pattern characters so that they will be treated

as plain text.

]]

function str._escapePattern( pattern_str )

return mw.ustring.gsub( pattern_str, "([%(%)%.%%%+%-%*%?%[%^%$%]])", "%%%1" );

return str