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
-- Validate a entered total length and calculated total ength. If entered total length doesnt match with calculated total length, a warning is added.
function Validation:validateTotalLength(length, calculatedLength)
local hour, minutes, seconds
local calculatedHour, calculatedMinutes, calculatedSeconds
-- Try to match times like "1:23:45".
hour, minutes, seconds = length:match('^(%d+):(%d+):(%d+)$')
calculatedHour, calculatedMinutes, calculatedSeconds = calculatedLength:match('^(%d+):(%d+):(%d+)$')
if not seconds then
-- The previous attempt didn't match. Try to match times for entered total length like "1:23".
minutes, seconds = length:match('^(%d+):(%d+)$')
--If calculated total length is like "1:23:45".
--then convert hours to minutes
if calculatedSeconds then
calculatedMinutes = tonumber(calculatedMinutes) + (tonumber(calculatedHour) * 60)
calculatedLength = calculatedMinutes .. ':' .. calculatedSeconds
else
-- Try to match times for calculated total length like "1:23".
calculatedMinutes, calculatedSeconds = calculatedLength:match('^(%d+):(%d+)$')
end
--Перевіряємо чи збігається обрахована і вказана загальна тривалість
if tonumber(minutes) ~= tonumber(calculatedMinutes) or tonumber(seconds) ~= tonumber(calculatedSeconds) then
self:addWarning(
mw.message.newRawMessage(cfg.unmatched_total_length, length, calculatedLength):plain(),
cfg.input_error_category
)
end
return nil
end
--Перевіряємо чи збігається обрахована і вказана загальна тривалість
if tonumber(hour) ~= tonumber(calculatedhour) or tonumber(minutes) ~= tonumber(calculatedMinutes) or tonumber(seconds) ~= tonumber(calculatedSeconds) then
self:addWarning(
mw.message.newRawMessage(cfg.unmatched_total_length, length, calculatedLength):plain(),
cfg.input_error_category
)
return nil
end
return nil
end
--------------------------------------------------------------------------------
-- Function for autogenerate total_length
--------------------------------------------------------------------------------
local function sixtyTranslation (number)
local integer, remainder
if number % 60 == 0 then -- перевфряємо чи на ціло ділиться на 60
integer = number / 60 -- якщо то повертаємо ціле число
return integer, 0 -- повертаємо отримані значення
else -- якщо ні,
integer = math.floor(number / 60) -- то визначаємо скільких частин є
remainder = number - (60*integer) -- та визначаємо залишок
return integer, remainder -- повертаємо отримані значення
end
end
local function generateTotalLength (data, lengthFormat)
local total = { --містить суму секунд, хвилин та годин, а також ключ, за якими здійснюється додавання цілого числа до хвилин чи годин
seconds = {0, 'minutes'},
minutes = {0, 'hour'},
hour = {0, ''},
}
for k, item in ipairs (data) do -- ітереція для отримання значення тривалость кожного рядка
local hour, minutes, seconds
hour, minutes, seconds = item['length']:match('^(%d+):(%d+):(%d+)$') -- шукаємо години, хвилини та секунди
if not seconds then -- якщо попередній метод не вдвався, то
minutes, seconds = item['length']:match('^(%d+):(%d+)$') -- шукаємо хвилини та секунди
total.minutes[1] = total.minutes[1] + tonumber(minutes) --сумуємо хвилини
total.seconds[1] = total.seconds[1] + tonumber(seconds) --сумуємо секунди
else
total.hour[1] = total.hour[1] + tonumber(hour) --сумуємо години
total.minutes[1] = total.minutes[1] + tonumber(minutes) --сумуємо хвилини
total.seconds[1] = total.seconds[1] + tonumber(seconds) --сумуємо хвилини
end
end
for key, item in pairs(total) do -- ітереція для отримання значення таблиці total
integer, remainder = sixtyTranslation (item[1]) -- перетворення секунд/хвилини на хвилини/години, якщо значення виходить за 60
if not (item[2] == '' and integer == 0) then -- якщо ціле число не нуль та вказаний ключ наступнї таблиці
local index = item[2]
total[index][1] = total[index][1] + integer -- додаємо ціле число до хвилини/годин
if remainder < 10 then --якщо залишок менше 10
item[1] = '0' .. remainder --то додаємо 0 перед залишком і присвоємо залишок змінні, що містить секенди/хвилини
else --в іншомову випадку
item[1] = remainder --присвоємо залишок змінні, що містить секенди/хвилини
end
end
if lengthFormat == "minutes" or lengthFormat == "хвилини" then -- якщо формат загальної тривалості задано хвилини
break -- то зупинямо ітерацію
end
end
local result
if total.hour[1] == 0 then --якщо значення годин дорівнює 0
result = tonumber(total.minutes[1]) .. ':' .. total.seconds[1] --то формуємо рядок лише з хвилинами та секундами
else --в іншомову випадку
result = total.hour[1] .. ':' .. total.minutes[1] .. ':' .. total.seconds[1] --то формуємо рядок з годинами, хвилинами та секундами
end
return result
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')
: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')
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('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
--Формуємо значення булевого значення
self.total_length_auto = yesno(data.total_length_auto, false)
--Якщо задано автоматична генерація, то виконуємо обрахування загальної тривалості
if self.total_length_auto then
self.autoTotalLength = generateTotalLength(data.tracks or {}, data.total_length_auto_format)
end
-- Validate total length
if data.total_length then
self:validateLength(data.total_length)
--Перевіряємо чи обрахована тривалість і вказана тривалість збігаються
if self.autoTotalLength then
self:validateTotalLength(data.total_length, self.autoTotalLength)
end
end
-- Add properties
for field in pairs(TrackListing.fields) do
self[field] = data[field]
end
-- Evaluate boolean properties
self.collapsed = yesno(self.collapsed, false)
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('[[Category:%s]]', 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, '<br>')
end
function TrackListing:__tostring()
-- 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) .. '%'
-- Special adapted parametr for better visual compatibility with old Ukranian template
if nColumns == 6 then
titleColumnWidth = 30
end
titleColumnWidth = titleColumnWidth .. '%'
-- 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')
:addClass(self.collapsed and 'collapsible collapsed' or nil)
-- Overall table width
if self.width then
tableRoot
:css('width', self.width)
end
-- Header row
if self.headline or self.collapsed then
tableRoot:tag('tr'):tag('th')
:addClass('tlheader tracklist-caption')
:attr('colspan', nColumns)
:wikitext(self.headline or cfg.track_listing)
end
-- Headers
local headerRow = tableRoot:tag('tr')
---- Track number
headerRow
:tag('th')
:addClass('tracklist-number-header')
:attr('scope', 'col')
-- Цей рядок і ще один рядок, що нижче, використовується для виведення тексту при наведенні на #, тому це поки закоментував для подібності з нашим шаблоном
-- :tag('abbr')
-- :attr('title', cfg.number)
:wikitext(cfg.number_abbr)
---- Title column
headerRow:tag('th')
: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('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 or self.autoTotalLength then
tableRoot
:tag('tr')
:addClass('tracklist-total-length')
-- Нижче закоментовані рядки виводить текст «Total length:», але поточний шаблон не має тексту такого змісту, тому поки закоментовано для подібності
-- :tag('th')
-- :attr('colspan', nColumns - 1)
-- :attr('scope', 'row')
-- :tag('span')
-- :wikitext(cfg.total_length)
-- :done()
-- :done()
:tag('td')
:attr('colspan', nColumns)
:wikitext(self.total_length or self.autoTotalLength)
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 = 'Шаблон:Tracklist'
})
return p._main(args)
end
return p
Документація модуля[перегляд] [редагувати] [історія] [очистити кеш]
