Module:Track listing

local yesno = require('Module:Yesno') local checkType = require('libraryUtil').checkType local cfg = mw.loadData('Module:Track listing/configuration')

-- Helper functions

-- Add a mixin to a class. local function addMixin(class, mixin) for k, v in pairs(mixin) do		if k ~= 'init' then class[k] = v		end end end

-- Validation mixin

local Validation = {}

function Validation.init(self) self.warnings = {} self.categories = {} end

function Validation:addWarning(msg, category) table.insert(self.warnings, msg) table.insert(self.categories, category) end

function Validation:addCategory(category) table.insert(self.categories, category) end

function Validation:getWarnings return self.warnings end

function Validation:getCategories return self.categories end

-- Validate a track length. If a track length is invalid, a warning is added. -- A type error is raised if the length is not of type string or nil. function Validation:validateLength(length) checkType('validateLength', 1, length, 'string', true) if length == nil then -- Do nothing if no length specified return nil end

local hours, minutes, seconds

-- Try to match times like "1:23:45". hours, minutes, seconds = length:match('^(%d+):(%d%d):(%d%d)$') if hours and hours:sub(1, 1) == '0' then -- Disallow times like "0:12:34" self:addWarning(			string.format(cfg.leading_0_in_hours, mw.text.nowiki(length)),			cfg.input_error_category		) return nil end

if not seconds then -- The previous attempt didn't match. Try to match times like "1:23". minutes, seconds = length:match('^(%d?%d):(%d%d)$') if minutes and minutes:find('^0%d$') then -- Special case to disallow lengths like "01:23". This check has to -- be here so that lengths like "1:01:23" are still allowed. self:addWarning(				string.format(cfg.leading_0_in_minutes, mw.text.nowiki(length)),				cfg.input_error_category			) return nil end end

-- Add a warning and return if we did not find a match. if not seconds then self:addWarning(			string.format(cfg.not_a_time, mw.text.nowiki(length)),			cfg.input_error_category		) return nil end

-- Check that the minutes are less than 60 if we have an hours field. if hours and tonumber(minutes) >= 60 then self:addWarning(			string.format(cfg.more_than_60_minutes, mw.text.nowiki(length)),			cfg.input_error_category		) return nil end -- Check that the seconds are less than 60 if tonumber(seconds) >= 60 then self:addWarning(			string.format(cfg.more_than_60_seconds, mw.text.nowiki(length)),			cfg.input_error_category		) end

return nil end

-- Track class

local Track = {} Track.__index = Track addMixin(Track, Validation)

Track.fields = cfg.track_field_names

Track.cellMethods = { number = 'makeNumberCell', title = 'makeTitleCell', writer = 'makeWriterCell', lyrics = 'makeLyricsCell', music = 'makeMusicCell', extra = 'makeExtraCell', length = 'makeLengthCell', }

function Track.new(data) local self = setmetatable({}, Track) Validation.init(self) for field in pairs(Track.fields) do		self[field] = data[field] end self.number = assert(tonumber(self.number)) self:validateLength(self.length) return self end

function Track:getLyricsCredit return self.lyrics end

function Track:getMusicCredit return self.music end

function Track:getWriterCredit return self.writer end

function Track:getExtraField return self.extra end

-- Note: called with single dot syntax function Track.makeSimpleCell(wikitext) return mw.html.create('td') :wikitext(wikitext or cfg.blank_cell) end

function Track:makeNumberCell return mw.html.create('th') :addClass('volume2') :attr('id', string.format(cfg.track_id, self.number)) :attr('scope', 'row') :wikitext(string.format(cfg.number_terminated, self.number)) end

function Track:makeTitleCell local titleCell = mw.html.create('td') :addClass('volume2') titleCell:wikitext(		self.title and string.format(cfg.track_title, self.title) or cfg.untitled	) if self.note then titleCell:wikitext(string.format(cfg.note, self.note)) end return titleCell end

function Track:makeWriterCell return Track.makeSimpleCell(self.writer) end

function Track:makeLyricsCell return Track.makeSimpleCell(self.lyrics) end

function Track:makeMusicCell return Track.makeSimpleCell(self.music) end

function Track:makeExtraCell return Track.makeSimpleCell(self.extra) end

function Track:makeLengthCell return mw.html.create('td') :addClass('volume2') :addClass('tracklist-length') :wikitext(self.length or cfg.blank_cell) end

function Track:exportRow(columns) local columns = columns or {} local row = mw.html.create('tr') for i, column in ipairs(columns) do		local method = Track.cellMethods[column] if method then row:node(self[method](self)) end end return row end

-- TrackListing class

local TrackListing = {} TrackListing.__index = TrackListing addMixin(TrackListing, Validation) TrackListing.fields = cfg.track_listing_field_names TrackListing.deprecatedFields = cfg.deprecated_track_listing_field_names

function TrackListing.new(data) local self = setmetatable({}, TrackListing) Validation.init(self)

-- Check for deprecated arguments for deprecatedField in pairs(TrackListing.deprecatedFields) do		if data[deprecatedField] then self:addCategory(cfg.deprecated_parameter_category) break end end

-- Validate total length if data.total_length then self:validateLength(data.total_length) end -- Add properties for field in pairs(TrackListing.fields) do		self[field] = data[field] end -- Evaluate boolean properties self.showCategories = yesno(self.category) ~= false self.category = nil

-- Make track objects self.tracks = {} for i, trackData in ipairs(data.tracks or {}) do		table.insert(self.tracks, Track.new(trackData)) end

-- Find which of the optional columns we have. -- We could just check every column for every track object, but that would -- be no fun^H^H^H^H^H^H inefficient, so we use four different strategies -- to try and check only as many columns and track objects as necessary. do local optionalColumns = {} local columnMethods = { lyrics = 'getLyricsCredit', music = 'getMusicCredit', writer = 'getWriterCredit', extra = 'getExtraField', }		local doneWriterCheck = false for i, trackObj in ipairs(self.tracks) do			for column, method in pairs(columnMethods) do				if trackObj[method](trackObj) then optionalColumns[column] = true columnMethods[column] = nil end end if not doneWriterCheck and optionalColumns.writer then doneWriterCheck = true optionalColumns.lyrics = nil optionalColumns.music = nil columnMethods.lyrics = nil columnMethods.music = nil end if not next(columnMethods) then break end end self.optionalColumns = optionalColumns end

return self end

function TrackListing:makeIntro if self.all_writing then return string.format(cfg.tracks_written, self.all_writing) elseif self.all_lyrics and self.all_music then return mw.message.newRawMessage(			cfg.lyrics_written_music_composed,			self.all_lyrics,			self.all_music		):plain elseif self.all_lyrics then return string.format(cfg.lyrics_written, self.all_lyrics) elseif self.all_music then return string.format(cfg.music_composed, self.all_music) else return nil end end

function TrackListing:renderTrackingCategories if not self.showCategories or mw.title.getCurrentTitle.namespace ~= 0 then return '' end

local ret = ''

local function addCategory(cat) ret = ret .. string.format('', cat) end

for i, category in ipairs(self:getCategories) do		addCategory(category) end

for i, track in ipairs(self.tracks) do		for j, category in ipairs(track:getCategories) do			addCategory(category) end end

return ret end

function TrackListing:renderWarnings if not cfg.show_warnings then return '' end

local ret = {}

local function addWarning(msg) table.insert(ret, string.format(cfg.track_listing_error, msg)) end

for i, warning in ipairs(self:getWarnings) do		addWarning(warning) end

for i, track in ipairs(self.tracks) do		for j, warning in ipairs(track:getWarnings) do			addWarning(warning) end end

return table.concat(ret, ' ') end

function TrackListing:__tostring -- Root of the output local root = mw.html.create('div') :addClass('track-listing') local intro = self:makeIntro if intro then root:tag('p') :wikitext(intro) :done end -- Start of track listing table local tableRoot = mw.html.create('table') tableRoot :addClass('tracklist') -- Header row if self.headline then tableRoot:tag('caption') :wikitext(self.headline or cfg.track_listing) end

-- Headers local headerRow = tableRoot:tag('tr')

Track number headerRow :tag('th') :addClass('tracklist-number-header') :addClass(self.bg) :attr('scope', 'col') :tag('abbr') :attr('title', cfg.number) :wikitext(cfg.number_abbr)

-- Find columns to output local columns = {'number', 'title'} if self.optionalColumns.writer then columns[#columns + 1] = 'writer' else if self.optionalColumns.lyrics then columns[#columns + 1] = 'lyrics' end if self.optionalColumns.music then columns[#columns + 1] = 'music' end end if self.optionalColumns.extra then columns[#columns + 1] = 'extra' end columns[#columns + 1] = 'length' -- Find column width local nColumns = #columns local nOptionalColumns = nColumns - 3 local titleColumnWidth = 100 if nColumns >= 5 then titleColumnWidth = 40 elseif nColumns >= 4 then titleColumnWidth = 60 end local optionalColumnWidth = ((100 - titleColumnWidth) / nOptionalColumns) .. '%'	titleColumnWidth = titleColumnWidth .. '%'	 Title column headerRow:tag('th') :addClass(self.bg) :attr('scope', 'col') :css('width', self.title_width or titleColumnWidth) :wikitext(cfg.title)

Optional headers: writer, lyrics, music, and extra local function addOptionalHeader(field, headerText, width) if self.optionalColumns[field] then headerRow:tag('th') :attr('scope', 'col') :css('width', width or optionalColumnWidth) :wikitext(headerText) end end addOptionalHeader('writer', cfg.writer, self.writing_width) addOptionalHeader('lyrics', cfg.lyrics, self.lyrics_width) addOptionalHeader('music', cfg.music, self.music_width) addOptionalHeader(		'extra',		self.extra_column or cfg.extra,		self.extra_width	)

Track length headerRow:tag('th') :addClass(self.bg) :addClass('tracklist-length-header') :attr('scope', 'col') :wikitext(cfg.length)

-- Tracks for i, track in ipairs(self.tracks) do		tableRoot:node(track:exportRow(columns)) end

-- Total length if self.total_length then tableRoot :tag('tr') :addClass('tracklist-total-length') :tag('th') :attr('colspan', nColumns - 1) :attr('scope', 'row') :tag('span') :addClass(self.bg) :wikitext(cfg.total_length) :done :done :tag('td') :addClass(self.bg) :wikitext(self.total_length) end root:node(tableRoot) -- Warnings and tracking categories root:wikitext(self:renderWarnings) root:wikitext(self:renderTrackingCategories) return mw.getCurrentFrame:extensionTag{ name = 'templatestyles', args = { src = 'Module:Track listing/styles.css' } } .. tostring(root) end

-- Exports

local p = {}

function p._main(args) -- Process numerical args so that we can iterate through them. local data, tracks = {}, {} for k, v in pairs(args) do		if type(k) == 'string' then local prefix, num = k:match('^(%D.-)(%d+)$') if prefix and Track.fields[prefix] and (num == '0' or num:sub(1, 1) ~= '0') then -- Allow numbers like 0, 1, 2 ..., but not 00, 01, 02..., -- 000, 001, 002... etc.				num = tonumber(num) tracks[num] = tracks[num] or {} tracks[num][prefix] = v			else data[k] = v			end end end data.tracks = (function (t)		-- Compress sparse array		local ret = {}		for num, trackData in pairs(t) do			trackData.number = num			table.insert(ret, trackData) 		end		table.sort(ret, function (t1, t2) return t1.number < t2.number end)		return ret	end)(tracks)

return tostring(TrackListing.new(data)) end

function p.main(frame) local args = require('Module:Arguments').getArgs(frame, {		wrappers = 'Template:Track listing'	}) return p._main(args) end

return p