<span class="mw-page-title-namespace">Module</span><span class="mw-page-title-separator">:</span><span class="mw-page-title-main">Format link</span>

This module, migrated from origins in Module:Hatnote, provides functionality for formatting links for display, including that powering the {{Format link}} template.

It can pretty-format section links with the section symbol ("§") and appropriate whitespace, it automatically escapes category and file names with the colon trick, and includes functionality for italicizing the page or section name, and for detecting and categorizing results that produce red links.

Use from wikitext

The functions in this module cannot be used directly from #invoke, and must be used through templates instead. Please see Template:Format link for documentation on usage of that template.

Use from other Lua modules

To load this module from another Lua module, use the following code:

local mFormatLink = require('Module:Format link')

You can then use the functions as documented below.

_formatLink

mFormatLink._formatLink{
    link = link,
    display = display,
    italicizePage = true,
    italicizeSection = true,
    categorizeMissing = 'Pages using formatted red links'
}

Formats link as a wikilink, with optional display value display. Categories and files are automatically escaped with the colon trick, and links to sections are automatically formatted as page § section, rather than the MediaWiki default of page#section. If manual piping is present in link, then the "manual" display value will be overridden by the display value if present.

If italicizePage is true then the page portion of the link is italicized, and if italicizeSection is true then the section portion of the link is italicized. If categorizeMissing is a string, then that value is used as a category name, and that category will be applied if the target of the link doesn't exist.

Examples

mFormatLink._formatLink{link = 'Foo#Bar'} → [[:Foo#Bar|Foo §&nbsp;Bar]] → Foo § Bar

mFormatLink._formatLink{link = 'Baz', display = 'Qux'} → [[:Baz|Qux]] → Qux

mFormatLink._formatLink{link = 'Foo|Bar', display = 'Baz'} → [[:Foo|Baz]] → Baz

mFormatLink._formatLink{link = 'Nonexistent page', categorizeMissing = 'Example'} → [[:Nonexistent page]][[Category:Example]] → Nonexistent page

mFormatLink._formatLink{link = 'Existing', categorizeMissing = 'Example'} → [[:Existing]] → Existing

mFormatLink._formatLink{link = 'The Lord of the Rings#Plot', italicizePage = true} → [[:The Lord of the Rings#Plot|''The Lord of the Rings'' §&nbsp;Plot]] → The Lord of the Rings § Plot

mFormatLink._formatLink{link = 'Cybercrime Prevention Act of 2012#Disini v. Secretary of Justice', italicizeSection = true} → [[:Cybercrime Prevention Act of 2012#Disini v. Secretary of Justice|Cybercrime Prevention Act of 2012 §&nbsp;''Disini v. Secretary of Justice'']] → Cybercrime Prevention Act of 2012 § Disini v. Secretary of Justice

formatPages

mFormatLink.formatPages(options, pages)

This derived function is useful for lists that format many links. It formats an array of pages using the _formatLink function, and returns the result as an array. Options in the options table are applied, and use the same names as the options for _formatLink.

Example

mFormatLink.formatPages({categorizeMissing = 'Example'}, {'Foo#Bar', 'Nonexistent page'}) → {'[[:Foo#Bar|Foo § Bar]]', '[[:Nonexistent page]][[Category:Example]]'}

---

--------------------------------------------------------------------------------
-- Format link
--
-- Makes a wikilink from the given link and display values. Links are escaped
-- with colons if necessary, and links to sections are detected and displayed
-- with " § " as a separator rather than the standard MediaWiki "#". Used in
-- the {{format link}} template.
--------------------------------------------------------------------------------
local libraryUtil = require('libraryUtil')
local checkType = libraryUtil.checkType
local checkTypeForNamedArg = libraryUtil.checkTypeForNamedArg
local mArguments -- lazily initialise [[Module:Arguments]]
local yesno -- lazily initialise [[Module:Yesno]]

local p = {}

--------------------------------------------------------------------------------
-- Helper functions
--------------------------------------------------------------------------------

local function getArgs(frame)
	-- Fetches the arguments from the parent frame. Whitespace is trimmed and
	-- blanks are removed.
	mArguments = require('Module:Arguments')
	return mArguments.getArgs(frame, {parentOnly = true})
end

local function removeInitialColon(s)
	-- Removes the initial colon from a string, if present.
	return s:match('^:?(.*)')
end

local function italicize(s)
	-- Italicize a string.
	return '<i>' .. s .. '</i>'
end

local function maybeItalicize(s, shouldItalicize)
	-- italicize s if s is a string and the shouldItalicize parameter is true.
	if s and shouldItalicize then
		return italicize(s)
	else
		return s
	end
end

local function parseLink(link)
	-- Parse a link and return a table with the link's components.
	-- These components are:
	-- - link: the link, stripped of any initial colon (always present)
	-- - page: the page name (always present)
	-- - section: the page name (may be nil)
	-- - display: the display text, if manually entered after a pipe (may be nil)
	link = removeInitialColon(link)

	-- Find whether a faux display value has been added with the {{!}} magic
	-- word.
	local prePipe, display = link:match('^(.-)|(.*)$')
	link = prePipe or link

	-- Find the page, if it exists.
	-- For links like [[#Bar]], the page will be nil.
	local preHash, postHash = link:match('^(.-)#(.*)$')
	local page
	if not preHash then
		-- We have a link like [[Foo]].
		page = link
	elseif preHash ~= '' then
		-- We have a link like [[Foo#Bar]].
		page = preHash
	end

	-- Find the section, if it exists.
	local section
	if postHash and postHash ~= '' then
		section = postHash
	end
	
	return {
		link = link,
		page = page,
		section = section,
		display = display,
	}
end

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

function p.formatLink(frame)
	-- The formatLink export function, for use in templates.
	yesno = require('Module:Yesno')
	local args = getArgs(frame)
	local link = args[1]
	if not link then
		return
			'<strong class="error">'..
			'Error: no link specified ([[Template:Format link#Errors|help]]).'..
			'</strong>'
	end
	return p._formatLink{
		link = link,
		display = args[2],
		italicizePage = yesno(args.italicizepage),
		italicizeSection = yesno(args.italicizesection),
		categorizeMissing = args.categorizemissing
	}
end

function p._formatLink(options)
	-- The formatLink export function, for use in modules.
	checkType('_formatLink', 1, options, 'table')
	checkTypeForNamedArg('_formatLink', 'link', options.link, 'string', false)
	checkTypeForNamedArg(
		'_formatLink',
		'display',
		options.display,
		'string',
		true
	)
	checkTypeForNamedArg(
		'_formatLink',
		'italicizePage',
		options.italicizePage,
		'boolean',
		true
	)
	checkTypeForNamedArg(
		'_formatLink',
		'italicizeSection',
		options.italicizeSection,
		'boolean',
		true
	)
	checkTypeForNamedArg(
		'_formatLink',
		'categorizeMissing',
		options.categorizeMissing,
		'string',
		true
	)

	local parsed = parseLink(options.link)
	local display = options.display or parsed.display
	local catMissing = options.categorizeMissing
	local category = ''

	--Test if page exists if a diagnostic category is specified
	if catMissing and (mw.ustring.len(catMissing) > 0) then
		local title = nil
		if parsed.page then title = mw.title.new(parsed.page) end
		if title and (not title.isExternal) and (not title.exists) then
			category = mw.ustring.format('[[Category:%s]]', catMissing)
		end
	end

	-- Deal with the case where we don't have to pipe the link
	if not display and not parsed.section and not options.italicizePage then
		return mw.ustring.format('[[:%s]]%s', parsed.link, category)
	end
	
	-- Find the display text for piped links
	if not display then
		local page = maybeItalicize(parsed.page, options.italicizePage)
		local section = maybeItalicize(parsed.section, options.italicizeSection)
		if not page then
			display = mw.ustring.format('§&nbsp;%s', section)
		elseif section then
			display = mw.ustring.format('%s §&nbsp;%s', page, section)
		else
			display = page
		end
	end
	
	return mw.ustring.format('[[:%s|%s]]%s', parsed.link, display, category)
end

--------------------------------------------------------------------------------
-- Derived convenience functions
--------------------------------------------------------------------------------

function p.formatPages(options, pages)
	-- Formats an array of pages using formatLink and the given options table,
	-- and returns it as an array. Nil values are not allowed.
	local ret = {}
	for i, page in ipairs(pages) do
		ret[i] = p._formatLink{
			link = page,
			categorizeMissing = options.categorizeMissing,
			italicizePage = options.italicizePage,
			italicizeSection = options.italicizeSection
		}
	end
	return ret
end

return p