July 25, 2020

👭 Knight Challenge #11 👬

Want to try your hand at these challenges? There's a couple of things you can do!
From writing, to research, to images, find your preferred way to contribute with our eleventh theme: Couples!

Latest Announcements

Module:UtilsMarkup/Format

From Zelda Wiki, the Zelda encyclopedia
Jump to: navigation, search

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