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/main/s1')

local i18n = cfg.i18n

-- 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/keywords/sandbox') or mw.loadData('Module:Keyword/keywords')
local m_data = mw.loadData('Module:Sandbox/Mefisto1029/main/s2')

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 ''
        local display = text ~= '' and text or key

        if caller == 'keyword' then
            -- just return text: second part if present, else key
            return display
        elseif caller == 'keyword_infobox' then
            -- call _keyword function dynamically
            return _keyword({
                id = key,
                text = display,
            })
        elseif caller == 'keyword_list' then
            return string.format('[[#%s|%s]]', key, display)
        else
            -- fallback: return raw text
            return display
        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)
    tpl_args.options = tpl_args.options or {}
    tpl_args.options.caller = 'keyword_list'

    -- Create a sortable wikitable with headers and rows
    local tbl = mw.html.create('table')
        :addClass('wikitable sortable')

    -- Headers
    local headers = {'Id', 'Title', 'Content'}
    local header_row = tbl:tag('tr')
    for _, h in ipairs(headers) do
        header_row:tag('th')
            :wikitext(h)
    end

    -- Rows
    for id, keyword in pairs(m_data) do
        local row = tbl:tag('tr')
            :attr('id', id)
        row:tag('td')
            :wikitext(id)
        row:tag('td')
            :wikitext(keyword.title or '')
        row:tag('td')
            :wikitext(h.process_templates(tpl_args, keyword.content or ''))
    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)

-- ----------------------------------------------------------------------------
-- Debug
-- ----------------------------------------------------------------------------

p.debug = {}

function p.debug.test_keyword()
    -- Args
    local tpl_args = {}
    tpl_args[1] = 'Fire'

    -- Print in console
    mw.log(_keyword(tpl_args))

    return
end

function p.debug.test_keyword_infobox()
    -- Args
    local tpl_args = {}
    tpl_args[1] = 'Fire'

    -- Print in console
    mw.log(_keyword_infobox(tpl_args))

    return
end

function p.debug.test_keyword_list()
    -- Args
    local tpl_args = {}

    -- Print in console
    mw.log(_keyword_list(tpl_args))

    return
end

function p.debug.test()
    -- Print in console
    mw.log(p.debug.test_keyword())
    mw.log(p.debug.test_keyword_infobox())

    return
end

return p