Extension:Scribunto/Debug console

Usage

Under the module editing window there is a "Debug console" window, where you can enter any line of text for Lua to evaluate. This includes the ability to return value of a variable using =, for example =a will return value of the variable "a" if it was previously defined in the console.

More importantly, it is also possible for the console to return value of the first variable returned by the module, using =p. (Note that the actual name of the variable doesn't matter, as it is always only accessible under that name.)
If that variable is a table, it is known as the "export table" and all functions belonging to it can be accessed with the #invoke Parser function.
Additionally, the console will also show output from print(), mw.log() and mw.logObject() functions.

To simulate calling a function inside the module, you need to enter a line in the following format: =p.function(frame)
Where "function" is the function in the Lua module export table that you want to call (for example "main"), and "frame" is a frame object analog(?) of the call that invokes the module.

Examples

Invoking module directly

Given Module:Test with the following contents:

local p = {}
function p.main(frame)
   local args = frame.args
   mw.log("log test")
   return args[1]..args["sep"]..args[2]
end
return p

The following invoke call: {{#invoke:Test|a|sep=;|b}} Can be simulated accurately with the following code in the debug console:

=p.main(
   mw.getCurrentFrame():newChild{
      title="Module:Test",
      args={"a",["sep"]=";","b"}
   }
)

Note that in this example the element in the export table which is being evaluated is called "main".

Simplified version

If the module you are debugging does not use any frame object methods (such as frame:preprocess()), like the example above, then the frame object analog(?) does not have to be complete, and the debugging code can be simplified into the following:

=p.main{
   args={"a",["sep"]=";","b"}
}

Invoking through a template

Given Module:Test with the following contents:

local p = {}
function p.main(frame)
   local args = frame:getParent().args
   mw.log("log test")
   return args[1]..args["sep"]..args[2]
end
return p

And the following "Template:Test":
{{#invoke|Test|main}}
The following template call: {{Test|a|sep=;|b}}
Can be simulated accurately with the following code in the debug console:

=p.main(
   mw.getCurrentFrame():newChild{
      title="Template:Test",
      args={"a",["sep"]=";","b"}
   }:newChild{
      title="Module:Test",
      args={}
   }
)

This example does not declare any extra arguments directly in the #invoke call, if that's required then appropiate elements should be added to the empty args table near the end of the debug code.

Note that this module uses frame:getParent() method, which means the debug code cannot be simplified as much, although it is still possible:

=p.main(
   mw.getCurrentFrame():newChild{
      args={"a",["sep"]=";","b"}
   }:newChild{}
)