Module:Template test case: Difference between revisions

    (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/Module:Template_test_case"