1,506
edits
m (joinList: Minor optimisation) |
(Issue finally found...) |
||
(27 intermediate revisions by 4 users not shown) | |||
Line 1: | Line 1: | ||
-- Module that contains all functions regarding numeric formatting and calculations. | |||
-- TODO: Make modules that now call Shared call Number (for relevant functions) | |||
local numModule = require('Module:Number') | |||
--So there are a handful of functions that I'm using in a lot of places | --So there are a handful of functions that I'm using in a lot of places | ||
--So rather than continue to copy across the same handful of functions to every single new module | --So rather than continue to copy across the same handful of functions to every single new module | ||
Line 13: | Line 17: | ||
local p = {} | local p = {} | ||
-- iterator sorted by keys | -- iterator sorted by keys | ||
-- For example, if you had a table that looked something like | -- For example, if you had a table that looked something like | ||
Line 25: | Line 29: | ||
--Originally snagged this from Module:VoidByReward written by User:NoBrainz | --Originally snagged this from Module:VoidByReward written by User:NoBrainz | ||
function p.skpairs(t, revert) | function p.skpairs(t, revert) | ||
local keys = {} | |||
for k in pairs(t) do keys[#keys + 1] = k end | |||
if revert ~= nil then | |||
table.sort(keys, function(a, b) return a > b end) | |||
else | |||
table.sort(keys) | |||
end | |||
local i = 0 | |||
local iterator = function() | |||
i = i + 1 | |||
local key = keys[i] | |||
if key then | |||
return key, t[key] | |||
else | |||
return nil | |||
end | |||
end | |||
return iterator | |||
end | |||
-- Function to sort a dictionary-like structure where items are added like tbl['key'] = value | |||
-- We need to turn this structure into a table first, in order to sort it. | |||
function p.sortDictionary(dict, comparer) | |||
local sortedTable = {} | |||
for k, v in pairs(dict) do | |||
table.insert(sortedTable, {key = k, value = v}) | |||
end | end | ||
return | |||
table.sort(sortedTable, comparer) | |||
return sortedTable | |||
end | end | ||
--General purpose function for going through a table after sorting based on a custom sort order | --General purpose function for going through a table after sorting based on a custom sort order | ||
--Taken from https://stackoverflow.com/questions/15706270/sort-a-table-in-lua | --Taken from https://stackoverflow.com/questions/15706270/sort-a-table-in-lua | ||
function p.spairs(t, order) | function p.spairs(t, order) | ||
-- collect the keys | |||
local keys = {} | |||
for k in pairs(t) do keys[#keys+1] = k end | |||
-- if order function given, sort by it by passing the table and keys a, b, | |||
-- otherwise just sort the keys | |||
if order then | |||
table.sort(keys, function(a,b) return order(t, a, b) end) | |||
else | |||
table.sort(keys) | |||
end | |||
-- return the iterator function | |||
local i = 0 | |||
return function() | |||
i = i + 1 | |||
if keys[i] then | |||
return keys[i], t[keys[i]] | |||
end | |||
end | |||
end | end | ||
-- | -- Takes an input string and returns the same string with title case-like | ||
-- | -- formatting (that is, the first letter of every word becomes uppercase, | ||
-- while the remainder becomes lowercase) | |||
-- Examples: | |||
-- titleCase('ALL CAPS') = 'All Caps' | |||
-- titleCase('all lowercase') = 'All Lowercase' | |||
-- titleCase('A MiXTUre') = 'A Mixture' | |||
-- Note that non-alphanumeric characters are treated as a word boundary, so: | |||
-- titleCase('a!b(c)d') = 'A!B(C)D' (not 'A!b(c)d') | |||
--Originally snagged this from Module:VoidByReward written by User:NoBrainz | --Originally snagged this from Module:VoidByReward written by User:NoBrainz | ||
function p.titleCase(head, tail) | function p.titleCase(head, tail) | ||
if tail == nil then | |||
--Split into two lines because don't want the other return from gsub | |||
local result = string.gsub(head, "(%a)([%w_']*)", p.titleCase) | |||
return result | |||
else | |||
return string.upper(head) .. string.lower(tail) | |||
end | |||
end | end | ||
-- Returns the number of rows in a table | -- Returns the number of rows in a table | ||
-- Originally snagged this from Module:VoidByReward written by User:NoBrainz | -- Originally snagged this from Module:VoidByReward written by User:NoBrainz | ||
Line 97: | Line 121: | ||
-- if table is not of type 'table' then return nil | -- if table is not of type 'table' then return nil | ||
function p.tableCount(table) | function p.tableCount(table) | ||
if (type(table) == 'table') then | |||
local count = 0 | |||
for _ in pairs(table) do count = count + 1 end | |||
return count | |||
else | |||
return nil | |||
end | |||
end | |||
-- Returns true if the table is empty, false otherwise | |||
function p.tableIsEmpty(table) | |||
if type(table) == 'table' then | |||
for k, v in pairs(table) do | |||
return false | |||
end | |||
return true | |||
else | |||
return nil | |||
end | |||
end | end | ||
-- Returns the number of indexed elements in a table | -- Returns the number of indexed elements in a table | ||
-- pre : table is a table with no explicit nil values | -- pre : table is a table with no explicit nil values | ||
Line 111: | Line 147: | ||
-- if table is not of type 'table' then return nil | -- if table is not of type 'table' then return nil | ||
function p.indexCount(table) | function p.indexCount(table) | ||
if (type(table) == 'table') then | |||
local count = 0 | |||
for _ in ipairs(table) do count = count + 1 end | |||
return count | |||
else | |||
return nil | |||
end | |||
end | end | ||
--Sorts theTable based on the listed column | --Sorts theTable based on the listed column | ||
function p.tableSort(theTable, sortCol, ascend) | function p.tableSort(theTable, sortCol, ascend) | ||
local sorter = function(r1, r2) | |||
if ascend then | |||
return r1[sortCol] < r2[sortCol] | |||
else | |||
return r1[sortCol] > r2[sortCol] | |||
end | |||
end | |||
table.sort(theTable, sorter) | |||
end | end | ||
--Splits a string based on a sent in separating character | --- Splits a string based on a sent in separating character | ||
--For example calling splitString ("Lith V1 Relic", " ") would return {"Lith", "V1", "Relic"} | --- For example calling splitString ("Lith V1 Relic", " ") would return {"Lith", "V1", "Relic"} | ||
function p.splitString(inputstr, sep) | -- @param inputstr (string) The input to separate. | ||
-- @param sep (string/char) The separation character. | |||
-- @param trim (boolean) TRUE to trim the leading/trailing whitespaces | |||
function p.splitString(inputstr, sep, trim) | |||
if sep == nil then | |||
sep = "%s" | |||
end | |||
local t = {} | |||
for str in string.gmatch(inputstr, "([^"..sep.."]+)") do | |||
if trim == true then | |||
str = str:gsub("^%s*(.-)%s*$", "%1") | |||
end | |||
table.insert(t, str) | |||
end | |||
return t | |||
end | end | ||
--Returns 'true' if a string starts with something | --Returns 'true' if a string starts with something | ||
--For example calling startsWith ("Lith V1 Relic", "Lith") would return true | --For example calling startsWith ("Lith V1 Relic", "Lith") would return true | ||
function p.startsWith(string1, start) | function p.startsWith(string1, start) | ||
return string.sub(string1, 1, string.len(start)) == start | |||
end | end | ||
--Adds commas | --Adds commas | ||
function p.formatnum(number) | function p.formatnum(number) | ||
return numModule.formatnum(number) | |||
end | |||
function p.formatNumber(frame) | |||
local number = frame.args ~= nil and frame.args[1] or frame | |||
return p.formatnum(number) | |||
end | end | ||
function p.round(val, maxDigits, minDigits) | function p.round(val, maxDigits, minDigits) | ||
return numModule.round(val, maxDigits, minDigits) | |||
end | end | ||
--From http://lua-users.org/wiki/SimpleRound | --From http://lua-users.org/wiki/SimpleRound | ||
function p.round2(num, numDecimalPlaces) | function p.round2(num, numDecimalPlaces) | ||
return numModule.round2(num, numDecimalPlaces) | |||
end | end | ||
-- pre : List is a table or a string | -- pre : List is a table or a string | ||
-- Item is the element that is being searched | -- Item is the element that is being searched | ||
Line 198: | Line 217: | ||
-- post: returns a boolean; true if element exists in List, false otherwise | -- post: returns a boolean; true if element exists in List, false otherwise | ||
function p.contains(List, Item, IgnoreCase) | function p.contains(List, Item, IgnoreCase) | ||
if List == nil or Item == nil then | |||
return false | |||
end | |||
if IgnoreCase == nil then | |||
IgnoreCase = false | |||
end | |||
if type(List) == "table" then | |||
for key, value in pairs(List) do | |||
if value == Item then | |||
return true, key | |||
elseif IgnoreCase and string.upper(value) == string.upper(Item) then | |||
return true, key | |||
end | |||
end | |||
else | |||
local start = string.find(List, Item) | |||
return start ~= nil | |||
end | |||
return false | |||
end | end | ||
Line 234: | Line 253: | ||
--User:Giga Martin | --User:Giga Martin | ||
function p.trim(str) | function p.trim(str) | ||
return (str:gsub("^%s*(.-)%s*$", "%1")) | |||
end | end | ||
Line 246: | Line 265: | ||
-- if key contains a nil value | -- if key contains a nil value | ||
function p.hasKey(table, key, length) | function p.hasKey(table, key, length) | ||
if (length == nil) then | |||
length = p.tableCount(table) | |||
end | |||
-- iterating through outer table | |||
for i = 1, length, 1 do | |||
local elem = table[i] -- storing one of inner tables into a variable | |||
if (elem[key] ~= nil) then | |||
return true | |||
end | |||
end | |||
return false | |||
end | end | ||
-- copies the contents of a variable; handy for when you might want to modify an object taken from a data file | -- copies the contents of a variable; handy for when you might want to modify an object taken from a data file | ||
-- or any other read-only variable | -- or any other read-only variable | ||
-- Stolen from https://gist.github.com/tylerneylon/81333721109155b2d244 | -- Stolen from https://gist.github.com/tylerneylon/81333721109155b2d244 | ||
function p.clone(obj) | function p.clone(obj) | ||
if type(obj) ~= 'table' then return obj end | |||
local res = {} | |||
for k, v in pairs(obj) do res[p.clone(k)] = p.clone(v) end | |||
return res | |||
end | |||
-- Shallow clone, desirable when operations such as sorting are to be performed | |||
-- on a table where it is not necessary to perform a deep clone of all data within | |||
-- the table's elements | |||
function p.shallowClone(obj) | |||
if type(obj) ~= 'table' then return obj end | |||
local res = {} | |||
for k, v in pairs(obj) do | |||
res[k] = v | |||
end | |||
return res | |||
end | end | ||
-- Euclidean Greatest Common Divisor algorithm | -- Euclidean Greatest Common Divisor algorithm | ||
function p.gcd(a, b) | function p.gcd(a, b) | ||
return numModule.gcd(a, b) | |||
end | end | ||
--Formats a pair of numbers as a reduced fraction | --Formats a pair of numbers as a reduced fraction | ||
function p.fraction(n, d) | function p.fraction(n, d) | ||
return numModule.fraction(n, d) | |||
end | |||
--Similar to p.fraction but returns the simplified numerator and denomerator separately without formatting | |||
function p.fractionpair(n, d) | |||
return numModule.fractionpair(n, d) | |||
end | end | ||
function p.timeString(timeInSeconds, shorten) | function p.timeString(timeInSeconds, shorten) | ||
local remain = timeInSeconds | |||
local days, hours, minutes = 0, 0, 0 | |||
local isShort = shorten | |||
local pieces = {} | |||
if remain >= 86400 then | |||
days = math.floor(remain / 86400) | |||
remain = remain - days * 86400 | |||
if isShort then | |||
table.insert(pieces, days..'d') | |||
elseif days > 1 then | |||
table.insert(pieces, days..' days') | |||
else | |||
table.insert(pieces, days..' day') | |||
end | |||
end | |||
if remain >= 3600 then | |||
hours = math.floor(remain / 3600) | |||
remain = remain - hours * 3600 | |||
if isShort then | |||
table.insert(pieces, hours..'h') | |||
elseif hours > 1 then | |||
table.insert(pieces, hours..' hours') | |||
else | |||
table.insert(pieces, hours..' hour') | |||
end | |||
end | |||
if remain >= 60 then | |||
minutes = math.floor(remain / 60) | |||
remain = remain - minutes * 60 | |||
if isShort then | |||
table.insert(pieces, minutes..'m') | |||
elseif minutes > 1 then | |||
table.insert(pieces, minutes..' minutes') | |||
else | |||
table.insert(pieces, minutes..' minutes') | |||
end | |||
end | |||
if remain > 0 then | |||
if isShort then | |||
table.insert(pieces, remain..'s') | |||
elseif remain > 1 then | |||
table.insert(pieces, remain..' seconds') | |||
else | |||
table.insert(pieces, remain..' second') | |||
end | |||
end | |||
return table.concat(pieces, ', ') | |||
end | end | ||
function p.fixPagename(pageName) | function p.fixPagename(pageName) | ||
local result = pageName | |||
result = string.gsub(result, "%%27", "'") | |||
result = string.gsub(result, "'", "'") | |||
result = string.gsub(result, "&", "&") | |||
return result | |||
end | end | ||
--Checks if two tables contain the same value with the same indices | --Checks if two tables contain the same value with the same indices | ||
function p.tablesEqual(t1, t2) | function p.tablesEqual(t1, t2) | ||
if p.tableCount(t1) ~= p.tableCount(t2) then return false end | |||
for i, val in p.skpairs(t1) do | |||
if type(val) ~= type(t2[i]) then | |||
return false | |||
elseif type(val) == 'table' then | |||
if not p.tablesEqual(val, t2[i]) then return false end | |||
elseif t2[i] ~= val then | |||
return false | |||
end | |||
end | |||
return true | |||
end | end | ||
--Returns a number including the sign, even if positive | --Returns a number including the sign, even if positive | ||
function p.numStrWithSign(number) | function p.numStrWithSign(number) | ||
return numModule.numStrWithSign(number) | |||
return ' | end | ||
-- Applies formatting to an error message for display on wiki pages. | |||
-- Also appends a category such that errors can be easily located | |||
function p.printError(message) | |||
-- Prevent message being interpreted as wikitext and handle non-string messages | |||
local messageString = mw.text.nowiki(type(message) == 'string' and message or mw.dumpObject(message)) | |||
return '[[Category:Pages with script errors]]<div class="text-negative">ERROR: ' .. messageString .. '</div>' | |||
end | |||
-- Takes a description template & template data, returning a description with variables populated | |||
function p.applyTemplateData(descTemplate, templateData) | |||
local resultDesc = descTemplate | |||
for k, v in pairs(templateData) do | |||
local val = v | |||
if type(v) == 'number' then | |||
val = p.formatnum(val) | |||
end | |||
resultDesc = string.gsub(resultDesc, '${' .. k .. '}', val) | |||
end | |||
return resultDesc | |||
end | |||
-- Given a namespace & local ID, returns a namespaced ID | |||
function p.getNamespacedID(namespace, localID) | |||
if string.find(localID, ':') == nil then | |||
return namespace .. ':' .. localID | |||
else | |||
-- ID already appears to be namespaced | |||
return localID | |||
end | |||
end | |||
-- Given a namespaced ID, returns both the namespace & local ID | |||
function p.getLocalID(ID) | |||
local namespace, localID = nil, nil | |||
local sepIdx = string.find(ID, ':') | |||
if sepIdx == nil then | |||
-- Provided ID doesn't appear to be namespaced | |||
localID = ID | |||
else | |||
namespace = string.sub(ID, 1, sepIdx - 1) | |||
localID = string.sub(ID, sepIdx + 1, string.len(ID)) | |||
end | |||
return namespace, localID | |||
end | end | ||
-- | -- Compares two strings, optionally ignoring case | ||
-- | function p.compareString(left, right, ignoreCase) | ||
-- | -- Both are nil (equal) | ||
function p. | if left == nil and right == nil then return true end | ||
-- Only one is nil (not equal) | |||
if left == nil or right == nil then return false end | |||
-- Convert inputs to strings, just in case | |||
left = tostring(left) | |||
right = tostring(right) | |||
if ignoreCase == true then | |||
return left:upper() == right:upper() | |||
else | |||
return left == right | |||
end | |||
end | |||
function p._replace(str, searchTerm, replacementTerm) | |||
if str == nil then | |||
return str | |||
end | |||
local escapedSearch = searchTerm:gsub("[%^%$%(%)%%%.%[%]%*%+%-%?]", "%%%1") | |||
local result = str:gsub(escapedSearch, replacementTerm) | |||
return result | |||
end | |||
function p.replace(frame) | |||
local args = frame:getParent().args | |||
return p._replace( | |||
frame.args[1], | |||
frame.args[2] or '', | |||
frame.args[3] or '') | |||
end | end | ||
return p | return p |
edits