Module:LuaCall

Module documentation[view] [edit] [history] [purge]

This module allows you to call any one single preinstalled Lua function, so that you don't need to write a module for one desired feature.

Usage

Main

{{#invoke:LuaCall|main|arbitrary variables|parameters|functioncall}}

The arbitrary variables are any key of your choice = any value of your choice. Values are interpreted as strings unless tonumber(value) isn't nil, i.e. numbers should be converted to the numeric type. No effort is made to interpret tables.

The parameters all begin with reserved_, which arbitrary variable should use.

• reserved_return sets which output from the function you want, and defaults to 1. For example, setting it to 2 for mw.ustring.gsub will return the number of replacements made.
• reserved_debug - nonzero value forces display of a not particularly useful debug text

The functioncall is written as some.function.name(a,b,c) where some.function.name means something in the Extension:Scribunto/Lua reference manual and a,b,c are the arbitrary variable names you've chosen.

Examples

Main

• {{#invoke:LuaCall|main|a=test |b=7|string.rep(a,b)}} → test test test test test test test 
• {{#invoke:LuaCall|main|pattern=(%a)|replace=%1.|string=I can't get no satisfaction|mw.ustring.gsub(string,pattern,replace)|reserved_return=1}} → I. c.a.n.'t. g.e.t. n.o. s.a.t.i.s.f.a.c.t.i.o.n.
• {{#invoke:LuaCall|main|pattern=(%a)|replace=%1.|string=I can't get no satisfaction|mw.ustring.gsub(string,pattern,replace)|reserved_return=2}} → 22
• {{#invoke:LuaCall|main|value=1.4512|math.ceil(value)}} → 2
• {{#invoke:LuaCall|main|value=1.4512|math.modf(value)}} → 1
• {{#invoke:LuaCall|main|value=1.4512|math.modf(value)|reserved_return=2}} → 0.4512
• {{#invoke:LuaCall|main|mw.text.nowiki(s)|s={{URL|1=https://www.Amazon.com/}}}} → <span class="url">[https://www.Amazon.com/ www<wbr/>.amazon<wbr/>.com]</span>

Call

• {{#invoke:LuaCall|call|string.format|%04x|127}} → 007f
• {{#invoke:LuaCall|call|math.modf|1.4512}} → 1
• {{#invoke:LuaCall|call|math.modf|1.4512|return=2}} → 1

Errors

The module may generate script errors — whenever your call is not valid Lua code, you see the error you would normally have. For example,

{{#invoke:LuaCall|main|value=1.4512|math.fmod(value)}} →

because the second value is lacking. No effort is made to trap these.

The above documentation is transcluded from Module:LuaCall/doc. (edit | history)
Editors can experiment in this module's sandbox (edit | diff) and testcases (edit | run) pages.
Subpages of this module.

local p={}

function p.main(frame)
    local parent=frame.getParent(frame) or {}
    local reserved_value={}
    local reserved_function,reserved_contents
    for k,v in pairs(parent.args or {}) do
        --if tonumber(v) then v=tonumber(v) end
        _G[k]=tonumber(v) or v -- transfer every parameter directly to the global variable table
        -- debuglog=debuglog..k.."="..v.."</nowiki><br /><nowiki>"
    end
    for k,v in pairs(frame.args or {}) do
        --if tonumber(v) then v=tonumber(v) end       
        _G[k]=tonumber(v) or v -- transfer every parameter directly to the global variable table
    end
     --- Alas Scribunto does NOT implement coroutines, according to
     --- http://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual#string.format
     --- this will not stop us from trying to implement one single lousy function call
    if _G[1] then
        reserved_function,reserved_contents=mw.ustring.match(_G[1],"^%s*(%a[^%s%(]*)%(([^%)]*)%)%s*$")
    end
    if reserved_contents then
        local reserved_counter=0
        repeat
            reserved_counter=reserved_counter+1
            reserved_value[reserved_counter]=_G[mw.ustring.match(reserved_contents,"([^%,]+)")]
            reserved_contents=mw.ustring.match(reserved_contents,"[^%,]+,(.*)$")
        until not reserved_contents
    end
    local reserved_arraypart=_G
    while mw.ustring.match(reserved_function,"%.") do
        reserved_functionpart,reserved_function=mw.ustring.match(reserved_function,"^(%a[^%.]*)%.(.*)$")
        reserved_arraypart=reserved_arraypart[reserved_functionpart]
    end
    local reserved_call=reserved_arraypart[reserved_function]
    if type(reserved_call)~="function" then
        return tostring(reserved_call)
    elseif reserved_debug or not reserved_function then return mw.text.nowiki(debuglog)
    else reserved_output={reserved_call(unpack(reserved_value))}
        return reserved_output[reserved_return or 1]
    end
end

-- This function is modified from https://en.wikipedia.org/wiki/Module:Ustring?oldid=885619921
-- All frame's arguments are coerced as number type if possible. If you wish for something to remain a string, you can simply escape it by insert \ at the beginning of the string. 
function p.import(o)
	local p = {}

	for k, v in pairs(o) do
		p[k] = function(frame)
			local args = {}
			for _, v in ipairs(frame.args) do
				table.insert(args, tonumber(v) or v:gsub("^\\", "", 1))
			end
			return (v(unpack(args)))
		end
	end

	return p
end

-- ipairsAt()/ipairsAtOffset() will be proposed to be placed in [[Module:TableTools]]
--[[
------------------------------------------------------------------------------------
-- ipairsAt
--
-- This is an iterator for arrays. It can be used like ipairs, but with
-- specified i as first index to iterate.
--
--    for i,v in p.ipairsAt(t, 3) do body end
--
-- will iterate over the pairs (3,t[3]),(4,t[4]),..., up to the first
-- integer key absent from the table.
--
-- Note: The following is an example to do range iteration from 3 to j
--
--    for i,v in p.ipairsAt(t, 3) do if i>j then break end; body end
--
------------------------------------------------------------------------------------
--]]
local function ipairsAt(t, i)
	--return ipairsAtOffset(t, i-1)
	-- This may be less overhead than return ipairsAtOffset() above
	local f, s, i0 = ipairs(t)
	return f, s, i0+i-1
end

--[[
------------------------------------------------------------------------------------
-- ipairsAtOffset
--
-- Like ipairsAt(), except that it treat argument i as offset from 1
--
------------------------------------------------------------------------------------
--]]
local function ipairsAtOffset(t, i)
	local f, s, i0 = ipairs(t)
	return f, s, i0+i
end

--[[
------------------------------------------------------------------------------------
-- call
--
-- Example:
--    {{#invoke:LuaCall|call|mw.log|a|1|2|3}} will return mw.log('a', 1, 2, 3)
--    {{#invoke:LuaCall|call|mw.logObject|a|321}} will return mw.logObject('a', 321)
--
------------------------------------------------------------------------------------
--]]
function p.call(frame)
	local args = {}
	--local f = mw.text.trim(frame.args[1], '%s')
	for _, v in ipairsAtOffset(frame.args, 1) do
		table.insert(args, tonumber(v) or v:gsub("^\\", "", 1))
	end
	local G = _G
	for _ in mw.text.gsplit(
		mw.text.trim(frame.args[1], '%s'), '%s*%.%s*'
	) do
		G = G[_]
	end
	return (G(unpack(args)))
end

return p