Module:Sandbox/Mefisto1029/main

Module documentation[create] [purge]

You might want to create a documentation page for this module.
Editors can experiment in this module's sandbox (create | mirror) and testcases (create) pages.
Please add categories to the /doc subpage. Subpages of this module.

-------------------------------------------------------------------------------
-- 
--                             Module:Keyword
-- 
-- This module implements Template:Keyword and Template:Keyword infobox
-------------------------------------------------------------------------------

require('strict')
local m_util = require('Module:Util')

-- Should we use the sandbox version of our submodules?
--local use_sandbox = m_util.misc.maybe_sandbox('Keyword')

-- Lazy loading
local f_infocard -- require('Module:Infocard')._main

-- The cfg table contains all localisable strings and configuration, to make it
-- easier to port this module to another wiki.
--local cfg = use_sandbox and mw.loadData('Module:Keyword/config/sandbox') or mw.loadData('Module:Keyword/config')
local cfg = mw.loadData('Module:Sandbox/Mefisto1029/config')

-- The data table contains all informations, to make it
-- easier to port this module to another wiki.
--local m_data = use_sandbox and mw.loadData('Module:Keyword/data/sandbox') or mw.loadData('Module:Keyword/data')
local m_data = mw.loadData('Module:Sandbox/Mefisto1029/data')

local i18n = cfg.i18n

local _keyword  -- forward declaration

-- ----------------------------------------------------------------------------
-- Helper functions
-- ----------------------------------------------------------------------------

local h = {}

-- Lazy loading for Module:Infocard
function h.infocard(args)
    if not f_infocard then
        f_infocard = require('Module:Infocard')._main
    end
    return f_infocard(args)
end

-- Preset basic args
function h.preset_args(tpl_args)
    tpl_args.id = tpl_args.id or tpl_args[1]
    tpl_args.text = tpl_args.text or tpl_args[2]
    tpl_args.options = tpl_args.options or {}

    if not tpl_args.id then
        error(i18n.errors.missing_id)
    end
end

-- Get data from submodule
function h.get_data(tpl_args)
    local data = m_data[tpl_args.id]
    if not data then
        error(i18n.errors.no_data)
    end
    return data
end

-- Get link
function h.resolve_link(tpl_args, data)
    if data.no_link then
        return nil
    end

    if data.links then
        for _, v in ipairs(data.links) do
            if type(v) == "table" and tpl_args.text == v[1] then
                return v[2]
            elseif tpl_args.text == v then
                return tpl_args.text
            end
        end
    end

    if data.default_link then
        return data.default_link
    else
        return data.title
    end
end

-- Finds template calls in a string and automatically
-- replace that template with the returned value
-- args are stored as one string
function h.process_templates(tpl_args, content)
    local caller = tpl_args.options and tpl_args.options.caller or 'keyword'

    -- match {{Template}} or {{Template|Arg}}
    local processed = content:gsub("{{(.-)}}", function(inner)
        -- split by | if present
        local key, text = inner:match("^%s*([^|]+)%s*|?(.-)%s*$")
        key = key or ""
        text = text or ""

        if caller == 'keyword' then
            -- just return text: second part if present, else key
            return text ~= "" and text or key
        elseif caller == 'keyword_infobox' then
            -- call _keyword function dynamically
            return _keyword({
                id = key,
                text = text ~= "" and text or key,
            })
        elseif caller == 'keyword_list' then
            return string.format('[[#%s|%s]]', key, text ~= "" and text or key)
        else
            -- fallback: return raw text
            return text ~= "" and text or key
        end
    end)

    return processed
end

-- ----------------------------------------------------------------------------
-- Main functions
-- ----------------------------------------------------------------------------

_keyword = function(tpl_args)
    h.preset_args(tpl_args)

    local data = h.get_data(tpl_args)

    tpl_args.options.caller = 'keyword'
    local content = h.process_templates(tpl_args, data.content)

    local link = h.resolve_link(tpl_args, data)
    if not link then
        return m_util.html.hoverbox(tpl_args.text or tpl_args.id, content)
    end

    return m_util.html.hoverbox(string.format('[[%s|%s]]', link, tpl_args.text or tpl_args.id), content)
end

local function _keyword_infobox(tpl_args)
    h.preset_args(tpl_args)

    local data = h.get_data(tpl_args)

    tpl_args.options.caller = 'keyword_infobox'
    local content = h.process_templates(tpl_args, data.content)

    local infocard_args = {}

    infocard_args.header = data.title
    infocard_args.subheading = i18n.tooltips.tooltip

    infocard_args[1] = content
    infocard_args['1class'] = 'tc -normal'

    return h.infocard(infocard_args)
end

local function _keyword_list(tpl_args)
    --h.preset_args(tpl_args)
    tpl_args.options = tpl_args.options or {}
    tpl_args.options.caller = 'keyword_list'
    
    -- create the table's header row
    local tbl = mw.html.create('table')
    local header_rows = tbl:tag('tr')
    
    local headers = { 'Id', 'Title', 'Content' }
    
    for _, v in ipairs(headers) do
        header_rows:tag('th')
    		:wikitext(v)
    end
    
    for k, v in pairs(m_data) do
    	tbl:tag('tr')
    		:tag('td')
    			:wikitext(k)
    		:tag('td')
    			:wikitext(v.title)
    		:tag('td')
    			:wikitext(h.process_templates(tpl_args, v.content))
    end

    return tbl
end

-- ----------------------------------------------------------------------------
-- Exported functions
-- ----------------------------------------------------------------------------

local p = {}

--
-- Template:Keyword
-- 
p.keyword = m_util.misc.invoker_factory(_keyword, {
    wrappers = cfg.wrappers.keyword,
})

--
-- Template:Keyword infobox
-- 
p.keyword_infobox = m_util.misc.invoker_factory(_keyword_infobox, {
    wrappers = cfg.wrappers.keyword_infobox,
})

--
-- Template:Keyword list
-- 
p.keyword_list = m_util.misc.invoker_factory(_keyword_list, {
    wrappers = 'Template:Keyword list',
})

return p