Module:CCI stats/sandbox

local TableTools = require("Module:TableTools"); local getArgs = require("Module:Arguments").getArgs;

local p = {}

--- Converts the stats date (days since 1 Jan 1970) into a human-readable -- date. -- @param date The date to convert function p._statsDateToDate(date) return mw.language.getContentLanguage :formatDate(os.date("%Y-%m-%d", date * 86400)) end

--- Extracts case open and close dates from wikitext. -- @param opens The table to append open dates to. -- @param opens The table to append close dates to. -- @param wikitext The wikitext to parse. function p._extractCaseDates(opens, closes, wikitext) for openDate in mw.ustring.gmatch(wikitext, "data%-cci%-open=['\"](.-)['\"]") do       table.insert(opens, tonumber(openDate)) end for closeDate in mw.ustring.gmatch(wikitext, "data%-cci%-close=['\"](.-)['\"]") do       table.insert(closes, tonumber(closeDate)) end

return opens, closes, wikitext end

--- Returns a tuple containing case dates, the first being all the dates where a -- case was opened, the second being all the dates where a case was closed. All -- dates are in stats format (i.e. days since the first day of the UNIX epoch, -- January 1, 1970). -- @param noArchive `true` to exclude counting archives. `closes` will be empty. function p._getCaseDates(noArchive) local frame = mw.getCurrentFrame local opens = {} local closes = {}

p._extractCaseDates(       opens, closes, frame:expandTemplate{ title = "CCIlist" }    )

if not noArchive then p._extractCaseDates(           opens, closes, frame:expandTemplate{ title = "Wikipedia:Contributor copyright investigations/Archive" }        ) end

table.sort(opens) table.sort(closes) return opens, closes end

--- Transforms a table of case opening and closing dates and returns a table -- of overall case count change for each day. This function will does not return -- any duplicate keys. function p._caseDatesToCaseNet(opens, closes) local caseNet = {}

for _, date in ipairs(opens) do       if not caseNet[date] then caseNet[date] = 1 else caseNet[date] = caseNet[date] + 1 end end

for _, date in ipairs(closes) do       if not caseNet[date] then caseNet[date] = -1 else caseNet[date] = caseNet[date] - 1 end end

return caseNet end

-- Gets case net change and count as tabulated data (wikitext) function p._caseCountToTabulatedRows(caseNet) local caseTable = mw.html.create("table") :addClass("wikitable") local caseCountRows = {} caseTable:node(		mw.html.create("tr")			:node( mw.html.create("th") :wikitext("Date") )			:node( mw.html.create("th") :wikitext("Total") )			:node( mw.html.create("th") :wikitext("Net") )	)

local lastValue = 0 for date, net in TableTools.sortedPairs(caseNet) do   	local newValue = lastValue + net local caseRow = mw.html.create("tr"); local caseDate = mw.html.create("td") :wikitext(p._statsDateToDate(date)); local caseCount = mw.html.create("td") :wikitext(newValue); local caseNet = mw.html.create("td") :css("color", net > 0 and "#006400" or (net < 0 and "#8b0000" or "inherit")) :css("font-weight", net > 2 and "bold" or "normal") :wikitext(net); caseRow :node(caseDate) :node(caseCount) :node(caseNet); caseTable:node(caseRow); lastValue = newValue end

return caseTable end

--- Transforms a table of case net dates and returns a table with date:caseCount -- pairs. function p._caseNetToDateCaseCounts(caseNet) local dateCaseCounts = {}

local lastValue = 0 for date, net in TableTools.sortedPairs(caseNet) do   	local newValue = lastValue + net dateCaseCounts[date] = newValue lastValue = newValue end

return dateCaseCounts end

--- Transforms date case counts to Vega data. function p._dateCaseCountsToVega(dateCaseCounts) local values = {}

for date, caseCount in TableTools.sortedPairs(dateCaseCounts) do       table.insert(values, {             -- Multiply by seconds in a day to get UNIX timestamp.            x = date * 86400000,            y = caseCount        }) end

return { data = { {           	name = "cases", values = values }       },        scales = { {               name = "date", type = "time", range = "width", domain = { data = "cases", field = "x" } },           {                name = "open-cases", range = "height", nice = true, domain = { data = "cases", field = "y" } }       },        axes = { { type = "x", scale = "date", title = "Date" }, { type = "y", scale = "open-cases", title = "Open cases" } },       marks = { {               type = "line", from = { data = "cases" }, properties = { enter = { x = { scale = "date", field = "x" }, y = { scale = "open-cases", field = "y" }, stroke = { value = "#652c90" } }               }            }        }    } end

--- Build a graph with the relevant data. local function buildGraph(frame, args, settings) local graphSettings = { version = "2", width = args.width or 1000, height = args.height or 300 }   local graphContent = TableTools.deepCopy(graphSettings) for k,v in TableTools.sortedPairs(settings) do graphContent[k] = v end

return frame:extensionTag{ name = "graph", content = mw.text.jsonEncode(           graphContent,            mw.text.JSON_PRETTY        ) } end

function p._graphCases(args) local opens, closes = p._getCaseDates(args.noArchive) local caseNet = p._caseDatesToCaseNet(opens, closes) local dateCaseCounts = p._caseNetToDateCaseCounts(caseNet) local vegaData = p._dateCaseCountsToVega(dateCaseCounts)

return buildGraph(args.frame, args.args, vegaData) end

function p.graphCases(frame) local args = getArgs(frame, {		trim = true,		removeBlanks = false	})

return p._graphCases{ frame = frame, args = args, from = args.from, upto = args.upto } end

-- Get raw Vega data function p.dumpCases(frame) local args = getArgs(frame, {		trim = true,		removeBlanks = false	})

local opens, closes = p._getCaseDates(args.noArchive) local caseNet = p._caseDatesToCaseNet(opens, closes) local dateCaseCounts = p._caseNetToDateCaseCounts(caseNet) return mw.text.jsonEncode(       p._dateCaseCountsToVega(dateCaseCounts),        mw.text.JSON_PRETTY    ) end

function p._tabulatedData(args) local opens, closes = p._getCaseDates(args.noArchive) local caseNet = p._caseDatesToCaseNet(opens, closes) return tostring(p._caseCountToTabulatedRows(caseNet)) end

function p.tabulatedData(frame) local args = getArgs(frame, {		trim = true,		removeBlanks = false	})

return p._tabulatedData{ frame = frame, args = args, from = args.from, upto = args.upto } end

function p._caseCount(args) local opens = p._getCaseDates(true) return tostring(#opens) end

function p.caseCount(frame) local args = getArgs(frame, {		trim = true,		removeBlanks = false	})

return p._caseCount{ frame = frame, args = args } end

return p