Jump to content

Module:Template test case: Difference between revisions

Module:Template test case (edit)

Revision as of 14:09, 24 November 2014

304 bytes added ,  9 years ago
make a template class and add code to set template objects in the test case class
(move the logic for finding the options into the exports - it seemed a bit unintuitive to have invocation objects handling argument code as well)
(make a template class and add code to set template objects in the test case class)
Line 9: Line 9:


-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
-- Helper functions
-- Template class
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------


--[[
local Template = {}
local function validateTemplateOptions()
Template.__index = Template
-- Add the template names for the first two templates if they weren't
 
-- specified.
function Template.new(invocationObj, options, titleCallback)
do
local obj = setmetatable({}, Template)
local title = mw.title.getCurrentTitle().basePageTitle
 
local template
-- Set input
if title.namespace == 10 then
for k, v in pairs(options or {}) do
template = title.text
obj[k] = v
elseif title.namespace == 0 then
end
template = ':' .. title.prefixedText
obj.invocation = invocationObj
 
-- Validate template
if not obj.template then
if titleCallback then
obj.title = titleCallback()
else
else
template = title.prefixedText
error('no template or title callback specified', 2)
end
end
local templatePage = title.prefixedText
templateOptions[1] = templateOptions[1] or {}
templateOptions[1].templatePage = templateOptions[1].template or templatePage
templateOptions[1].template = templateOptions[1].template or template
templateOptions[2] = templateOptions[2] or {}
templateOptions[2].templatePage = templateOptions[2].template or templatePage .. '/sandbox'
templateOptions[2].template = templateOptions[2].template or template .. '/sandbox'
end
end


-- Validate options for three or more templates.
return obj
if #templateOptions >= 3 then
end
for i = 3, #templateOptions do
 
local template = templateOptions[i].template
function Template:getFullPage()
if not template then
if self.template then
error('arguments for a third or subsequent ' ..
local strippedTemplate, hasColon = self.template:gsub('^:', '', 1)
'template were found, but no template name ' ..
local ns = strippedTemplate:match('^(.-):')
'was specified', 3)
ns = ns and mw.site.namespaces[ns]
end
if ns then
return strippedTemplate
elseif hasColon then
return strippedTemplate -- Main namespace
else
return mw.site.namespaces[10].name .. ':' .. strippedTemplate
end
end
else
return self.title.prefixedText
end
end
end
end
--]]


local function parseTemplateOptions(origOptions)
function Template:getName()
-- Given a table of raw options, returns a table of general options
if self.template then
-- and template options.
return self.template
local templateOptions = mTableTools.numData(origOptions, true)
else
local options = templateOptions.other
return require('Module:Template invocation').name(self.title)
templateOptions.other = nil
end
return options, templateOptions
end
 
function Template:makeLink(display)
if display then
return string.format('[[:%s|%s]]', self:getFullPage(), display)
else
return string.format('[[:%s]]', self:getFullPage())
end
end
 
function Template:makeBraceLink(display)
display = display or self:getName()
local link = self:makeLink(display)
return mw.text.nowiki('{{') .. link .. mw.text.nowiki('}}')
end
 
function Template:getInvocation(format)
local invocation = self.invocation:getInvocation(self:getName())
invocation = mw.text.nowiki(invocation)
if format == 'code' then
invocation = '<code>' .. invocation .. '</code>'
elseif format == 'pre' then
invocation = '<pre style="white-space: pre-wrap;">' .. invocation .. '</pre>'
invocation = mw.getCurrentFrame():preprocess(invocation)
end
return invocation
end
 
function Template:getOutput()
return self.invocation:getOutput(self:getName())
end
end


Line 65: Line 98:
TestCase.__index = TestCase
TestCase.__index = TestCase


function TestCase.new(invocationObj)
function TestCase.new(invocationObj, options)
checkType('TestCase.new', 'invocationObj', invocationObj, 'table')
local obj = setmetatable({}, TestCase)
local obj = setmetatable({}, TestCase)
-- Validate options
do
local highestNum = 0
for k in pairs(options) do
if type(k) == 'string' then
local num = k:match('([1-9][0-9]*)$')
num = tonumber(num)
if num > highestNum then
highestNum = num
end
end
end
for i = 3, highestNum do
if not options['template' .. i] then
error(string.format(
"one or more options ending in '%d' were " ..
"detected, but no 'template%d' option was found",
i, i
), 2)
end
end
end
-- Separate general options from options for specific templates
local templateOptions = mTableTools.numData(options, true)
options = templateOptions.other
templateOptions.other = nil
-- Make the template objects
obj.templates = {}
local function templateTitleCallback()
return mw.title.getCurrentTitle().basePageTitle
end
obj.templates[1] = Template.new(
invocationObj,
templateOptions[1],
templateTitleCallback
)
obj.templates[2] = Template.new(
invocationObj,
options,
function ()
return templateTitleCallback():subPageTitle('sandbox')
end
)
for i = 3, #templateOptions do
table.insert(obj.templates, Template.new(
invocationObj,
templateOptions[i]
))
end
return obj
return obj
end
end
--------------------------------------------------------------------------------
-- Test case display functions
--
-- Test case display functions produce the wikitext to display the template
-- output for one test case. For example, one function might produce templates
-- aligned horizontally, and another function might produce templates aligned
-- one below the other.
--
-- They are named functions that accept the following parameters:
-- * templates - an array of subtables containing data about each template to be
--    displayed. These subtables can contain the following values:
--    * result - the expanded wikitext from the template.
--    * invocation - the original unexpanded wikitext that the output was
--        generated from. This may be nil if the invocation is not available.
--    * name - the name of the template.
--    * link - a normal wikilink to the template page (displays as
--        "Template:Foo").
--    * braceLink - a wikilink to the template page formatted like the {{tl}}
--        template, i.e. it displays as "{{Foo}}".
--    * heading - a heading to display above the template output.
--------------------------------------------------------------------------------


-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
Retrieved from "https://nonbinary.wiki/wiki/Special:MobileDiff/31296"
Cookies help us deliver our services. By using our services, you agree to our use of cookies.
More information