Module:Keyword

Module documentation[view] [edit] [history] [purge]

This module depends on the following other modules:

• Module:Util
• Module:Keyword/config
• Module:Keyword/keywords
• Module:Keyword/keywords lookup

The module implements {{keyword}} and {{keyword infobox}}.

Overview

The above documentation is transcluded from Module:Keyword/doc. (edit | history)
Editors can experiment in this module's sandbox (create | mirror) and testcases (create) pages.
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 i18n = cfg.i18n

-- The data table contains all informations, to make it
-- easier to port this module to another wiki.
local m_data = mw.loadData('Module:Keyword/keywords')
local m_data_lookup = mw.loadData('Module:Keyword/keywords_lookup')

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]
    if tpl_args.text then
        tpl_args.text, tpl_args.punct = tpl_args.text:match("^(.-)([.,]?)$")
    else
        tpl_args.id, tpl_args.punct = tpl_args.id:match("^(.-)([.,]?)$")
    end
    tpl_args.punct = tpl_args.punct or ''
    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[m_data_lookup[tpl_args.id]]

    -- Get error only for infobox, else just get input text
    if not data and tpl_args.options.caller == 'keyword_infobox' then
        error(i18n.errors.no_data)
    end
    return data
end

-- Get link
function h.resolve_link(tpl_args, data)
    if data.no_link or not data.title 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 then
        return data.default
    else
        return data.title
    end
end

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

    -- match [keyword_id] or [keyword_id|text], optionally followed by . or ,
    local processed = description:gsub('%[(.-)%]([.,]?)', function(inner, punct)
        -- split by | if present
        local key, text = inner:match('^%s*([^|]+)%s*|?(.-)%s*$')

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

    return processed
end

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

_keyword = function(tpl_args)
    h.preset_args(tpl_args)
    tpl_args.options.caller = 'keyword'

    local data = h.get_data(tpl_args)

    -- return input text if no keyword found
    if not data then
        return tpl_args.text or tpl_args.id
    end

    local description = h.process_templates(tpl_args, data.desc)

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

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

local function _keyword_infobox(tpl_args)
    h.preset_args(tpl_args)
    tpl_args.options.caller = 'keyword_infobox'

    local data = h.get_data(tpl_args)

    local description = h.process_templates(tpl_args, data.desc)

    local infocard_args = {}

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

    infocard_args[1] = description
    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', 'Description'}
    local header_row = tbl:tag('tr')
    for _, h in ipairs(headers) do
        header_row:tag('th')
            :wikitext(h)
    end

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

return p