Module:Hatnote

Documentation for this module may be created at Module:Hatnote/doc

--------------------------------------------------------------------------------
--                              Module:Hatnote                                --
--                                                                            --
-- This module produces hatnote links and links to related articles. It       --
-- implements the {{rellink}} and {{hatnote}} meta-templates, and a few of    --
-- the more popular templates they depend on, including {{main}},             --
-- {{see also}}, {{further}} and {{details}}.                                 --
--------------------------------------------------------------------------------

local mTableTools = require('Module:TableTools')
local mArguments = require('Module:Arguments')

--------------------------------------------------------------------------------
-- Argument processing
--------------------------------------------------------------------------------

--[[
-- The p table is for functions to be returned from #invoke, and for functions
-- to be used from other Lua modules. The f table is for functions acting as a
-- bridge between #invoke functions and Lua module functions. #invoke functions
-- are connected to f table functions through the makeInvokeFunction function.
-- Functions for use from other Lua modules have names beginning with an
-- underscore. 
--]]
local p, f = {}, {}

local function makeInvokeFunction(func)
	return function(frame)
		local args = mArguments.getArgs(frame, {parentOnly = true})
		return func(args)
	end
end

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

local function findNamespaceId(link)
	-- Finds the namespace id (namespace number) of a link or a pagename. This
	-- function will not work if the link is enclosed in double brackets or if
	-- the link has been escaped with the colon trick.
	local namespace = link:match('^(.-):')
	if namespace then
		local nsTable = mw.site.namespaces[namespace]
		if nsTable then
			return nsTable.id
		end
	end
	return 0
end

local function formatLink(link, display)
	-- 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 "#".

	-- Find whether we need to use the colon trick or not. We need to use the
	-- colon trick for categories and files, as otherwise category links
	-- categorise the page and file links display the file.
	local namespace = findNamespaceId(link)
	local colon
	if namespace == 6 or namespace == 14 then
		colon = ':'
	else
		colon = ''
	end

	-- Find the display value.
	if not display then
		local page, section = link:match('^(.-)#(.*)$')
		if page then
			display = page .. ' § ' .. section
		end
	end

	-- Assemble the link.
	if display then
		return string.format('[[%s%s|%s]]', colon, link, display)
	else
		return string.format('[[%s%s]]', colon, link)
	end
end

local function formatPages(...)
	-- Formats a list of pages using formatLink and returns it as an array. Nil
	-- values are not allowed.
	local pages = {...}
	local ret = {}
	for i, page in ipairs(pages) do
		ret[i] = formatLink(page)
	end
	return ret
end
	

local function makeWikitextError(msg)
	-- Formats an error message to be returned to wikitext.
	return string.format('<strong class="error">Error: %s.</strong>', msg)
end

--------------------------------------------------------------------------------
-- Hatnote
--
-- Produces standard hatnote text. Implements the {{hatnote}} template.
--------------------------------------------------------------------------------

function p._hatnote(s)
	return string.format('<div class="dablink">%s</div>', s)
end

function f.hatnote(args)
	local s = args[1]
	if not s then
		return makeWikitextError('no text specified')
	end
	return p._hatnote(s)
end

p.hatnote = makeInvokeFunction(f.hatnote)

--------------------------------------------------------------------------------
-- Rellink
--
-- Produces a standard link to a related article. Implements the {{rellink}}
-- template.
--------------------------------------------------------------------------------

function p._rellink(s, extraclasses)
	if extraclasses then
		extraclasses = ' ' .. extraclasses
	else
		extraclasses = ''
	end
	return string.format('<div class="rellink%s">%s</div>', extraclasses, s)
end

function f.rellink(args)
	local s = args[1]
	local extraclasses = args.extraclasses
	if not s then
		return makeWikitextError('no text specified')
	end
	return p._rellink(s, extraclasses)
end

p.rellink = makeInvokeFunction(f.rellink)

--------------------------------------------------------------------------------
-- Details
--
-- Produces a "For more details on this topic" link. the first parameter is the
-- page linked to, and if the second parameter is present it is used instead
-- of the "this topic" text.
--------------------------------------------------------------------------------

function p._details(page, topic)
	page = formatLink(page)
	topic = topic or 'this topic'
	local text = string.format('For more details on %s, see %s.', topic, page)
	local extraclasses = 'boilerplate seealso'
	return p._rellink(text, extraclasses)
end

function f.details(args)
	local page = args[1]
	local topic = args[2]
	if not page then
		return makeWikitextError('no page specified')
	end
	return p._details(page, topic)
end

p.details = makeInvokeFunction(f.details)

--------------------------------------------------------------------------------
-- Further
--
-- Produces a "Further information: a, b and c" link. It accepts an unlimited
-- number of positional parameters, each of which is a page name.
--------------------------------------------------------------------------------

function p._further(...)
	local links = formatPages(...)
	local text = 'Further information: ' .. mw.text.listToText(links)
	return p._rellink(text)
end

function f.further(args)
	local pages = mTableTools.compressSparseArray(args)
	if #pages < 1 then
		return makeWikiTextError('no pages specified')
	end
	return p._further(unpack(pages))
end

p.further = makeInvokeFunction(f.further)

--------------------------------------------------------------------------------
-- Main
--
-- Produces a link to a main article or articles. If used in category or
-- category talk space, produces "The main article for this category is xxx".
-- Otherwise, produces "Main article: xxx". Accepts a table of arguments.
-- Numerical keys for this table are the page names. If the first page name is
-- not in mainspace, uses "page" instead of "article". If more than one page is
-- specified, the function uses plural forms. Display names can be specified for
-- each page name by using the arguments l1, l2, etc.
--------------------------------------------------------------------------------

function p._main(args)
	-- Initialize variables.
	local links, firstPage
	local currentTitle = mw.title.getCurrentTitle()

	-- Make the list of formatted links and find the link for the first page.
	local nums = mTableTools.numKeys(args)
	if nums[1] then
		firstPage = args[nums[1]]
		links = {}
	else
		firstPage = currentTitle.text
		links = {formatLink(firstPage)}
	end
	for i, num in ipairs(nums) do
		local link = args[num]
		local display = args['l' .. tostring(num)]
		links[#links + 1] = formatLink(link, display)
	end

	-- Find the pagetype.
	local firstPageNs = findNamespaceId(firstPage)
	local pagetype = firstPageNs == 0 and 'article' or 'page'

	-- Build the text.
	local isPlural = #links > 1
	local currentNs = currentTitle.namespace
	local isCategoryNamespace = currentNs - currentNs % 2 == 14
	links = mw.text.listToText(links)
	local stringToFormat
	if isCategoryNamespace then
		if isPlural then
			stringToFormat = 'The main %ss for this'
				.. ' [[Wikipedia:Categorization|category]] are %s'
		else
			stringToFormat = 'The main %s for this'
				.. ' [[Wikipedia:Categorization|category]] is %s'
		end
	else
		if isPlural then
			stringToFormat = 'Main %ss: %s'
		else
			stringToFormat = 'Main %s: %s'
		end
	end
	local text = string.format(stringToFormat, pagetype, links)

	-- Pass the text to p._rellink.
	local extraclasses = 'relarticle mainarticle'
	return p._rellink(text, extraclasses)
end

p.main = makeInvokeFunction(p._main)

return p