KWCBot: main(): accept month/day from direct #invoke frame args too (testing)

2026-07-15T00:12:46Z

main(): accept month/day from direct #invoke frame args too (testing)

New page

local p = {}

----------------------------------------------------------------
-- CONFIG: Week 1 anchor for King Warz Charts
-- Week 1 starts: 2020-12-25 (Friday)
----------------------------------------------------------------
local WEEK1_Y, WEEK1_M, WEEK1_D = 2020, 12, 25

----------------------------------------------------------------
-- Load data from Module:OnThisDay/Data
----------------------------------------------------------------
local ok, data = pcall(mw.loadData, 'Module:OnThisDay/Data')
if not ok or type(data) ~= 'table' then
data = {}
end

-- Extra day-precise events (certs, first plays, debuts, first #1s),
-- generated by the Control Center's otd_events.py
local ok2, extraEvents = pcall(mw.loadData, 'Module:OnThisDay/Extra')
if not ok2 or type(extraEvents) ~= 'table' then
extraEvents = {}
end

----------------------------------------------------------------
-- Date helpers (pure Lua date math; no os.time needed)
-- Uses "days from civil" algorithms (safe in Scribunto)
----------------------------------------------------------------
local function isLeap(y)
return (y % 4 == 0 and y % 100 ~= 0) or (y % 400 == 0)
end

local function daysInMonth(y, m)
local dim = {31,28,31,30,31,30,31,31,30,31,30,31}
if m == 2 and isLeap(y) then
return 29
end
return dim[m] or 30
end

-- Convert civil date -> serial day number (Rata Die-ish)
local function daysFromCivil(y, m, d)
-- Howard Hinnant algorithm
y = y - (m <= 2 and 1 or 0)
local era = math.floor(y / 400)
local yoe = y - era * 400
local doy = math.floor((153 * (m + (m > 2 and -3 or 9)) + 2) / 5) + d - 1
local doe = yoe * 365 + math.floor(yoe / 4) - math.floor(yoe / 100) + doy
return era * 146097 + doe
end

-- Convert serial day number -> civil date
local function civilFromDays(z)
-- Inverse Howard Hinnant algorithm
local era = math.floor(z / 146097)
local doe = z - era * 146097
local yoe = math.floor((doe - math.floor(doe/1460) + math.floor(doe/36524) - math.floor(doe/146096)) / 365)
local y = yoe + era * 400
local doy = doe - (yoe * 365 + math.floor(yoe/4) - math.floor(yoe/100))
local mp = math.floor((5 * doy + 2) / 153)
local d = doy - math.floor((153 * mp + 2) / 5) + 1
local m = mp + (mp < 10 and 3 or -9)
y = y + (m <= 2 and 1 or 0)
return y, m, d
end

local function pad2(n)
if n < 10 then return "0" .. tostring(n) end
return tostring(n)
end

local function toISO(y, m, d)
return tostring(y) .. "-" .. pad2(m) .. "-" .. pad2(d)
end

local function parseISO(s)
if type(s) ~= 'string' then return nil end
local y, m, d = s:match("^(%d%d%d%d)%-(%d%d)%-(%d%d)$")
if not y then return nil end
y, m, d = tonumber(y), tonumber(m), tonumber(d)
if not y or not m or not d then return nil end
if m < 1 or m > 12 then return nil end
local dim = daysInMonth(y, m)
if d < 1 or d > dim then return nil end
return y, m, d
end

-- Week number -> Week start ISO date (Friday)
local function weekToISO(weekNum)
if not weekNum or weekNum < 1 then return nil end
local base = daysFromCivil(WEEK1_Y, WEEK1_M, WEEK1_D)
local z = base + (weekNum - 1) * 7
local y, m, d = civilFromDays(z)
return toISO(y, m, d)
end

----------------------------------------------------------------
-- Helpers
----------------------------------------------------------------
local u = mw.ustring

local TITLE_JOINERS = {
['of'] = true, ['the'] = true, ['and'] = true, ['a'] = true,
['an'] = true, ['in'] = true, ['on'] = true, ['to'] = true,
['for'] = true, ['with'] = true, ['from'] = true, ['by'] = true,
['at'] = true, ['or'] = true,
}

local function titlecase(str)
if not str or str == '' then
return ''
end
str = mw.text.trim(str)
str = u.lower(str)

local first = true
local function up_word(word)
local bare = u.match(word, '^%p*(.-)%p*$') or word
if not first and TITLE_JOINERS[bare] then
return word -- joiners stay lowercase mid-title
end
first = false
-- capitalize the first LETTER, skipping leading punctuation
-- so '(rock' becomes '(Rock', not '(rock'
local pre, ch, rest = u.match(word, '^(%A*)(%a)(.*)$')
if ch then
return pre .. u.upper(ch) .. rest
end
return word
end

str = u.gsub(str, '%S+', up_word)
return str
end

local function normalizeArtistList(raw)
if not raw or raw == '' then
return ''
end
local parts = {}
for part in mw.text.gsplit(raw, ",") do
part = mw.text.trim(part)
part = titlecase(part)
table.insert(parts, part)
end
return table.concat(parts, ", ")
end

local function normalizeNo1Field(text, isAlbum)
if not text or text == '' then
return text
end

local linkInner, afterLink = text:match("%[%[([^%]]+)%]%](.*)")
if not linkInner then
return titlecase(text)
end

local target, label = linkInner:match("^(.-)|(.+)$")
if not target then
target = linkInner
label = linkInner
end

label = titlecase(label)

if isAlbum then
label = "''" .. label .. "''"
end

local changed = false

local beforeSmall, insideParens, afterSmall =
afterLink:match("^(.-)%s*%((.-)%)%s*(.*)$")

if insideParens then
local artistsText = normalizeArtistList(insideParens)
afterLink = (beforeSmall or "") ..
"(" .. artistsText .. ")" ..
(afterSmall or "")
changed = true
else
local b2, insidePlain, a2 =
afterLink:match("^(.-)%s*(.-)%s*(.*)$")
if insidePlain then
local artistsText = normalizeArtistList(insidePlain)
afterLink = (b2 or "") ..
"" .. artistsText .. "" ..
(a2 or "")
changed = true
else
local b3, artistsPlain, a3 =
afterLink:match("^(%s*)%(%s*(.-)%s*%)(.*)$")
if artistsPlain then
local artistsText = normalizeArtistList(artistsPlain)
afterLink = (b3 or "") ..
"(" .. artistsText .. ")" ..
(a3 or "")
changed = true
end
end
end

if not changed then
local newAfter, n = afterLink:gsub("%(([^()]+)%)", function(inner)
local artistsText = normalizeArtistList(inner)
return "(" .. artistsText .. ")"
end, 1)
if n > 0 then
afterLink = newAfter
end
end

local link = "[[" .. target .. "|" .. label .. "]]"
return link .. afterLink
end

local function getMonthDay(args)
local month = tonumber(args.month)
local day = tonumber(args.day)

if not month or not day then
local lang = mw.getContentLanguage()
month = tonumber(lang:formatDate('m'))
day = tonumber(lang:formatDate('d'))
end

return month, day
end

local function targetDateString(year, month, day)
return string.format('%04d-%02d-%02d', year, month, day)
end

----------------------------------------------------------------
-- Normalize entry date:
-- - If entry.date is valid ISO, keep it
-- - Else if entry.week exists, compute ISO date from week anchor
-- - Else nil
----------------------------------------------------------------
local function getEntryISODate(entry)
local datestr = tostring(entry.date or '')
local y, m, d = parseISO(datestr)
if y then
return datestr
end

local w = tonumber(entry.week)
if w then
return weekToISO(w)
end

return nil
end

----------------------------------------------------------------
-- Build per-year index from the data module (using normalized dates)
----------------------------------------------------------------
local by_year = {}
local year_min, year_max = nil, nil

for md, entries in pairs(data) do
if type(entries) == 'table' then
for _, entry in ipairs(entries) do
local iso = getEntryISODate(entry)
if iso then
local year = tonumber(iso:sub(1,4))
if year then
if not by_year[year] then
by_year[year] = {}
end

-- store a lightweight copy with a normalized date
table.insert(by_year[year], {
date = iso,
week = entry.week,
no1song = entry.no1song,
no1album = entry.no1album
})

if not year_min or year < year_min then year_min = year end
if not year_max or year > year_max then year_max = year end
end
end
end
end
end

for year, list in pairs(by_year) do
table.sort(list, function(a, b)
return tostring(a.date or '') < tostring(b.date or '')
end)
end

----------------------------------------------------------------
-- For a given year and target month/day:
-- 1) pick the last entry whose date <= target
-- 2) if none, pick the first entry whose date >= target
----------------------------------------------------------------
local function pickNearestInYear(year, month, day)
local list = by_year[year]
if not list then
return nil
end

local target = targetDateString(year, month, day)

local chosenBefore = nil
local firstAfter = nil

for _, entry in ipairs(list) do
local d = tostring(entry.date or '')
if d ~= '' then
if d <= target then
chosenBefore = entry
elseif not firstAfter and d >= target then
firstAfter = entry
end
end
end

return chosenBefore or firstAfter
end

local function formatEntryParts(entry)
local datestr = tostring(entry.date or '')
local year = datestr:sub(1, 4)
local week = tonumber(entry.week)
local weekPart = ''
if week then
weekPart = string.format('[[Week %d]] – ', week)
end

local songLine, albumLine

if entry.no1song and entry.no1song ~= '' then
local songText = normalizeNo1Field(entry.no1song, false)
songLine = string.format(
'* %s – %s%s is the #1 song on the charts',
year,
weekPart,
songText
)
end

if entry.no1album and entry.no1album ~= '' then
local albumText = normalizeNo1Field(entry.no1album, true)
albumLine = string.format(
'* %s – %s%s is the #1 album on the charts',
year,
weekPart,
albumText
)
end

return songLine, albumLine
end

----------------------------------------------------------------
-- Main entry point
----------------------------------------------------------------
function p.main(frame)
-- prefer whichever frame actually carries month/day: template calls
-- put them in parent.args, direct {{#invoke:}} puts them in frame.args
local parent = frame:getParent()
local pargs = parent and parent.args or {}
local fargs = frame.args or {}
local args = pargs
if not (pargs.month or pargs.day) and (fargs.month or fargs.day) then
args = fargs
end

local month, day = getMonthDay(args)
if not month or not day then
return 'OnThisDay: could not determine date.'
end

local lang = mw.getContentLanguage()
local currentYear = tonumber(lang:formatDate('Y')) or 2025

-- Use actual min year found in data; fallback to 2020
local startYear = year_min or 2020

local picks = {}
for year = startYear, currentYear do
local entry = pickNearestInYear(year, month, day)
if entry then
table.insert(picks, entry)
end
end

local songLines, albumLines = {}, {}

for _, entry in ipairs(picks) do
local sLine, aLine = formatEntryParts(entry)
if sLine then table.insert(songLines, sLine) end
if aLine then table.insert(albumLines, aLine) end
end

local out = {}
table.insert(out, "'''On this day in King Warz Charts history:'''")
table.insert(out, '')

if #songLines > 0 then
table.insert(out, "''Songs''")
for _, line in ipairs(songLines) do
table.insert(out, line)
end
end

if #albumLines > 0 then
table.insert(out, '')
table.insert(out, "''Albums''")
for _, line in ipairs(albumLines) do
table.insert(out, line)
end
end

-- day-precise anniversaries from Module:OnThisDay/Extra
local mdKey = string.format('%02d-%02d', month, day)
local ex = extraEvents[mdKey]
if ex then
local function addSection(title, rows, cap, fmt)
if not rows then return end
local total = 0
for _ in ipairs(rows) do total = total + 1 end
if total == 0 then return end
table.insert(out, '')
table.insert(out, "''" .. title .. "''")
local n = 0
for _, r in ipairs(rows) do
n = n + 1
if cap and n > cap then
table.insert(out, string.format(
'* ...and %d more', total - cap))
break
end
table.insert(out, fmt(r))
end
end
addSection('Artist birthdays', ex.birthdays, nil, function(r)
if r.dead then
return string.format('* %d – [[%s]] was born on this day',
r.year, r.artist)
end
return string.format(
'* %d – [[%s]] was born on this day (turns %d)',
r.year, r.artist, currentYear - r.year)
end)
addSection('Certifications', ex.certs, 6, function(r)
return string.format('* %d – [[%s]] reached %s',
r.year, r.page, r.label)
end)
addSection('First listens', ex.firstplays, 5, function(r)
return string.format('* %d – First ever play of [[%s]]',
r.year, r.page)
end)
addSection('Chart debuts', ex.debuts, 5, function(r)
local nm = r.album and ("''[[" .. r.page .. "]]''") or ("[[" .. r.page .. "]]")
local chart = r.album and 'album chart' or 'chart'
return string.format('* %d – %s debuted on the %s at #%d',
r.year, nm, chart, r.pos)
end)
addSection('First week at No. 1', ex.crownings, nil, function(r)
local nm = r.album and ("''[[" .. r.page .. "]]''") or ("[[" .. r.page .. "]]")
local chart = r.album and ' on the album chart' or ''
return string.format(
'* %d – %s hit #1 for the first time%s ([[Week %d]])',
r.year, nm, chart, r.week)
end)
addSection('Play milestones', ex.playmilestones, 5, function(r)
local nm = r.album and ("''[[" .. r.page .. "]]''") or ("[[" .. r.page .. "]]")
return string.format('* %d – %s logged its %s play',
r.year, nm, r.mlabel)
end)
addSection('Artist firsts', ex.artistfirsts, 4, function(r)
return string.format('* %d – First ever play of a [[%s]] song',
r.year, r.artist)
end)
addSection('Listening records', ex.recorddays, nil, function(r)
if r.rank == 1 then
return string.format(
'* %d – Your busiest listening day on record (%s plays)',
r.year, r.plays)
end
return string.format(
'* %d – Your %s-busiest listening day on record (%s plays)',
r.year, r.ranklabel, r.plays)
end)
addSection('Certification crown', ex.certcrowns, nil, function(r)
if r.prev and r.prev ~= '' then
return string.format(
'* %d – [[%s]] overtook [[%s]] as the most certified song in chart history',
r.year, r.page, r.prev)
end
return string.format(
'* %d – [[%s]] became the most certified song in chart history',
r.year, r.page)
end)
end

if #out <= 2 then
return string.format(
'No chart history recorded for this date yet (month=%d, day=%d).',
month, day)
end

return table.concat(out, '\n')
end

----------------------------------------------------------------
-- Debug helper
----------------------------------------------------------------
function p.debug(frame)
local parent = frame:getParent()
local args = parent and parent.args or frame.args or {}
local month, day = getMonthDay(args)

local out = {}
table.insert(out, string.format('Debug OnThisDay: month=%d, day=%d', month or -1, day or -1))

table.insert(out, string.format('\nData loaded ok: %s', tostring(ok)))
table.insert(out, '\nTop-level data type: ' .. type(data))

local years = {}
for y, _ in pairs(by_year) do
table.insert(years, y)
end
table.sort(years)

table.insert(out, '\n\nYears indexed in by_year: ' .. (#years > 0 and table.concat(years, ', ') or '(none)'))
table.insert(out, string.format('\nYear min/max: %s / %s', tostring(year_min), tostring(year_max)))

table.insert(out, string.format(
'\n\nWeek1 anchor used: %04d-%02d-%02d',
WEEK1_Y, WEEK1_M, WEEK1_D
))

local currentYear = tonumber(mw.getContentLanguage():formatDate('Y')) or 2025
local startYear = year_min or 2020

table.insert(out, '\n\nPicks per year for this month/day:')
for year = startYear, currentYear do
local e = pickNearestInYear(year, month, day)
if e then
table.insert(out, string.format(
'\n%d: week=%s, date=%s, song=%s, album=%s',
year,
tostring(e.week or ''),
tostring(e.date or ''),
tostring(e.no1song or ''),
tostring(e.no1album or '')
))
else
table.insert(out, string.format('\n%d: (no entry)', year))
end
end

return table.concat(out, '\n')
end

return p

Module:OnThisDay - Revision history

KWCBot: main(): accept month/day from direct #invoke frame args too (testing)