This module exports the following functions.
bold
bold(text)
Parameters
text- The text to bold.
Returns
- The bolded text.
Examples
| # | Input | Output | Result | Status |
|---|---|---|---|---|
| 1 | bold("Fooloo Limpah")
| "<b>Fooloo Limpah</b>" | Fooloo Limpah |  |
caption
caption(text)
Returns
- Text in caption font, which is slightly smaller.
Examples
| # | Input | Output | Result | Status |
|---|---|---|---|---|
| 2 | caption("Fooloo Limpah")
| '<span class="caption">Fooloo Limpah</span>' | Fooloo Limpah | |
class
class(class, text)
Returns
- Text wrapped in a span tag with the given class string.
Examples
| # | Input | Output | Result | Status |
|---|---|---|---|---|
| 3 | class("term error", "Fooloo Limpah")
| '<span class="term error">Fooloo Limpah</span>' | Fooloo Limpah | |
code
code(text)
Parameters
text- The text to render monospaced.
Returns
- The formatted text.
Examples
| # | Input | Output | Result | Status |
|---|---|---|---|---|
| 4 | code("code stuff")
| "<code>code stuff</code>" | code stuff | |
heading
heading(level, text)
Parameters
Returns
stringof text for the heading
Examples
| # | Input | Output | Status |
|---|---|---|---|
| 5 | heading(2, "Section")
| "\n==Section==\n" | |
| 6 | heading(3, "Sub-section")
| "\n===Sub-section===\n" | |
italic
italic(text)
Parameters
text- The text to italicize.
Returns
- The italicized text.
Examples
| # | Input | Output | Result | Status |
|---|---|---|---|---|
| 7 | italic("Fooloo Limpah")
| "<i>Fooloo Limpah</i>" | Fooloo Limpah | |
inline
inline(text, [options])
Parameters
Returns
- The formatted text.
Examples
| # | Input | Output | Result | Status |
|---|---|---|---|---|
| 8 | inline(
"Fooloo Limpah",
{
bold = true,
italic = true,
class = "error",
tooltip = "Don't steal them!",
}
)
| "<span class=\"error\"><span title=\"Don't steal them!\" class=\"explain\"><b><i>Fooloo Limpah</i></b></span></span>" | Fooloo Limpah | |
| 9 | inline(
"{{Foo}}",
{
bold = true,
nowiki = true,
code = true,
}
)
| "<b><code>{{Foo}}</code></b>" | {{Foo}} | |
lua
lua(text, [options])
Parameters
text- A string of text to format as Lua code.
[options][wrapLines=true]- If set to
false, prevents lines from wrapping by setting white-space topre.
Returns
- A block of pre-formatted, syntax-highlighted Lua code
Examples
| # | Input | Result |
|---|---|---|
| 10 | lua("function(foo) \n\t\treturn foo\n\tend")
| function(foo)
return foo
end
|
pre
pre(text, [options])
Parameters
text- Text to render as preformatted.
[options][wrapLines=true]- If set to
false, prevents lines from wrapping by setting white-space topre.
Returns
- A block of pre-formatted text.
Examples
| # | Input | Result |
|---|---|---|
| 11 | pre("{{List\n\t |foo\n\t |bar\n\t |baz\n\t}}")
| {{List
|foo
|bar
|baz
}}
|
tooltip
tooltip(baseText, tooltipText, [type])
Parameters
baseText- The text to receive a tooltip.
tooltipText- The text to display on hover.
[type]- If
"highlight", colors the base text to make the presence of tooltip text more evident.
Returns
- Text with a tooltip.
Examples
| # | Input | Output | Result | Status |
|---|---|---|---|---|
| 12 | tooltip("hover over me", "hello world!")
| '<span title="hello world!" class="explain">hover over me</span>' | hover over me | |
| 13 | tooltip("foo", "bar", "highlight")
| '<span title="bar" class="explain" style="color:yellow">foo</span>' | foo | |
local p = {}
local utilsTable = require("Module:UtilsTable")
local function tag(tag, attributes, styles)
return function(content)
return tostring(mw.html.create(tag)
:attr(attributes or {})
:css(styles or {})
:wikitext(content))
end
end
local function extensionTag(tag, defaultArgs)
return function(content, overrideArgs)
local args = utilsTable.merge({}, defaultArgs or {}, overrideArgs or {})
return mw.getCurrentFrame():extensionTag(tag, content, args) .. "\n" -- tags like <pre> don't work properly without the newline
end
end
function p.bold(text)
return tag("b")(text)
end
function p.caption(text)
return p.class("caption", text)
end
function p.class(class, text)
return tag("span", { class = class })(text)
end
function p.code(text)
return "<code>" .. text .. "</code>"
end
function p.heading(level, content)
local headingTag = string.rep("=", level)
return "\n" .. headingTag .. content .. headingTag .. "\n"
end
function p.italic(text)
return tag("i")(text)
end
function p.inline(text, options)
options = options or {}
if options.nowiki then
text = mw.text.nowiki(text)
end
if options.caption then
text = p.caption(text)
end
if options.code then
text = p.code(text)
end
if options.italic then
text = p.italic(text)
end
if options.bold then
text = p.bold(text)
end
if options.tooltip then
text = p.tooltip(text, options.tooltip)
end
if options.class then
text = p.class(options.class, text)
end
return text
end
function p.lua(content, options)
local wrapLines = options and options.wrapLines
local attrs = {}
if type(content) ~= "string" then
content = utilsTable.print(content)
end
if wrapLines == false then
attrs.class = "nowrapLines"
end
return p.syntaxHighlight("lua")(content or "nil", attrs)
end
function p.pre(text, options)
options = options or {}
local attrs = {}
local wrapLines = options and options.wrapLines
if wrapLines == false then
attrs.style = "white-space: pre;"
end
return extensionTag("pre", attrs)(text)
end
function p.syntaxHighlight(lang, args)
local args = utilsTable.merge({}, args or {}, {
lang = lang
})
return extensionTag("syntaxHighlight", args)
end
function p.tooltip(baseText, tooltipText, type)
local attrs = {
class = "explain",
title = tooltipText,
}
local styles = {}
if type == "highlight" then
styles.color = "yellow"
end
return tag("span", attrs, styles)(baseText)
end
function p.Schemas()
return {
bold = {
text = {
type = "string",
required = true,
desc = "The text to bold."
},
},
code = {
text = {
type = "string",
required = true,
desc = "The text to render monospaced."
},
},
italic = {
text = {
type = "string",
required = true,
desc = "The text to italicize."
},
},
inline = {
text = { type = "string", required = true, },
options = {
type = "record",
desc = "Formatting options are applied in the reverse order in which they are listed below. In other words, <code>nowiki</code> is always the outermost tag and <code>i</code> is always the innermost.",
properties = {
{
name = "nowiki",
type = "boolean",
},
{
name = "caption",
type = "caption",
},
{
name = "code",
type = "boolean",
},
{
name = "class",
type = "string",
},
{
name = "tooltip",
type = "string",
},
{
name = "bold",
type = "boolean",
},
{
name = "italic",
type = "boolean",
},
},
},
},
heading = {
level = {
type = "number",
required = true,
desc = "The heading level." ,
},
text = {
type = "string",
required = true,
desc = "The heading text.",
},
},
tooltip = {
baseText = {
type = "string",
required = true,
desc = "The text to receive a tooltip.",
},
tooltipText = {
type = "string",
required = true,
desc = "The text to display on hover.",
},
type = {
type = "string",
enum = {"highlight"},
desc = 'If <code>"highlight"</code>, colors the base text to make the presence of tooltip text more evident.',
},
},
pre = {
text = {
type = "string",
required = true,
desc = "Text to render as preformatted.",
},
options = {
type = "record",
properties = {
{
name = "wrapLines",
type = "boolean",
default = true,
desc = "If set to <code>false</code>, prevents lines from wrapping by setting [https://developer.mozilla.org/en-US/docs/Web/CSS/white-space white-space] to <code>pre</code>."
}
}
}
},
lua = {
text = {
type = "string",
required = true,
desc = "A string of text to format as Lua code."
},
options = {
type = "record",
properties = {
{
name = "wrapLines",
type = "boolean",
default = true,
desc = "If set to <code>false</code>, prevents lines from wrapping by setting [https://developer.mozilla.org/en-US/docs/Web/CSS/white-space white-space] to <code>pre</code>."
}
}
}
}
}
end
function p.Documentation()
return {
bold = {
params = {"text"},
returns = "The bolded text.",
cases = {
{
args = { "Fooloo Limpah" },
expect = "<b>Fooloo Limpah</b>",
},
},
},
italic = {
params = {"text"},
returns = "The italicized text.",
cases = {
{
args = { "Fooloo Limpah" },
expect = "<i>Fooloo Limpah</i>",
},
},
},
caption = {
params = {"text"},
returns = "Text in caption font, which is slightly smaller.",
cases = {
{
args = { "Fooloo Limpah" },
expect = '<span class="caption">Fooloo Limpah</span>',
}
}
},
class = {
params = {"class", "text"},
returns = "Text wrapped in a span tag with the given class string.",
cases = {
{
args = {"term error", "Fooloo Limpah"},
expect = [[<span class="term error">Fooloo Limpah</span>]]
},
},
},
heading = {
params = {"level", "text"},
returns = "<code>string</code> of text for the heading",
cases = {
outputOnly = true,
{
args = {2, "Section"},
expect = "\n==Section==\n",
},
{
args = {3, "Sub-section"},
expect = "\n===Sub-section===\n"
}
}
},
tooltip = {
params = {"baseText", "tooltipText", "type"},
returns = "Text with a tooltip.",
cases = {
{
args = {"hover over me", "hello world!"},
expect = '<span title="hello world!" class="explain">hover over me</span>'
},
{
args = {"foo", "bar", "highlight"},
expect = '<span title="bar" class="explain" style="color:yellow">foo</span>'
},
},
},
code = {
params = {"text"},
returns = "The formatted text.",
cases = {
{
args = {"code stuff"},
expect = "<code>code stuff</code>",
},
},
},
inline = {
params = {"text", "options"},
returns = "The formatted text.",
cases = {
{
args = {"Fooloo Limpah", {
class = "error",
tooltip = "Don't steal them!",
bold = true,
italic = true,
},
},
expect = [[<span class="error"><span title="Don't steal them!" class="explain"><b><i>Fooloo Limpah</i></b></span></span>]],
},
{
args = {"{{Foo}}", {
code = true,
nowiki = true,
bold = true,
}
},
expect = "<b><code>{{Foo}}</code></b>",
},
},
},
pre = {
params = {"text", "options"},
returns = "A block of pre-formatted text.",
cases = {
resultOnly = true,
{
args = {
[[{{List
|foo
|bar
|baz
}}]]
}
}
}
},
lua = {
params = {"text", "options"},
returns = "A block of pre-formatted, syntax-highlighted Lua code",
cases = {
resultOnly = true,
{
args = {
[[function(foo)
return foo
end]]
},
}
}
}
}
end
return p