Module:TableTools - Revision history

Abinash: 41 revisions

2016-04-08T12:23:12Z

41 revisions

Abinash: 1 revision

2016-04-08T11:49:58Z

1 revision

Mr. Stradivarius: fix cleanPattern function - some of the character classes were still being magic even when they were inside the set, so escape them all

2014-05-25T14:11:02Z

fix cleanPattern function - some of the character classes were still being magic even when they were inside the set, so escape them all

New page

--[[
------------------------------------------------------------------------------------
-- TableTools --
-- --
-- This module includes a number of functions for dealing with Lua tables. --
-- It is a meta-module, meant to be called from other Lua modules, and should --
-- not be called directly from #invoke. --
------------------------------------------------------------------------------------
--]]

local libraryUtil = require('libraryUtil')

local p = {}

-- Define often-used variables and functions.
local floor = math.floor
local infinity = math.huge
local checkType = libraryUtil.checkType

--[[
------------------------------------------------------------------------------------
-- isPositiveInteger
--
-- This function returns true if the given value is a positive integer, and false
-- if not. Although it doesn't operate on tables, it is included here as it is
-- useful for determining whether a given table key is in the array part or the
-- hash part of a table.
------------------------------------------------------------------------------------
--]]
function p.isPositiveInteger(v)
if type(v) == 'number' and v >= 1 and floor(v) == v and v < infinity then
return true
else
return false
end
end

--[[
------------------------------------------------------------------------------------
-- isNan
--
-- This function returns true if the given number is a NaN value, and false
-- if not. Although it doesn't operate on tables, it is included here as it is
-- useful for determining whether a value can be a valid table key. Lua will
-- generate an error if a NaN is used as a table key.
------------------------------------------------------------------------------------
--]]
function p.isNan(v)
if type(v) == 'number' and tostring(v) == '-nan' then
return true
else
return false
end
end

--[[
------------------------------------------------------------------------------------
-- shallowClone
--
-- This returns a clone of a table. The value returned is a new table, but all
-- subtables and functions are shared. Metamethods are respected, but the returned
-- table will have no metatable of its own.
------------------------------------------------------------------------------------
--]]
function p.shallowClone(t)
local ret = {}
for k, v in pairs(t) do
ret[k] = v
end
return ret
end

--[[
------------------------------------------------------------------------------------
-- removeDuplicates
--
-- This removes duplicate values from an array. Non-positive-integer keys are
-- ignored. The earliest value is kept, and all subsequent duplicate values are
-- removed, but otherwise the array order is unchanged.
------------------------------------------------------------------------------------
--]]
function p.removeDuplicates(t)
checkType('removeDuplicates', 1, t, 'table')
local isNan = p.isNan
local ret, exists = {}, {}
for i, v in ipairs(t) do
if isNan(v) then
-- NaNs can't be table keys, and they are also unique, so we don't need to check existence.
ret[#ret + 1] = v
else
if not exists[v] then
ret[#ret + 1] = v
exists[v] = true
end
end
end
return ret
end

--[[
------------------------------------------------------------------------------------
-- numKeys
--
-- This takes a table and returns an array containing the numbers of any numerical
-- keys that have non-nil values, sorted in numerical order.
------------------------------------------------------------------------------------
--]]
function p.numKeys(t)
checkType('numKeys', 1, t, 'table')
local isPositiveInteger = p.isPositiveInteger
local nums = {}
for k, v in pairs(t) do
if isPositiveInteger(k) then
nums[#nums + 1] = k
end
end
table.sort(nums)
return nums
end

--[[
------------------------------------------------------------------------------------
-- affixNums
--
-- This takes a table and returns an array containing the numbers of keys with the
-- specified prefix and suffix. For example, for the table
-- {a1 = 'foo', a3 = 'bar', a6 = 'baz'} and the prefix "a", affixNums will
-- return {1, 3, 6}.
------------------------------------------------------------------------------------
--]]
function p.affixNums(t, prefix, suffix)
checkType('affixNums', 1, t, 'table')
checkType('affixNums', 2, prefix, 'string', true)
checkType('affixNums', 3, suffix, 'string', true)

local function cleanPattern(s)
-- Cleans a pattern so that the magic characters ()%.[]*+-?^$ are interpreted literally.
s = s:gsub('([%(%)%%%.%[%]%*%+%-%?%^%$])', '%%%1')
return s
end

prefix = prefix or ''
suffix = suffix or ''
prefix = cleanPattern(prefix)
suffix = cleanPattern(suffix)
local pattern = '^' .. prefix .. '([1-9]%d*)' .. suffix .. '$'

local nums = {}
for k, v in pairs(t) do
if type(k) == 'string' then
local num = mw.ustring.match(k, pattern)
if num then
nums[#nums + 1] = tonumber(num)
end
end
end
table.sort(nums)
return nums
end

--[[
------------------------------------------------------------------------------------
-- numData
--
-- Given a table with keys like ("foo1", "bar1", "foo2", "baz2"), returns a table
-- of subtables in the format
-- { [1] = {foo = 'text', bar = 'text'}, [2] = {foo = 'text', baz = 'text'} }
-- Keys that don't end with an integer are stored in a subtable named "other".
-- The compress option compresses the table so that it can be iterated over with
-- ipairs.
------------------------------------------------------------------------------------
--]]
function p.numData(t, compress)
checkType('numData', 1, t, 'table')
checkType('numData', 2, compress, 'boolean', true)
local ret = {}
for k, v in pairs(t) do
local prefix, num = mw.ustring.match(tostring(k), '^([^0-9]*)([1-9][0-9]*)$')
if num then
num = tonumber(num)
local subtable = ret[num] or {}
if prefix == '' then
-- Positional parameters match the blank string; put them at the start of the subtable instead.
prefix = 1
end
subtable[prefix] = v
ret[num] = subtable
else
local subtable = ret.other or {}
subtable[k] = v
ret.other = subtable
end
end
if compress then
local other = ret.other
ret = p.compressSparseArray(ret)
ret.other = other
end
return ret
end

--[[
------------------------------------------------------------------------------------
-- compressSparseArray
--
-- This takes an array with one or more nil values, and removes the nil values
-- while preserving the order, so that the array can be safely traversed with
-- ipairs.
------------------------------------------------------------------------------------
--]]
function p.compressSparseArray(t)
checkType('compressSparseArray', 1, t, 'table')
local ret = {}
local nums = p.numKeys(t)
for _, num in ipairs(nums) do
ret[#ret + 1] = t[num]
end
return ret
end

--[[
------------------------------------------------------------------------------------
-- sparseIpairs
--
-- This is an iterator for sparse arrays. It can be used like ipairs, but can
-- handle nil values.
------------------------------------------------------------------------------------
--]]
function p.sparseIpairs(t)
checkType('sparseIpairs', 1, t, 'table')
local nums = p.numKeys(t)
local i = 0
local lim = #nums
return function ()
i = i + 1
if i <= lim then
local key = nums[i]
return key, t[key]
else
return nil, nil
end
end
end

--[[
------------------------------------------------------------------------------------
-- size
--
-- This returns the size of a key/value pair table. It will also work on arrays,
-- but for arrays it is more efficient to use the # operator.
------------------------------------------------------------------------------------
--]]
function p.size(t)
checkType('size', 1, t, 'table')
local i = 0
for k in pairs(t) do
i = i + 1
end
return i
end

return p

Mr. Stradivarius: escape prefix and suffix strings in affixNums so that magic characters are interpreted literally

2013-12-27T05:57:19Z

escape prefix and suffix strings in affixNums so that magic characters are interpreted literally

Mr. Stradivarius: add p.numData function

2013-12-27T05:13:33Z

add p.numData function

Mr. Stradivarius: sparseIpairs: return nil explicitly if i > lim

2013-12-24T23:47:45Z

sparseIpairs: return nil explicitly if i > lim

Mr. Stradivarius: Protected Module:TableTools: High-risk Lua module ([Edit=Allow only template editors and admins] (indefinite) [Move=Allow only template editors and admins] (indefinite))

2013-12-20T06:14:43Z

Protected Module:TableTools: High-risk Lua module ([Edit=Allow only template editors and admins] (indefinite) [Move=Allow only template editors and admins] (indefinite))

Mr. Stradivarius: split set functions out to Module:Set

2013-12-20T05:46:35Z

split set functions out to Module:Set

Show changes

Mr. Stradivarius: reinstate shallowClone - saw a use for it in p.complement - and write p.valueComplement

2013-12-20T01:51:19Z

reinstate shallowClone - saw a use for it in p.complement - and write p.valueComplement

Mr. Stradivarius: better error message for the set functions

2013-12-20T01:17:23Z

better error message for the set functions

@@ Line 93: / Line 93: @@
 	local lim = select('#', ...)
 	if lim < 2 then
-		error(lim .. ' argument' .. (lim == 1 and '' or 's') .. " passed to 'union' (minimum is 2)", 2)
+		error("too few arguments to 'union' (minimum is 2, received " .. lim .. ')', 2)
 	end
 	local ret, trackArrays = {}, {}
@@ Line 139: / Line 139: @@
 	local lim = select('#', ...)
 	if lim < 2 then
-		error(lim .. ' argument' .. (lim == 1 and '' or 's') .. " passed to 'valueUnion' (minimum is 2)", 2)
+		error("too few arguments to 'valueUnion' (minimum is 2, received " .. lim .. ')', 2)
 	end
 	local isNan = p.isNan
@@ Line 169: / Line 169: @@
 	local lim = select('#', ...)
 	if lim < 2 then
-		error(lim .. ' argument' .. (lim == 1 and '' or 's') .. " passed to 'intersection' (minimum is 2)", 2)
+		error("too few arguments to 'intersection' (minimum is 2, received " .. lim .. ')', 2)
 	end
 	local ret, track, pairCounts = {}, {}, {}
@@ Line 205: / Line 205: @@
 	local lim = select('#', ...)
 	if lim < 2 then
-		error(lim .. ' argument' .. (lim == 1 and '' or 's') .. " passed to 'valueIntersection' (minimum is 2)", 2)
+		error("too few arguments to 'valueIntersection' (minimum is 2, received " .. lim .. ')', 2)
 	end
 	local isNan = p.isNan
@@ Line 255: / Line 255: @@
 	local lim = select('#', ...)
 	if lim < 2 then
-		error(lim .. ' argument' .. (lim == 1 and '' or 's') .. " passed to 'complement' (minimum is 2)", 2)
+		error("too few arguments to 'complement' (minimum is 2, received " .. lim .. ')', 2)
 	end
 	--[[

@@ Line 136: / Line 136: @@
 	local function cleanPattern(s)
 		-- Cleans a pattern so that the magic characters ()%.[]*+-?^$ are interpreted literally.
-		s = s:gsub('([()%%.%[%]*+-?^$])', '%%%1')
+		s = s:gsub('([%(%)%%%.%[%]%*%+%-%?%^%$])', '%%%1')
 		return s
 	end

← Older revision	Revision as of 11:49, 8 April 2016
(No difference)

@@ Line 133: / Line 133: @@
 	checkType('affixNums', 2, prefix, 'string', true)
 	checkType('affixNums', 3, suffix, 'string', true)
 	prefix = prefix or ''
 	suffix = suffix or ''
 	local pattern = '^' .. prefix .. '([1-9]%d*)' .. suffix .. '$'
 	local nums = {}
 	for k, v in pairs(t) do

@@ Line 147: / Line 147: @@
 	table.sort(nums)
 	return nums
 end

@@ Line 186: / Line 186: @@
 			local key = nums[i]
 			return key, t[key]
 		end
 	end

← Older revision	Revision as of 06:14, 20 December 2013
(No difference)

@@ Line 52: / Line 52: @@
 		return false
 	end
 end
@@ Line 264: / Line 281: @@
 	local tn = select(lim, ...)
 	checkType('complement', lim, tn, 'table')
-	local ret = {}
+	local ret = p.shallowClone(tn)
-	for k, v in pairs(tn) do
-		ret[k] = v
-	end
 	-- Remove all the key/value pairs in t1, t2, ..., tn-1.
 	for i = 1, lim - 1 do
@@ Line 276: / Line 290: @@
 				ret[k] = nil
 			end
 		end
 	end