Module:Infobox

    From Nonbinary Wiki
    Revision as of 15:20, 3 June 2013 by m>Mr. Stradivarius (hack to parse the parameters in the 'correct' order)

    Documentation for this module may be created at Module:Infobox/doc

    --
    -- This module implements {{Infobox}}
    --
     
    local p = {}
     
    local HtmlBuilder = require('Module:HtmlBuilder')
     
    local args
    local root
     
    function union(t1, t2)
        -- return the union of the values of two tables, as a sequence
        local vals = {}
        for k, v in pairs(t1) do
            vals[v] = true
        end
        for k, v in pairs(t2) do
            vals[v] = true
        end
        local ret = {}
        for k, v in pairs(vals) do
            table.insert(ret, k)
        end
        return ret
    end
    
    local function getArgNums(prefix)
        local nums = {}
        for k, v in pairs(args) do
            local num = ('' .. k):match('^' .. prefix .. '([1-9]%d*)$')
            if num then table.insert(nums, tonumber(num)) end
        end
        table.sort(nums)
        return nums
    end
    
    local function addRow(rowArgs)
        if rowArgs.header then
            root
                .tag('tr')
                    .tag('th')
                        .attr('colspan', 2)
                        .addClass(rowArgs.class)
                        .css('text-align', 'center')
                        .cssText(args.headerstyle)
                        .wikitext(rowArgs.header)
        elseif rowArgs.data then
            local row = root.tag('tr')
            row.addClass(rowArgs.rowclass)
            if rowArgs.label then
                row
                    .tag('th')
                        .attr('scope', 'row')
                        .css('text-align', 'left')
                        .cssText(args.labelstyle)
                        .wikitext(rowArgs.label)
                        .done()
            end
            
            local dataCell = row.tag('td')
            if not rowArgs.label then 
                dataCell
                    .attr('colspan', 2)
                    .css('text-align', 'center') 
            end
            dataCell
                .addClass(rowArgs.class)
                .cssText(rowArgs.datastyle)
                .wikitext(rowArgs.data)
        end
    end
    
    local function renderTitle()
        if not args.title then return end
    
        root
            .tag('caption')
                .addClass(args.titleclass)
                .cssText(args.titlestyle)
                .wikitext(args.title)
    end
    
    local function renderAboveRow()
        if not args.above then return end
        
        root
            .tag('tr')
                .tag('th')
                    .attr('colspan', 2)
                    .addClass(args.aboveclass)
                    .css('text-align', 'center')
                    .css('font-size', '125%')
                    .css('font-weight', 'bold')
                    .cssText(args.abovestyle)
                    .wikitext(args.above)
    end
    
    local function renderBelowRow()
        if not args.below then return end
        
        root
            .tag('tr')
                .tag('td')
                    .attr('colspan', '2')
                    .addClass(args.belowclass)
                    .css('text-align', 'center')
                    .cssText(args.belowstyle)
                    .newline()
                    .wikitext(args.below)
                    .newline()
    end
    
    local function renderSubheaders()
        if args.subheader then
            args.subheader1 = args.subheader
        end
        if args.subheaderrowclass then
            args.subheaderrowclass1 = args.subheaderrowclass
        end
        local subheadernums = getArgNums('subheader')
        for k, num in ipairs(subheadernums) do
            addRow({
                data = args['subheader' .. num],
                datastyle = args.subheaderstyle or args['subheaderstyle' .. num],
                class = args.subheaderclass,
                rowclass = args['subheaderrowclass' .. num]
            })
        end
    end
    
    local function renderImages()
        if args.image then
            args.image1 = args.image
        end
        if args.caption then
            args.caption1 = args.caption
        end
        local imagenums = getArgNums('image')
        for k, num in ipairs(imagenums) do
            local caption = args['caption' .. num]
            local data = HtmlBuilder.create().wikitext(args['image' .. num])
            if caption then
                data
                    .tag('br', {selfClosing = true})
                        .done()
                    .tag('span')
                        .cssText(args.captionstyle)
                        .wikitext(caption)
            end
            addRow({
                data = tostring(data),
                datastyle = args.imagestyle,
                class = args.imageclass,
                rowclass = args['imagerowclass' .. num]
            })
        end
    end
    
    local function renderRows()
        local rownums = union(getArgNums('header'), getArgNums('data'))
        table.sort(rownums)
        for k, num in ipairs(rownums) do
            addRow({
                header = args['header' .. num],
                label = args['label' .. num],
                data = args['data' .. num],
                datastyle = args.datastyle,
                class = args['class' .. num],
                rowclass = args['rowclass' .. num]
            })
        end
    end
    
    local function renderNavBar()
        if not args.name then return end
        
        root
            .tag('tr')
                .tag('td')
                    .attr('colspan', '2')
                    .css('text-align', 'right')
                    .wikitext(mw.getCurrentFrame():expandTemplate({ 
                        title = 'navbar', 
                        args = { args.name, mini = 1 }
                    }))
    end
    
    local function renderItalicTitle()
        local italicTitle = args['italic title'] and mw.ustring.lower(args['italic title'])
        if italicTitle == '' or italicTitle == 'force' or italicTitle == 'yes' then
            root.wikitext(mw.getCurrentFrame():expandTemplate({title = 'italic title'}))
        end
    end
    
    local function renderTrackingCategories()
        if args.decat ~= 'yes' then
            if #(getArgNums('data')) == 0 and mw.title.getCurrentTitle().namespace == 0 then
                root.wikitext('[[Category:Articles which use infobox templates with no data rows]]')
            end
            if args.child == 'yes' and args.title then
                root.wikitext('[[Category:Articles which use embedded infobox templates with the title parameter]]')
            end
        end
    end
    
    local function _infobox()
        if args.child ~= 'yes' then
            root = HtmlBuilder.create('table')
            
            root
                .addClass('infobox')
                .addClass(args.bodyclass)
                .attr('cellspacing', 3)
                .css('border-spacing', '3px')
                .cssText(args.bodystyle)
                
                if args.subbox == 'yes' then
                    root
                        .css('padding', '0')
                        .css('border', 'none')
                        .css('margin', '-3px')
                        .css('width', 'auto')
                        .css('min-width', '100%')
                        .css('font-size', '100%')
                        .css('clear', 'none')
                        .css('float', 'none')
                        .css('background-color', 'transparent')
                else
                    root
                        .css('width', '22em')
                end
        
            renderTitle()
            renderAboveRow()
        else
            root = HtmlBuilder.create()
        end
    
        renderSubheaders()
        renderImages() 
        renderRows() 
        renderBelowRow()  
        renderNavBar()
        renderItalicTitle()
        renderTrackingCategories()
        
        return tostring(root)
    end
    
    -- This function parses the parameters with the given prefixes, in order, in batches of 20.
    local function touchParameters(prefixTable, origArgs)
        if type(prefixTable) ~= 'table' or type(origArgs) ~= 'table' then
            error("Invalid input to the touchParameters function detected. Both parameters must be tables.", 2)
        end
        local temp
        local argumentCounter = 1
        local moreArgumentsExist = true
        for j,v in ipairs(prefixTable) do
            if not type(v) == "string" then
                error("Non-string value detected in the prefix table in the touchParameters function.", 2)
            end
            temp = origArgs[v]
        end
        while moreArgumentsExist == true do
            moreArgumentsExist = false
            for i = argumentCounter, argumentCounter + 19 do
                for j,v in ipairs(prefixTable) do
                    temp = origArgs[v .. tostring(i)]
                    if temp then
                        moreArgumentsExist = true
                    end
                end
            end
            argumentCounter = argumentCounter + 20
        end
    end
     
    function p.infobox(frame)
        local origArgs
        -- If called via #invoke, use the args passed into the invoking template.
        -- Otherwise, for testing purposes, assume args are being passed directly in.
        if frame == mw.getCurrentFrame() then
            origArgs = frame:getParent().args
        else
            origArgs = frame
        end
        
        -- Parse the data parameters in the same order that the old {{infobox}} did, so that
        -- references etc. will display in the expected places.
        local temp
        temp = origArgs.title
        temp = origArgs.above
        touchParameters({'subheader'}, origArgs)
        touchParameters({'image', 'caption'}, origArgs)
        touchParameters({'header', 'label', 'data'}, origArgs)
        temp = origArgs.below
     
        -- ParserFunctions considers whitespace to be false, so to preserve the previous 
        -- behavior of {{infobox}}, change any whitespace arguments to nil, so Lua will consider
        -- them false too. (Except the 'italic title' param, which specifies different behavior
        -- depending on whether it's absent or empty)
        args = {}
        for k, v in pairs(origArgs) do
            if mw.ustring.match(v, '%S') or k == 'italic title' then
                args[k] = v
            end
        end
     
        return _infobox()
    end
     
    return p