FANDOM


-------------------------------------------------------------------------------
-- Helper functions
-------------------------------------------------------------------------------
 
-- Find whether the specified page exists. We use pcall to catch errors if we
-- are over the expensive parser function count limit, or a number of other
-- juicy errors. This function increases the expensive parser function count
-- for every new page called.
local function exists(page)
	local success, title = pcall(mw.title.new, page)
	return success and title and title.exists or false
end
 
-------------------------------------------------------------------------------
-- Eras class
-------------------------------------------------------------------------------
 
-- The eras class does all of the heavy lifting in the module. We use a class
-- rather than normal functions so that we can avoid passing lots of different
-- values around for each different function.
 
local Eras = {}
Eras.__index = Eras -- Set up inheritance for tables that use Eras as a metatable.
 
-- This function makes a new eras object. Here we set all the values from the
-- arguments and do any preprocessing that we need.
function Eras.new(args, title)
	local obj = setmetatable({}, Eras) -- Make our object inherit from Eras.
	obj.title = title or mw.title.getCurrentTitle()
 
	-- Set object structure
	obj.categories = {}
 
	-- Set display title parameters
	obj.noDisplayTitle = args.notitle
	obj.displayTitleBase = args.title
	obj.displayTitleParen = args.title2
 
	-- Set hidden status
	obj.isHidden = args.hide
 
	-- Set the continuity override (the "type" parameter)
	if args.type then
		local override = args.type:lower()
		if override ~= 'canon' and override ~= 'legends' then
			obj:raiseError("if the 'type' parameter is specified, it must " ..
				"have a value of 'canon' or 'legends'")
		end
		obj.continuityOverride = override
	end
 
	-- Set canon and legends article names for the subject
	obj.legendsArticle = args.legends
	obj.canonArticle = args.canon
 
	-- Get the icon data.
	do
		local icons = {}
		for _, v in ipairs(args) do
			if t then
				icons[string.lower(v)] = t
			else
				-- The specified icon wasn't found in the icon data, so set a
				-- tracking category flag.
				obj.hasBadParameter = true
			end
		end
		obj.icons = icons
	end
 
	return obj
end
 
-- Raise an error. If DEBUG_MODE is set to false, then errors raised here
-- are caught by the export function p._main.
function Eras:raiseError(msg)
	local level
	if DEBUG_MODE then
		level = nil
	else
		level = 0 -- Suppress module name and line number in the error message.
	end
	error(msg, level)
end
 
-- Add a category, to be rendered at the very end of the template output.
function Eras:addCategory(cat, sort)
	table.insert(self.categories, {category = cat, sortKey = sort})
end
 
-- Shortcut method for getting an icon data subtable.
function Eras:getIconData(code)
	return self.icons[code]
end
 
-- Whether the current title ends with /Canon.
function Eras:hasCanonTitle()
	return self.title.text:find('/Canon$')
end
 
-- Whether the current title ends with /Show.
function Eras:hasLegendsTitle()
	return self.title.text:find('/Show$')
end
 
-- Analyses the page name and sets {{DISPLAYTITLE}}.
function Eras:renderDisplayTitle()
	local pagename = self.title.text
 
	-- Exit if we have been told not to set a title or if the title begins with
	-- an opening parenthesis.
	if self.noDisplayTitle or pagename:find('^%(') then
		return nil
	end
 
	-- Find the display base and the display parentheses.
	local dBase = self.displayTitleBase
	local dParen = self.displayTitleParen
	if not dBase or not dParen then
		-- Analyse the pagename to find base part and any ending parentheses.
		-- /Canon is removed, and parentheses are only recognised if they are
		-- at the end of the pagename.
		local trimmedPagename = pagename:gsub('/Canon$', '')
		trimmedPagename = trimmedPagename:gsub('/Show$', '')
		local base, paren = trimmedPagename:match('^(.*)%s*%((.-)%)$')
		if not base then
			base = trimmedPagename
		end
		-- Use the values we found, but only if a value has not already been
		-- specified.
		dBase = dBase or base
		dParen = dParen or paren
	end
 
	-- Build the display string
	local display
	if dParen then
		display = string.format('%s <small>(%s)</small>', dBase, dParen)
	else
		display = dBase
	end
	if self.title.namespace ~= 0 then
		display = mw.site.namespaces[self.title.namespace].name .. ':' .. display
	end
 
	-- Return the expanded DISPLAYTITLE parser function.
	return mw.getCurrentFrame():preprocess(string.format(
		'{{DISPLAYTITLE:%s}}',
		display
	))
end
-- Renders the Canon and TSS tabs for articles that are in both
-- continuities.
function Eras:renderCanonTab()
	if self.isHidden or self.title.namespace ~= 0 then
		-- Exit if we have been explicitly hidden or if we are not in the main
		-- namespace.
		return nil
	end
 
	-- Find the page type, canon title, and legends title.
	local pageType, canonTitle, legendsTitle
	if self.legendsArticle then
		pageType = 'canon'
		canonTitle = self.title.text
		legendsTitle = self.legendsArticle
	elseif self.canonArticle then
		pageType = 'legends'
		canonTitle = self.canonArticle
		legendsTitle = self.title.text
	elseif self:hasCanonTitle() then
		pageType = 'canon'
		canonTitle = self.title.text
		legendsTitle = canonTitle:match('^(.*)/Canon$') or canonTitle
	elseif self:hasLegendsTitle() then
		pageType = 'legends'
		legendsTitle = self.title.text
		canonTitle = legendsTitle:match('^(.*)/Show$') or legendsTitle
	elseif exists(self.title.text .. '/Show') then
		pageType = 'canon'
		legendsTitle = self.title.text .. '/Show'
		canonTitle = self.title.text
	elseif exists(self.title.text .. '/Canon') then
		pageType = 'legends'
		canonTitle = self.title.text .. '/Canon'
		legendsTitle = self.title.text
	else
		-- Could not determine that the article has both a Canon and a TSS
		-- version, so exit.
		return nil
	end
 
	if self:hasCanonTitle() then
		self:addCategory('Articles with /Canon')
	end
 
	-- Add categories.
	if pageType == 'canon' then
		self:addCategory('Canon articles with Thomas Simpson Show counterparts')
	elseif pageType == 'legends' then
		self:addCategory('Thomas Simpson Show articles with canon counterparts')
	else
		self:addCategory('Outliers')
	end
 
	-- Make the table root.
	local root = mw.html.create('table')
	root
		:attr('id', 'canontab')
		:css('text-align', 'center')
		:css('padding', '0')
		:css('margin', '0 0 5px 0')
		:css('border-left', '0')
		:css('border-right', '0')
		:css('border-top', '0')
		:css('border-bottom', '7px solid #002e54')
		:css('border-spacing', '0')
		:css('border-collapse', 'collapse')
		:css('width', '100%')
		:css('vertical-align', 'top')
 
	local row = root:tag('tr')
 
	-- This makes one Canon/Legends cell. Having this as a function rather than
	-- doing it with chaining allows us to avoid putting the same code in twice.
	local function makeCell(id, color, image, link, tooltip)
		local cell = mw.html.create('td')
		cell
			:attr('id', id)
			:css('padding', '0 0 5px 0')
			:css('background-color', color)
			:css('line-height', '0.95em')
			:css('font-size', '150%')
			:css('font-weight', 'bold')
			:css('width', '20px')
			:css('vertical-align', 'top')
			:tag('span')
				:addClass('content-bg rtop')
				:css('background', '#ffffff')
				:tag('span')
					:addClass('r1')
					:css('background', color)
					:done()
				:tag('span')
					:addClass('r2')
					:css('background', color)
					:done()
				:tag('span')
					:addClass('r3')
					:css('background', color)
					:done()
				:tag('span')
					:addClass('r4')
					:css('background', color)
					:done()
				:done()
			:wikitext(string.format(
				' [[File:%s|link=%s|%s]]',
				image, link, tooltip
			))
		return cell
	end
 
	local foregroundColor = '#002e54'
	local backgroundColor = '#d8e9fc'
 
	-- Make the canon cell.
	do
		local id = 'canontab-canon'
		local link = canonTitle
		local color, image, tooltip
		if pageType == 'canon' then
			color = foregroundColor
			image = 'Tab-canon-white.png'
			tooltip = 'This article covers the Canon version of this subject.'
		else
			color = backgroundColor
			image = 'Tab-canon-black.png'
			tooltip = "Click here for The Puppet Saga Wiki's article on the Canon " ..
				"version of this subject."
		end
		row:node(makeCell(id, color, image, link, tooltip))
	end
 
	-- First separator cell
	row:tag('td')
		:attr('id', 'canontab-separator1')
		:css('width', '3px')
		:wikitext('&nbsp;')
 
	-- Make the legends cell
	do
		local id = 'canontab-legends'
		local link = legendsTitle
		local color, image, tooltip
		if pageType ~= 'canon' then --  page
			color = foregroundColor
			image = 'Tab-show-white.png'
			tooltip = 'This article covers the Thomas Simpson Show version of this subject.'
		else -- is a Canon page
			color = backgroundColor
			image = 'Tab-show-black.png'
			tooltip = "Click here for The Puppet Saga Wiki's article on the Thomas Simpson Show " ..
				"version of this subject."
		end
		row:node(makeCell(id, color, image, link, tooltip))
	end
 
	-- Second separator cell
	row:tag('td')
		:attr('id', 'canontab-separator2')
		:css('width', '3000px')
		:wikitext('&nbsp;')
 
	return tostring(root)
end
 
-- Render all the categories that were specified using Eras:addCategory or with
-- category flags.
function Eras:renderCategories()
	local fullPagename = self.title.prefixedText
	if fullPagename == 'Template:Eras' or fullPagename == 'Template:Eraicon' then
		-- Exit if we are on a blacklisted page.
		return nil
	end
 
	local pagename = self.title.text
 
	-- Renders one category.
	local function renderCategory(cat, sort)
		return string.format(
			'[[%s:%s|%s]]', 'Category', cat, sort or pagename
		)
	end
 
	local ret = {}
 
	-- Render categories from Eras:addCategory
	for i, t in ipairs(self.categories) do
		ret[i] = renderCategory(t.category, t.sortKey)
	end
	return table.concat(ret)
end
-- This method is called when the tostring function is used on the Eras object.
-- (This works in a similar fashion to Eras.__index above.) It calls all the
-- top-level render methods and returns the final output.
function Eras:__tostring()
	local ret = {}
	ret[#ret + 1] = self:renderDisplayTitle()
	ret[#ret + 1] = self:renderCanonTab()
	ret[#ret + 1] = self:renderCategories()
	return table.concat(ret)
end
-------------------------------------------------------------------------------
-- Exports
-------------------------------------------------------------------------------
 
local p = {}
 
-- This function is the entry point from other Lua modules.
function p._main(args)
	-- Define a function to call from pcall so that we can catch any errors
	-- and display them to the user rather than the cryptic "Script error".
	-- (It's not so cryptic if you click on it to see the error message, but
	-- not so many users know to do that.)
	local function getErasResult ()
		local erasObj = Eras.new(args)
		return tostring(erasObj)
	end
 
	-- Get the result. We only catch errors if debug mode is set to false.
	local success, result
	if DEBUG_MODE then
		success = true
		result = getErasResult()
	else
		success, result = pcall(getErasResult)
	end
 
	-- Return the result if there were no errors, and a formatted error message 
	-- if there were.
	if success then
		return result
	else
		return string.format(
			'<strong class="error">[[Template:Eras]] error: %s.</strong>' ..
			'[[' .. 'Category:Pages with bad parameters in Template:Eras]]',
			result -- this is the error message
		)
	end
end
 
-- This is the function accessed from wikitext. It must be accessed through
-- a template. The template should transclude only the text
-- "{{#invoke:Eras|main}}", and then when that template is used, any arguments
-- passed to it are magically sent through to the module.
function p.main(frame)
	local args = {}
	for k, v in pairs(frame:getParent().args) do
		v = v:match('^%s*(.-)%s*$') -- trim whitespace
		if v ~= '' then
			args[k] = v
		end
	end
	return p._main(args)
end
 
return p
 
-- </nowiki>
-- [[Category:Eras utility templates|{{PAGENAME}}]]

Ad blocker interference detected!


Wikia is a free-to-use site that makes money from advertising. We have a modified experience for viewers using ad blockers

Wikia is not accessible if you’ve made further modifications. Remove the custom ad blocker rule(s) and the page will load as expected.