439
edits
(pass the config through to NowikiInvocation from TableInvocation:getInvocation) |
m (87 revisions imported from wikipedia:Module:Template_test_case) |
||
(50 intermediate revisions by 11 users not shown) | |||
Line 1: | Line 1: | ||
-- This module | --[[ | ||
A module for generating test case templates. | |||
This module incorporates code from the English Wikipedia's "Testcase table" | |||
module,[1] written by Frietjes [2] with contributions by Mr. Stradivarius [3] | |||
and Jackmcbarn,[4] and the English Wikipedia's "Testcase rows" module,[5] | |||
written by Mr. Stradivarius. | |||
The "Testcase table" and "Testcase rows" modules are released under the | |||
CC BY-SA 3.0 License [6] and the GFDL.[7] | |||
License: CC BY-SA 3.0 and the GFDL | |||
Author: Mr. Stradivarius | |||
[1] https://en.wikipedia.org/wiki/Module:Testcase_table | |||
[2] https://en.wikipedia.org/wiki/User:Frietjes | |||
[3] https://en.wikipedia.org/wiki/User:Mr._Stradivarius | |||
[4] https://en.wikipedia.org/wiki/User:Jackmcbarn | |||
[5] https://en.wikipedia.org/wiki/Module:Testcase_rows | |||
[6] https://en.wikipedia.org/wiki/Wikipedia:Text_of_Creative_Commons_Attribution-ShareAlike_3.0_Unported_License | |||
[7] https://en.wikipedia.org/wiki/Wikipedia:Text_of_the_GNU_Free_Documentation_License | |||
]] | |||
-- Load required modules | -- Load required modules | ||
local yesno = require('Module:Yesno') | local yesno = require('Module:Yesno') | ||
-- Set constants | -- Set constants | ||
local DATA_MODULE = 'Module:Template test case/data' | local DATA_MODULE = 'Module:Template test case/data' | ||
------------------------------------------------------------------------------- | |||
-- Shared methods | |||
------------------------------------------------------------------------------- | |||
local function message(self, key, ...) | |||
-- This method is added to classes that need to deal with messages from the | |||
-- config module. | |||
local msg = self.cfg.msg[key] | |||
if select(1, ...) then | |||
return mw.message.newRawMessage(msg, ...):plain() | |||
else | |||
return msg | |||
end | |||
end | |||
------------------------------------------------------------------------------- | ------------------------------------------------------------------------------- | ||
Line 19: | Line 54: | ||
getFullPage = true, | getFullPage = true, | ||
getName = true, | getName = true, | ||
makeHeader = true, | |||
getOutput = true | getOutput = true | ||
} | } | ||
function Template.new(invocationObj, options) | function Template.new(invocationObj, options) | ||
Line 84: | Line 94: | ||
function Template:getFullPage() | function Template:getFullPage() | ||
if self.template then | if not self.template then | ||
return self.title.prefixedText | |||
elseif self.template:sub(1, 7) == '#invoke' then | |||
return 'Module' .. self.template:sub(8):gsub('|.*', '') | |||
else | |||
local strippedTemplate, hasColon = self.template:gsub('^:', '', 1) | local strippedTemplate, hasColon = self.template:gsub('^:', '', 1) | ||
hasColon = hasColon > 0 | hasColon = hasColon > 0 | ||
Line 96: | Line 110: | ||
return mw.site.namespaces[10].name .. ':' .. strippedTemplate | return mw.site.namespaces[10].name .. ':' .. strippedTemplate | ||
end | end | ||
end | end | ||
end | end | ||
Line 123: | Line 135: | ||
end | end | ||
function Template: | function Template:makeHeader() | ||
return self.heading or self:makeBraceLink() | return self.heading or self:makeBraceLink() | ||
end | end | ||
function Template:getInvocation(format) | function Template:getInvocation(format) | ||
local invocation = self._invocation:getInvocation | local invocation = self._invocation:getInvocation{ | ||
template = self:getName(), | |||
requireMagicWord = self.requireMagicWord, | |||
} | |||
if format == 'code' then | if format == 'code' then | ||
invocation = '<code>' .. mw.text.nowiki(invocation) .. '</code>' | invocation = '<code>' .. mw.text.nowiki(invocation) .. '</code>' | ||
elseif format == 'kbd' then | |||
invocation = '<kbd>' .. mw.text.nowiki(invocation) .. '</kbd>' | |||
elseif format == 'plain' then | elseif format == 'plain' then | ||
invocation = mw.text.nowiki(invocation) | invocation = mw.text.nowiki(invocation) | ||
Line 143: | Line 160: | ||
function Template:getOutput() | function Template:getOutput() | ||
return self._invocation | local protect = require('Module:Protect') | ||
-- calling self._invocation:getOutput{...} | |||
return protect(self._invocation.getOutput)(self._invocation, { | |||
template = self:getName(), | |||
requireMagicWord = self.requireMagicWord, | |||
}) | |||
end | end | ||
Line 152: | Line 174: | ||
local TestCase = {} | local TestCase = {} | ||
TestCase.__index = TestCase | TestCase.__index = TestCase | ||
TestCase.message = message -- add the message method | |||
TestCase.renderMethods = { | |||
-- Keys in this table are values of the "format" option, values are the | |||
-- method for rendering that format. | |||
columns = 'renderColumns', | |||
rows = 'renderRows', | |||
tablerows = 'renderRows', | |||
inline = 'renderInline', | |||
cells = 'renderCells', | |||
default = 'renderDefault' | |||
} | |||
function TestCase.new(invocationObj, options, cfg) | function TestCase.new(invocationObj, options, cfg) | ||
Line 157: | Line 191: | ||
obj.cfg = cfg | obj.cfg = cfg | ||
-- | -- Separate general options from template options. Template options are | ||
-- numbered, whereas general options are not. | |||
local generalOptions, templateOptions = {}, {} | |||
for k, v in pairs(options) do | |||
local prefix, num | |||
if type(k) == 'string' then | |||
prefix, num = k:match('^(.-)([1-9][0-9]*)$') | |||
end | end | ||
if prefix then | |||
num = tonumber(num) | |||
templateOptions[num] = templateOptions[num] or {} | |||
templateOptions[num][prefix] = v | |||
else | |||
generalOptions[k] = v | |||
end | end | ||
end | end | ||
-- | -- Set general options | ||
generalOptions.showcode = yesno(generalOptions.showcode) | |||
obj.options = | generalOptions.showheader = yesno(generalOptions.showheader) ~= false | ||
generalOptions.showcaption = yesno(generalOptions.showcaption) ~= false | |||
generalOptions.collapsible = yesno(generalOptions.collapsible) | |||
generalOptions.notcollapsed = yesno(generalOptions.notcollapsed) | |||
generalOptions.wantdiff = yesno(generalOptions.wantdiff) | |||
obj.options = generalOptions | |||
-- | -- Preprocess template args | ||
for num, t in pairs(templateOptions) do | |||
if t.showtemplate ~= nil then | |||
t.showtemplate = yesno(t.showtemplate) | |||
end | |||
end | |||
-- | -- Set up first two template options tables, so that if only the | ||
-- "template3" is specified it isn't made the first template when the | |||
-- the table options array is compressed. | |||
templateOptions[1] = templateOptions[1] or {} | templateOptions[1] = templateOptions[1] or {} | ||
templateOptions[2] = templateOptions[2] or {} | templateOptions[2] = templateOptions[2] or {} | ||
-- Allow the "template" option to override the "template1" option for | |||
-- backwards compatibility with [[Module:Testcase table]]. | |||
if generalOptions.template then | |||
templateOptions[1].template = generalOptions.template | |||
end | |||
-- Add default template options | |||
if templateOptions[1].template and not templateOptions[2].template then | if templateOptions[1].template and not templateOptions[2].template then | ||
templateOptions[2].template = templateOptions[1].template .. '/ | templateOptions[2].template = templateOptions[1].template .. | ||
'/' .. obj.cfg.sandboxSubpage | |||
end | end | ||
if not templateOptions[1].template then | if not templateOptions[1].template then | ||
Line 198: | Line 245: | ||
end | end | ||
if not templateOptions[2].template then | if not templateOptions[2].template then | ||
templateOptions[2].title = templateOptions[1].title:subPageTitle( | templateOptions[2].title = templateOptions[1].title:subPageTitle( | ||
obj.cfg.sandboxSubpage | |||
) | |||
end | |||
-- Remove template options for any templates where the showtemplate | |||
-- argument is false. This prevents any output for that template. | |||
for num, t in pairs(templateOptions) do | |||
if t.showtemplate == false then | |||
templateOptions[num] = nil | |||
end | |||
end | end | ||
-- Check for missing template names. | |||
for num, t in pairs(templateOptions) do | |||
if not t.template and not t.title then | |||
error(obj:message( | |||
'missing-template-option-error', | |||
num, num | |||
), 2) | |||
end | |||
end | |||
-- Compress templateOptions table so we can iterate over it with ipairs. | |||
templateOptions = (function (t) | |||
local nums = {} | |||
for num in pairs(t) do | |||
nums[#nums + 1] = num | |||
end | |||
table.sort(nums) | |||
local ret = {} | |||
for i, num in ipairs(nums) do | |||
ret[i] = t[num] | |||
end | |||
return ret | |||
end)(templateOptions) | |||
-- Don't require the __TEMPLATENAME__ magic word for nowiki invocations if | |||
-- there is only one template being output. | |||
if #templateOptions <= 1 then | |||
templateOptions[1].requireMagicWord = false | |||
end | |||
mw.logObject(templateOptions) | |||
-- Make the template objects | -- Make the template objects | ||
obj.templates = {} | obj.templates = {} | ||
for i, | for i, options in ipairs(templateOptions) do | ||
table.insert(obj.templates, Template.new(invocationObj, | table.insert(obj.templates, Template.new(invocationObj, options)) | ||
end | |||
-- Add tracking categories. At the moment we are only tracking templates | |||
-- that use any "heading" parameters or an "output" parameter. | |||
obj.categories = {} | |||
for k, v in pairs(options) do | |||
if type(k) == 'string' and k:find('heading') then | |||
obj.categories['Test cases using heading parameters'] = true | |||
elseif k == 'output' then | |||
obj.categories['Test cases using output parameter'] = true | |||
end | |||
end | end | ||
Line 216: | Line 316: | ||
end | end | ||
return output | return output | ||
end | |||
function TestCase:templateOutputIsEqual() | |||
-- Returns a boolean showing whether all of the template outputs are equal. | |||
-- The random parts of strip markers (see [[Help:Strip markers]]) are | |||
-- removed before comparison. This means a strip marker can contain anything | |||
-- and still be treated as equal, but it solves the problem of otherwise | |||
-- identical wikitext not returning as exactly equal. | |||
local function normaliseOutput(obj) | |||
local out = obj:getOutput() | |||
-- Remove the random parts from strip markers. | |||
out = out:gsub('(\127\'"`UNIQ.-)%-%x+%-(QINU`"\'\127)', '%1%2') | |||
return out | |||
end | |||
local firstOutput = normaliseOutput(self.templates[1]) | |||
for i = 2, #self.templates do | |||
local output = normaliseOutput(self.templates[i]) | |||
if output ~= firstOutput then | |||
return false | |||
end | |||
end | |||
return true | |||
end | end | ||
function TestCase:makeCollapsible(s) | function TestCase:makeCollapsible(s) | ||
local | local title = self.options.title or self.templates[1]:makeHeader() | ||
if self.options.titlecode then | |||
title = self.templates[1]:getInvocation('kbd') | |||
end | |||
local isEqual = self:templateOutputIsEqual() | |||
local root = mw.html.create('table') | local root = mw.html.create('table') | ||
if self.options.wantdiff then | |||
root | root | ||
:addClass('collapsible') | :addClass('mw-collapsible') | ||
:addClass(isEqual and 'collapsed' or nil) | if self.options.notcollapsed == false then | ||
root | |||
:addClass('mw-collapsed') | |||
end | |||
root | |||
:css('background-color', 'transparent') | |||
:css('width', '100%') | |||
:css('border', 'solid silver 1px') | |||
:tag('tr') | |||
:tag('th') | |||
:css('background-color', isEqual and 'yellow' or '#90a8ee') | |||
:wikitext(title) | |||
:done() | |||
:done() | |||
:tag('tr') | |||
:tag('td') | |||
:newline() | |||
:wikitext(s) | |||
:newline() | |||
else | |||
root | |||
:addClass('mw-collapsible') | |||
if self.options.notcollapsed == false then | |||
root | |||
:addClass('mw-collapsed') | |||
end | |||
if self.options.notcollapsed ~= true or false then | |||
root | |||
:addClass(isEqual and 'mw-collapsed' or nil) | |||
end | |||
root | |||
:css('background-color', 'transparent') | :css('background-color', 'transparent') | ||
:css('width', '100%') | :css('width', '100%') | ||
Line 230: | Line 387: | ||
:tag('th') | :tag('th') | ||
:css('background-color', isEqual and 'lightgreen' or 'yellow') | :css('background-color', isEqual and 'lightgreen' or 'yellow') | ||
:wikitext( | :wikitext(title) | ||
:done() | :done() | ||
:done() | :done() | ||
:tag('tr') | :tag('tr') | ||
:tag('td') | :tag('td') | ||
:newline() | |||
:wikitext(s) | :wikitext(s) | ||
:newline() | |||
end | |||
return tostring(root) | return tostring(root) | ||
end | end | ||
Line 248: | Line 408: | ||
local tableroot = root:tag('table') | local tableroot = root:tag('table') | ||
-- | if self.options.showheader then | ||
-- Caption | |||
if self.options.showcaption then | |||
tableroot | |||
:addClass(self.options.class) | |||
:cssText(self.options.style) | |||
:tag('caption') | |||
:wikitext(self.options.caption or self:message('columns-header')) | |||
end | |||
-- Headers | |||
local headerRow = tableroot:tag('tr') | |||
if self.options.rowheader then | |||
-- rowheader is correct here. We need to add another th cell if | |||
-- rowheader is set further down, even if heading0 is missing. | |||
headerRow:tag('th'):wikitext(self.options.heading0) | |||
end | |||
local width | |||
if #self.templates > 0 then | |||
width = tostring(math.floor(100 / #self.templates)) .. '%' | |||
else | |||
width = '100%' | |||
end | |||
for i, obj in ipairs(self.templates) do | |||
headerRow | |||
:tag('th') | |||
:css('width', width) | |||
:wikitext(obj:makeHeader()) | |||
end | |||
end | end | ||
Line 284: | Line 450: | ||
-- Template output | -- Template output | ||
for i, obj in ipairs(self.templates) do | for i, obj in ipairs(self.templates) do | ||
dataRow:tag('td') | if self.options.output == 'nowiki+' then | ||
:newline() | dataRow:tag('td') | ||
:wikitext(self:getTemplateOutput(obj)) | :newline() | ||
:wikitext(self.options.before) | |||
:wikitext(self:getTemplateOutput(obj)) | |||
:wikitext(self.options.after) | |||
:wikitext('<pre style="white-space: pre-wrap;">') | |||
:wikitext(mw.text.nowiki(self.options.before or "")) | |||
:wikitext(mw.text.nowiki(self:getTemplateOutput(obj))) | |||
:wikitext(mw.text.nowiki(self.options.after or "")) | |||
:wikitext('</pre>') | |||
elseif self.options.output == 'nowiki' then | |||
dataRow:tag('td') | |||
:newline() | |||
:wikitext(mw.text.nowiki(self.options.before or "")) | |||
:wikitext(mw.text.nowiki(self:getTemplateOutput(obj))) | |||
:wikitext(mw.text.nowiki(self.options.after or "")) | |||
else | |||
dataRow:tag('td') | |||
:newline() | |||
:wikitext(self.options.before) | |||
:wikitext(self:getTemplateOutput(obj)) | |||
:wikitext(self.options.after) | |||
end | |||
end | end | ||
Line 313: | Line 499: | ||
for _, obj in ipairs(self.templates) do | for _, obj in ipairs(self.templates) do | ||
-- | local dataRow = tableroot:tag('tr') | ||
:tag(' | -- Header | ||
:tag('td') | if self.options.showheader then | ||
if self.options.format == 'tablerows' then | |||
dataRow:tag('th') | |||
:attr('scope', 'row') | |||
:css('vertical-align', 'top') | |||
:css('text-align', 'left') | |||
:wikitext(obj:makeHeader()) | |||
dataRow:tag('td') | |||
:css('vertical-align', 'top') | |||
:css('padding', '0 1em') | |||
:wikitext('→') | |||
else | |||
dataRow:tag('td') | |||
:css('text-align', 'center') | :css('text-align', 'center') | ||
:css('font-weight', 'bold') | :css('font-weight', 'bold') | ||
:wikitext(obj: | :wikitext(obj:makeHeader()) | ||
dataRow = tableroot:tag('tr') | |||
: | end | ||
:tag('tr') | end | ||
:tag('td') | |||
-- Template output | |||
if self.options.output == 'nowiki+' then | |||
dataRow:tag('td') | |||
:newline() | |||
:wikitext(self:getTemplateOutput(obj)) | |||
:wikitext('<pre style="white-space: pre-wrap;">') | |||
:wikitext(mw.text.nowiki(self:getTemplateOutput(obj))) | |||
:wikitext('</pre>') | |||
elseif self.options.output == 'nowiki' then | |||
dataRow:tag('td') | |||
:newline() | |||
:wikitext(mw.text.nowiki(self:getTemplateOutput(obj))) | |||
else | |||
dataRow:tag('td') | |||
:newline() | |||
:wikitext(self:getTemplateOutput(obj)) | |||
end | |||
end | |||
return tostring(root) | |||
end | |||
function TestCase:renderInline() | |||
local arrow = mw.language.getContentLanguage():getArrow('forwards') | |||
local ret = {} | |||
for i, obj in ipairs(self.templates) do | |||
local line = {} | |||
line[#line + 1] = self.options.prefix or '* ' | |||
if self.options.showcode then | |||
line[#line + 1] = obj:getInvocation('code') | |||
line[#line + 1] = ' ' | |||
line[#line + 1] = arrow | |||
line[#line + 1] = ' ' | |||
end | |||
if self.options.output == 'nowiki+' then | |||
line[#line + 1] = self:getTemplateOutput(obj) | |||
line[#line + 1] = '<pre style="white-space: pre-wrap;">' | |||
line[#line + 1] = mw.text.nowiki(self:getTemplateOutput(obj)) | |||
line[#line + 1] = '</pre>' | |||
elseif self.options.output == 'nowiki' then | |||
line[#line + 1] = mw.text.nowiki(self:getTemplateOutput(obj)) | |||
else | |||
line[#line + 1] = self:getTemplateOutput(obj) | |||
end | |||
ret[#ret + 1] = table.concat(line) | |||
end | |||
if self.options.addline then | |||
local line = {} | |||
line[#line + 1] = self.options.prefix or '* ' | |||
line[#line + 1] = self.options.addline | |||
ret[#ret + 1] = table.concat(line) | |||
end | |||
return table.concat(ret, '\n') | |||
end | |||
function TestCase:renderCells() | |||
local root = mw.html.create() | |||
local dataRow = root:tag('tr') | |||
dataRow | |||
:css('vertical-align', 'top') | |||
:addClass(self.options.class) | |||
:cssText(self.options.style) | |||
-- Row header | |||
if self.options.rowheader then | |||
dataRow:tag('th') | |||
:attr('scope', 'row') | |||
:newline() | |||
:wikitext(self.options.rowheader or self:message('row-header')) | |||
end | |||
-- Caption | |||
if self.options.showcaption then | |||
dataRow:tag('th') | |||
:attr('scope', 'row') | |||
:newline() | |||
:wikitext(self.options.caption or self:message('columns-header')) | |||
end | |||
-- Show code | |||
if self.options.showcode then | |||
dataRow:tag('td') | |||
:newline() | |||
:wikitext(self:getInvocation('code')) | |||
end | |||
-- Template output | |||
for i, obj in ipairs(self.templates) do | |||
if self.options.output == 'nowiki+' then | |||
dataRow:tag('td') | |||
:newline() | |||
:wikitext(self.options.before) | |||
:wikitext(self:getTemplateOutput(obj)) | |||
:wikitext(self.options.after) | |||
:wikitext('<pre style="white-space: pre-wrap;">') | |||
:wikitext(mw.text.nowiki(self.options.before or "")) | |||
:wikitext(mw.text.nowiki(self:getTemplateOutput(obj))) | |||
:wikitext(mw.text.nowiki(self.options.after or "")) | |||
:wikitext('</pre>') | |||
elseif self.options.output == 'nowiki' then | |||
dataRow:tag('td') | |||
:newline() | |||
:wikitext(mw.text.nowiki(self.options.before or "")) | |||
:wikitext(mw.text.nowiki(self:getTemplateOutput(obj))) | |||
:wikitext(mw.text.nowiki(self.options.after or "")) | |||
else | |||
dataRow:tag('td') | |||
:newline() | |||
:wikitext(self.options.before) | |||
:wikitext(self:getTemplateOutput(obj)) | |||
:wikitext(self.options.after) | |||
end | |||
end | end | ||
return tostring(root) | return tostring(root) | ||
Line 338: | Line 646: | ||
for i, obj in ipairs(self.templates) do | for i, obj in ipairs(self.templates) do | ||
ret[#ret + 1] = '<div style="clear: both;"></div>' | ret[#ret + 1] = '<div style="clear: both;"></div>' | ||
ret[#ret + 1] = obj: | if self.options.showheader then | ||
ret[#ret + 1] = self:getTemplateOutput(obj) | ret[#ret + 1] = obj:makeHeader() | ||
end | |||
if self.options.output == 'nowiki+' then | |||
ret[#ret + 1] = self:getTemplateOutput(obj) .. '<pre style="white-space: pre-wrap;">' .. mw.text.nowiki(self:getTemplateOutput(obj)) .. '</pre>' | |||
elseif self.options.output == 'nowiki' then | |||
ret[#ret + 1] = mw.text.nowiki(self:getTemplateOutput(obj)) | |||
else | |||
ret[#ret + 1] = self:getTemplateOutput(obj) | |||
end | |||
end | end | ||
return table.concat(ret, '\n\n') | return table.concat(ret, '\n\n') | ||
Line 345: | Line 661: | ||
function TestCase:__tostring() | function TestCase:__tostring() | ||
local format = self.options.format | local format = self.options.format | ||
local method = format and | local method = format and TestCase.renderMethods[format] or 'renderDefault' | ||
local ret = self[method](self) | local ret = self[method](self) | ||
if self.options.collapsible then | if self.options.collapsible then | ||
ret = self:makeCollapsible(ret) | ret = self:makeCollapsible(ret) | ||
end | |||
for cat in pairs(self.categories) do | |||
ret = ret .. string.format('[[Category:%s]]', cat) | |||
end | end | ||
return ret | return ret | ||
Line 365: | Line 679: | ||
local NowikiInvocation = {} | local NowikiInvocation = {} | ||
NowikiInvocation.__index = NowikiInvocation | NowikiInvocation.__index = NowikiInvocation | ||
NowikiInvocation.message = message -- Add the message method | |||
function NowikiInvocation.new(invocation, cfg) | function NowikiInvocation.new(invocation, cfg) | ||
Line 381: | Line 696: | ||
end | end | ||
function NowikiInvocation:getInvocation( | function NowikiInvocation:getInvocation(options) | ||
template = template:gsub('%%', '%%%%') -- Escape "%" with "%%" | local template = options.template:gsub('%%', '%%%%') -- Escape "%" with "%%" | ||
local invocation, count = self.invocation:gsub( | local invocation, count = self.invocation:gsub( | ||
self.cfg.templateNameMagicWordPattern, | self.cfg.templateNameMagicWordPattern, | ||
template | template | ||
) | ) | ||
if count < 1 then | if options.requireMagicWord ~= false and count < 1 then | ||
error( | error(self:message( | ||
'nowiki-magic-word-error', | |||
self.cfg.templateNameMagicWord | self.cfg.templateNameMagicWord | ||
)) | )) | ||
Line 397: | Line 711: | ||
end | end | ||
function NowikiInvocation:getOutput( | function NowikiInvocation:getOutput(options) | ||
local invocation = self:getInvocation( | local invocation = self:getInvocation(options) | ||
return mw.getCurrentFrame():preprocess(invocation) | return mw.getCurrentFrame():preprocess(invocation) | ||
end | end | ||
Line 408: | Line 722: | ||
local TableInvocation = {} | local TableInvocation = {} | ||
TableInvocation.__index = TableInvocation | TableInvocation.__index = TableInvocation | ||
TableInvocation.message = message -- Add the message method | |||
function TableInvocation.new(invokeArgs, nowikiCode, cfg) | function TableInvocation.new(invokeArgs, nowikiCode, cfg) | ||
Line 417: | Line 732: | ||
end | end | ||
function TableInvocation:getInvocation( | function TableInvocation:getInvocation(options) | ||
if self.code then | if self.code then | ||
local nowikiObj = NowikiInvocation(self.code, self.cfg) | local nowikiObj = NowikiInvocation.new(self.code, self.cfg) | ||
return nowikiObj:getInvocation( | return nowikiObj:getInvocation(options) | ||
else | else | ||
return require('Module:Template invocation').invocation( | return require('Module:Template invocation').invocation( | ||
template, | options.template, | ||
self.invokeArgs | self.invokeArgs | ||
) | ) | ||
Line 429: | Line 744: | ||
end | end | ||
function TableInvocation:getOutput(template) | function TableInvocation:getOutput(options) | ||
if (options.template:sub(1, 7) == '#invoke') then | |||
local moduleCall = mw.text.split(options.template, '|', true) | |||
local args = mw.clone(self.invokeArgs) | |||
table.insert(args, 1, moduleCall[2]) | |||
return mw.getCurrentFrame():callParserFunction(moduleCall[1], args) | |||
end | |||
return mw.getCurrentFrame():expandTemplate{ | return mw.getCurrentFrame():expandTemplate{ | ||
title = template, | title = options.template, | ||
args = self.invokeArgs | args = self.invokeArgs | ||
} | } | ||
Line 437: | Line 758: | ||
------------------------------------------------------------------------------- | ------------------------------------------------------------------------------- | ||
-- | -- Bridge functions | ||
-- | |||
-- These functions translate template arguments into forms that can be accepted | |||
-- by the different classes, and return the results. | |||
------------------------------------------------------------------------------- | ------------------------------------------------------------------------------- | ||
local | local bridge = {} | ||
function | function bridge.table(args, cfg) | ||
cfg = cfg or mw.loadData(DATA_MODULE) | cfg = cfg or mw.loadData(DATA_MODULE) | ||
Line 471: | Line 795: | ||
end | end | ||
function | function bridge.nowiki(args, cfg) | ||
cfg = cfg or mw.loadData(DATA_MODULE) | cfg = cfg or mw.loadData(DATA_MODULE) | ||
local invocationObj = NowikiInvocation.new( | local code = args.code or args[1] | ||
local invocationObj = NowikiInvocation.new(code, cfg) | |||
args.code = nil | args.code = nil | ||
args[1] = nil | |||
-- Assume we want to see the code as we already passed it in. | -- Assume we want to see the code as we already passed it in. | ||
args.showcode = args.showcode or true | args.showcode = args.showcode or true | ||
Line 481: | Line 807: | ||
return tostring(testCaseObj) | return tostring(testCaseObj) | ||
end | end | ||
------------------------------------------------------------------------------- | |||
-- Exports | |||
------------------------------------------------------------------------------- | |||
local p = {} | |||
function p.main(frame, cfg) | function p.main(frame, cfg) | ||
Line 515: | Line 847: | ||
end | end | ||
return | return bridge[func](args, cfg) | ||
end | end | ||