Zelda Wiki

OoT Navi.png

Hey! Listen!

This wiki contains spoilers! Read at your own risk!

READ MORE

Zelda Wiki
Advertisement
Zelda Wiki
10,304
pages
This module exports the following functions.

bold

bold(text)

Parameters
  • text
    The text to bold.
Returns
  • The bolded text.
Examples
InputOutputResultStatus
bold("Fooloo Limpah")
"<b>Fooloo Limpah</b>"
Fooloo Limpah
Green check.svg

caption

caption(text)

Returns
  • Text in caption font, which is slightly smaller.
Examples
InputOutputResultStatus
caption("Fooloo Limpah")
'<span class="caption">Fooloo Limpah</span>'
Fooloo Limpah
Green check.svg

class

class(class, text)

Returns
  • Text wrapped in a span tag with the given class string.
Examples
InputOutputResultStatus
class("term error", "Fooloo Limpah")
'<span class="term error">Fooloo Limpah</span>'
Fooloo Limpah
Green check.svg

code

code(text)

Parameters
  • text
    The text to render monospaced.
Returns
  • The formatted text.
Examples
InputOutputResultStatus
code("code stuff")
"<code>code stuff</code>"
code stuff
Green check.svg

heading

heading(level, text)

Parameters
Returns
  • string of text for the heading
Examples
InputOutputStatus
heading(2, "Section")
"\n==Section==\n"
Green check.svg
heading(3, "Sub-section")
"\n===Sub-section===\n"
Green check.svg

italic

italic(text)

Parameters
  • text
    The text to italicize.
Returns
  • The italicized text.
Examples
InputOutputResultStatus
italic("Fooloo Limpah")
"<i>Fooloo Limpah</i>"
Fooloo Limpah
Green check.svg

inline

inline(text, [options])

Parameters
Returns
  • The formatted text.
Examples
InputOutputResultStatus
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
Green check.svg
inline(
  "{{Foo}}",
  {
    bold = true,
    nowiki = true,
    code = true,
  }
)
"<b><code>&#123;&#123;Foo&#125;&#125;</code></b>"
{{Foo}}
Green check.svg

lua

lua(text, [options])

Parameters
Returns
  • A block of pre-formatted, syntax-highlighted Lua code
Examples
InputResult
lua("function(foo) \n\treturn foo\nend")
function(foo) 
	return foo
end

pre

pre(text, [options])

Parameters
Returns
  • A block of pre-formatted text.
Examples
InputResult
pre("{{List\n |foo\n |bar\n |baz\n}}")
{{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
InputOutputResultStatus
tooltip("hover over me", "hello world!")
'<span title="hello world!" class="explain">hover over me</span>'
hover over me
Green check.svg
tooltip("foo", "bar", "highlight")
'<span title="bar" class="explain" style="color:yellow">foo</span>'
foo
Green check.svg

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

p.Schemas = {
	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>."
				}
			}
		}
	}
}

p.Documentation = {
	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>&#123;&#123;Foo&#125;&#125;</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]]
				},
			}
		}
	}
}

return p
Advertisement