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/List

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

list

list(items)

Parameters
  • items
    An array of strings (list items).
Returns
  • An unordered list with the plainlist class.
Examples
InputOutputResultStatus
list({})
""
Green check.svg
list({"single item"})
'<ul class="plainlist"><li>single item</li></ul>'
  • single item
Green check.svg
list({"multiple", "items", ""})
'<ul class="plainlist"><li>multiple</li><li>items</li><li></li></ul>'
  • multiple
  • items
Green check.svg

bulletList

bulletList(items)

Parameters
  • items
    An array of strings (list items).
Returns
  • A string representation of an unordered list using HTML syntax.
Examples
InputOutputResultStatus
bulletList({})
""
Green check.svg
bulletList({"single item"})
"<ul><li>single item</li></ul>"
  • single item
Green check.svg
bulletList({"multiple", "items", ""})
"<ul><li>multiple</li><li>items</li><li></li></ul>"
  • multiple
  • items
Green check.svg
bulletList({
  "list",
  {
    "with",
    {"nested", "items"},
    "inside",
  },
})
"<ul><li>list</li><ul><li>with</li><ul><li>nested</li><li>items</li></ul><li>inside</li></ul></ul>"
  • list
    • with
      • nested
      • items
    • inside
Green check.svg

numberList

numberList(items)

Parameters
  • items
    An array of strings (list items).
Returns
  • A string representation of an ordered list using HTML syntax.
Examples
InputOutputResultStatus
numberList({})
""
Green check.svg
numberList({"single item"})
"<ol><li>single item</li></ol>"
  1. single item
Green check.svg
numberList({"multiple", "items", ""})
"<ol><li>multiple</li><li>items</li><li></li></ol>"
  1. multiple
  2. items
Green check.svg
numberList({
  "list",
  {
    "with",
    {"nested", "items"},
    "inside",
  },
})
"<ol><li>list</li><ol><li>with</li><ol><li>nested</li><li>items</li></ol><li>inside</li></ol></ol>"
  1. list
    1. with
      1. nested
      2. items
    2. inside
Green check.svg
numberList({"Eight", "Nine", "Ten", start = 8})
'<ol start="8"><li>Eight</li><li>Nine</li><li>Ten</li></ol>'
  1. Eight
  2. Nine
  3. Ten
Green check.svg

definitionList

definitionList(pairs)

Parameters
  • pairs
    Array of table of pairs where the first pair item is a term and the value is a definition.
Returns
  • A string representation of a definition list using HTML syntax.
Examples
InputResultStatus
definitionList({})
Green check.svg
definitionList({
  {"key1", "value1"},
})
key1
value1
Green check.svg
definitionList({
  {"key1", "value1"},
  {"key2", "value2"},
})
key1
value1
key2
value2
Green check.svg
definitionList({
  {"", "value1"},
  {[2] = "value2" },
  {"key3", ""},
  {"key4"},
})
value1
value2
key3
key4
Green check.svg
definitionList({
  {
    "key 1",
    {
      {
        "key 1.1",
        {
          {"key 1.1.1", "value 1.1.1"},
        },
      },
      {"key 1.2", "value 1.2"},
    },
  },
  {"key2", "value2"},
})
key 1
key 1.1
key 1.1.1
value 1.1.1
key 1.2
value 1.2
key2
value2
Green check.svg
definitionList({
  {
    "key 1",
    "value 1.1",
    {
      {"key 1.1", "value 1.2"},
      {"key 1.2", "value 1.2"},
    },
  },
})
key 1
value 1.1
key 1.1
value 1.2
key 1.2
value 1.2
Green check.svg

local p = {}

local utilsTable = require("Module:UtilsTable")

local function tag(tag, content, attributes)
	if not tag then
		return content
	end
	local html = mw.html.create(tag)
		:attr(attributes or {})
		:wikitext(mw.getCurrentFrame():preprocess(content))
	return tostring(html)
end

local function tagList(listTag, itemTag, listAttributes, level)
	level = level or 1
	return function(items)
		listAttributes = utilsTable.merge(listAttributes or {}, { 
			start = items.start 
		})
		if #items == 0 then
			return ""
		end
		local list = ""
		for _, item in ipairs(items) do
			if utilsTable.isArray(item) then
				list = list .. tagList(listTag, itemTag, listAttributes, level + 1)(item)
			else
				list = list .. tag(itemTag, item)
			end
		end
		return tag(listTag, list, listAttributes)
	end
end

function p.list(items)
	return tagList("ul", "li", {
		class = "plainlist"
	})(items)
end

function p.bulletList(items)
	return tagList("ul", "li")(items)
end

function p.numberList(items)
	return tagList("ol", "li")(items)
end

function p.definitionList(items, attributes, level)
	level = level or 1
	local listItems = {}
	for _, definitions in ipairs(items) do
		local dt = definitions[1]
		if dt then
			table.insert(listItems, tag("dt", dt or ""))
		end
		for i = 2, table.maxn(definitions) do
			local dd = definitions[i]
			if type(dd) == "table" then
				dd = p.definitionList(dd, attributes, level + 1)
			end
			table.insert(listItems, tag("dd", dd or ""))
		end
	end
	local list = tagList("dl", nil, attributes, level)(listItems)
	return list
end

local listItems = {
	type = "array",
	required = true,
	items = { type = "string" },
	desc = "An array of strings (list items).",
}

p.Schemas = {
	list = {
		items = listItems,
	},
	bulletList = {
		items = listItems,
	},
	numberList = {
		items = listItems,
	},
	definitionList = {
		pairs = {
			type = "array",
			required = true,
			items = { type = "any" }, -- TODO
			desc = "Array of <code>table</code> of pairs where the first pair item is a term and the value is a definition.",
		}
	}
}

p.Documentation = {
	list = {
		params = {"items"},
		returns = "An unordered list with the <code>plainlist</code> class.",
		cases = {
			{
				args = { {} },
				expect = "",
			},
			{
				args = {
					{ "single item" }
				},
				expect = '<ul class="plainlist"><li>single item</li></ul>',
			},
			{
				args = {
					{ "multiple", "items", "" },
				},
				expect = '<ul class="plainlist"><li>multiple</li><li>items</li><li></li></ul>'
			},
		},
	},
	bulletList = {
		params = {"items"},
		returns = "A string representation of an unordered list using HTML syntax.",
		cases = {
			{
				args = { {} },
				expect = "",
			},
			{
				args = {
					{ "single item" }
				},
				expect = "<ul><li>single item</li></ul>",
			},
			{
				args = {
					{ "multiple", "items", "" },
				},
				expect = "<ul><li>multiple</li><li>items</li><li></li></ul>",
			},
			{
				args = {
					{
						"list",
						{
							"with",
							{"nested", "items"},
							"inside"
						},
					},
				},
				expect = "<ul><li>list</li><ul><li>with</li><ul><li>nested</li><li>items</li></ul><li>inside</li></ul></ul>"
			},
		}
	},
	numberList = {
		params = {"items"},
		returns = "A string representation of an ordered list using HTML syntax.",
		cases = {
			{
				args = { {} },
				expect = "",
			},
			{
				args = {
					{ "single item" }
				},
				expect = "<ol><li>single item</li></ol>",
			},
			{
				args = {
					{ "multiple", "items", "" },
				},
				expect = "<ol><li>multiple</li><li>items</li><li></li></ol>"
			},
			{
				args = {
					{
						"list",
						{
							"with",
							{"nested", "items"},
							"inside"
						},
					},
				},
				expect = "<ol><li>list</li><ol><li>with</li><ol><li>nested</li><li>items</li></ol><li>inside</li></ol></ol>"
			},
			{
				args = {
					{
						start = 8,
						"Eight", "Nine", "Ten"
					},
				},
				expect = '<ol start="8"><li>Eight</li><li>Nine</li><li>Ten</li></ol>',
			},
		}
	},
	definitionList = {
		params = {"pairs"},
		returns = "A string representation of a definition list using HTML syntax.",
		cases = {
			resultOnly = true,
			{
				args = { {} },
				expect = "",
			},
			{
				args = {
					{
						{ "key1", "value1" },
					}
				},
				expect = "<dl><dt>key1</dt><dd>value1</dd></dl>",
			},
			{
				args = {
					{
						{ "key1", "value1" },
						{ "key2", "value2" },
					}
				},
				expect = "<dl><dt>key1</dt><dd>value1</dd><dt>key2</dt><dd>value2</dd></dl>",
			},
			{
				args = {
					{
						{ "", "value1" },
						{ nil, "value2" },
						{ "key3", "" },
						{ "key4", nil },
					},
				},
				expect = "<dl><dt></dt><dd>value1</dd><dd>value2</dd><dt>key3</dt><dd></dd><dt>key4</dt></dl>"
			},
			{
				args = {
					{
						{ "key 1", {
							{"key 1.1", {
								{ "key 1.1.1", "value 1.1.1" },
							}},
							{"key 1.2", "value 1.2" },
						}},
						{ "key2", "value2" },
					}
				},
				expect = "<dl><dt>key 1</dt><dd><dl><dt>key 1.1</dt><dd><dl><dt>key 1.1.1</dt><dd>value 1.1.1</dd></dl></dd><dt>key 1.2</dt><dd>value 1.2</dd></dl></dd><dt>key2</dt><dd>value2</dd></dl>"
			},
			{
				args = {
					{
						{ "key 1", "value 1.1", {
							{"key 1.1", "value 1.2"},
							{ "key 1.2", "value 1.2"},
						}},
					},
				},
				expect = "<dl><dt>key 1</dt><dd>value 1.1</dd><dd><dl><dt>key 1.1</dt><dd>value 1.2</dd><dt>key 1.2</dt><dd>value 1.2</dd></dl></dd></dl>"
			},
		},
	},
}
	
return p