Version 2.2.2

- The old functionality of lume.merge() is now spread across
  lume.merge() (for tables) and lume.concat() (for arrays). Both these
  functions create new tables rather than operating in-place
- Changed lume.fn() to use lume.concat() internally

.gitignore

@@ -1,3 +0,0 @@
-__*
-*.tmp
-*.swp

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2014, rxi
+Copyright (c) 2015, rxi
 
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of

README.md

@@ -74,8 +74,50 @@ lume.weightedchoice({ ["cat"] = 10, ["dog"] = 5, ["frog"] = 0 })
 -- Returns either "cat" or "dog" with "cat" being twice as likely to be chosen.
 ```
 
+### lume.push(t, ...)
+Pushes all the given values to the end of the table `t` and returns the pushed
+values. Nil values are ignored.
+```lua
+local t = { 1, 2, 3 }
+lume.push(t, 4, 5) -- `t` becomes { 1, 2, 3, 4, 5 }
+```
+
+### lume.remove(t, x)
+Removes the first instance of the value `x` if it exists in the table `t`.
+Returns `x`.
+```lua
+local t = { 1, 2, 3 }
+lume.remove(t, 2) -- `t` becomes { 1, 3 }
+```
+
+### lume.clear(t)
+Nils all the values in the table `t`, this renders the table empty. Returns
+`t`.
+```lua
+local t = { 1, 2, 3 }
+lume.clear(t) -- `t` becomes {}
+```
+
+### lume.extend(t, ...)
+Copies all the fields from the source tables to the table `t` and returns `t`.
+If a key exists in multiple tables the right-most table's value is used.
+```lua
+local t = { a = 1, b = 2 }
+lume.extend(t, { b = 4, c = 6 }) -- `t` becomes { a = 1, b = 4, c = 6 }
+```
+
 ### lume.shuffle(t)
-Shuffles the values of array `t` in place, returns the array.
+Returns a shuffled copy of the array `t`.
+
+### lume.sort(t [, comp])
+Returns a copy of the array `t` with all its items sorted. If `comp` is a
+function it will be used to compare the items when sorting. If `comp` is a
+string it will be used as the key to sort the items by.
+```lua
+lume.sort({ 1, 4, 3, 2, 5 }) -- Returns { 1, 2, 3, 4, 5 }
+lume.sort({ {z=2}, {z=3}, {z=1} }, "z") -- Returns { {z=1}, {z=2}, {z=3} }
+lume.sort({ 1, 3, 2 }, function(a, b) return a > b end) -- Returns { 3, 2, 1 }
+```
 
 ### lume.array(...)
 Iterates the supplied iterator and returns an array filled with the values.
@@ -125,10 +167,8 @@ an error is raised,
 lume.reduce({1, 2, 3}, function(a, b) return a + b end) -- Returns 6
 ```
 
-### lume.set(t [, retainkeys])
-Returns a copy of the `t` table with all the duplicate values removed. If
-`retainkeys` is true the table is not treated as an array and retains its
-original keys.
+### lume.set(t)
+Returns a copy of the `t` array with all the duplicate values removed. 
 ```lua
 lume.set({2, 1, 2, "cat", "cat"}) -- Returns {1, 2, "cat"}
 ```
@@ -141,12 +181,25 @@ an array and retains its original keys.
 lume.filter({1, 2, 3, 4}, function(x) return x % 2 == 0 end) -- Returns {2, 4}
 ```
 
-### lume.merge(t, t2 [, retainkeys])
-Merges all the values from the table `t2` into `t` in place. If `retainkeys` is
-true the table is not treated as an array and retains its original keys; if `t`
-and `t2` have a conflicting key, the value from `t2` is used.
+### lume.reject(t, fn [, retainkeys])
+The opposite of `lume.filter()`: Calls `fn` on each value of `t` table; returns
+a new table with only the values where `fn` returned false. If `retainkeys` is
+true the table is not treated as an array and retains its original keys.
 ```lua
-lume.merge({2, 3}, {4, 5}) -- Returns {2, 3, 4, 5}
+lume.reject({1, 2, 3, 4}, function(x) return x % 2 == 0 end) -- Returns {1, 3}
+```
+
+### lume.merge(...)
+Returns a new table with all the given tables merged together. If a key exists
+in multiple tables the right-most table's value is used.
+```lua
+lume.merge({a=1, b=2, c=3}, {c=8, d=9}) -- Returns {a=1, b=2, c=8, d=9}
+```
+
+### lume.concat(...)
+Returns a new array consisting of all the given arrays concatenated into one.
+```lua
+lume.concat({1, 2}, {3, 4}, {5, 6}) -- Returns {1, 2, 3, 4, 5, 6}
 ```
 
 ### lume.find(t, value)
@@ -199,6 +252,12 @@ values the keys.
 lume.invert({a = "x", b = "y"}) -- returns {x = "a", y = "b"}
 ```
 
+### lume.pick(t, ...)
+Returns a copy of the table filtered to only contain values for the given keys.
+```lua
+lume.pick({ a = 1, b = 2, c = 3 }, "a", "c") -- Returns { a = 1, c = 3 }
+```
+
 ### lume.keys(t)
 Returns an array containing each key of the table.
 
@@ -244,6 +303,13 @@ local f = lume.combine(function(a, b) print(a + b) end,
 f(3, 4) -- Prints "7" then "12" on a new line
 ```
 
+### lume.call(fn, ...)
+Calls the given function with the provided arguments and returns its values. If
+`fn` is `nil` then no action is performed and the function returns `nil`.
+```lua
+lume.call(print, "Hello world") -- Prints "Hello world"
+```
+
 ### lume.time(fn, ...)
 Inserts the arguments into function `fn` and calls it. Returns the time in
 seconds the function `fn` took to execute followed by `fn`'s returned values.
@@ -263,7 +329,7 @@ f(10, 5) -- Returns 25
 ### lume.serialize(x)
 Serializes the argument `x` into a string which can be loaded again using
 `lume.deserialize()`. Only booleans, numbers, tables and strings can be
-serialized. Circular references are not handled; all nested tables are
+serialized. Circular references will result in an error; all nested tables are
 serialized as unique tables.
 ```lua
 lume.serialize({a = "test", b = {1, 2, 3}, false})
@@ -294,6 +360,15 @@ instead of whitespace.
 lume.trim("  Hello  ") -- Returns "Hello"
 ```
 
+### lume.wordwrap(str [, limit])
+Returns `str` wrapped to `limit` number of characters per line, by default
+`limit` is `72`. `limit` can also be a function which when passed a string,
+returns `true` if it is too long for a single line.
+```lua
+-- Returns "Hello world\nThis is a\nshort string"
+lume.wordwrap("Hello world. This is a short string", 14)
+```
+
 ### lume.format(str [, vars])
 Returns a formatted string. The values of keys in the table `vars` can be
 inserted into the string by using the form `"{key}"` in `str`; numerical keys
@@ -308,7 +383,7 @@ Prints the current filename and line number followed by each argument separated
 by a space.
 ```lua
 -- Assuming the file is called "example.lua" and the next line is 12:
-lume.trace("hello", 1234) -- Prints "[example.lua:12] hello 1234"
+lume.trace("hello", 1234) -- Prints "example.lua:12: hello 1234"
 ```
 
 ### lume.dostring(str)
@@ -332,6 +407,28 @@ lume.hotswap("lume") -- Reloads the lume module
 assert(lume.hotswap("inexistant_module")) -- Raises an error
 ```
 
+### lume.ripairs(t)
+Performs the same function as `ipairs()` but iterates in reverse; this allows
+the removal of items from the table during iteration without any items being
+skipped.
+```lua
+-- Prints "3->c", "2->b" and "1->a" on separate lines
+for i, v in lume.ripairs({ "a", "b", "c" }) do
+  print(i .. "->" .. v)
+end
+```
+
+### lume.color(str [, mul])
+Takes color string `str` and returns 4 values, one for each color channel (`r`,
+`g`, `b` and `a`). By default the returned values are between 0 and 1; the
+values are multiplied by the number `mul` if it is provided.
+```lua
+lume.color("#ff0000")               -- Returns 1, 0, 0, 1
+lume.color("rgba(255, 0, 255, .5)") -- Returns 1, 0, 1, .5
+lume.color("#00ffff", 256)          -- Returns 0, 256, 256, 256
+lume.color("rgb(255, 0, 0)", 256)   -- Returns 256, 0, 0, 256
+```
+
 ### lume.rgba(color)
 Takes the 32bit integer `color` argument and returns 4 numbers, one for each
 channel, with a range of 0 - 255. The returned values can be used as the
@@ -356,6 +453,36 @@ as calling `lume.chain()`.
 lume({1, 2, 3}):each(print) -- Prints 1, 2 then 3 on separate lines
 ```
 
+## Iteratee functions
+Several lume functions allow a `table`, `string` or `nil` to be used in place
+of their iteratee function argument. The functions that provide this behaviour
+are: `map()`, `all()`, `any()`, `filter()`, `reject()`, `match()` and
+`count()`.
+
+If the argument is `nil` then each value will return itself.
+```lua
+lume.filter({ true, true, false, true }, nil) -- { true, true, true }
+```
+
+If the argument is a `string` then each value will be assumed to be a table,
+and will return the value of the key which matches the string.
+``` lua
+local t = {{ z = "cat" }, { z = "dog" }, { z = "owl" }}
+lume.map(t, "z") -- Returns { "cat", "dog", "owl" }
+```
+
+If the argument is a `table` then each value will return `true` or `false`,
+depending on whether the values at each of the table's keys match the
+collection's value's values.
+```lua
+local t = {
+  { age = 10, type = "cat" },
+  { age = 8,  type = "dog" },
+  { age = 10, type = "owl" },
+}
+lume.count(t, { age = 10 }) -- returns 2
+```
+
 
 ## License
 

lume.lua

@@ -1,13 +1,13 @@
 --
 -- lume
 --
--- Copyright (c) 2014, rxi
+-- Copyright (c) 2015 rxi
 --
 -- This library is free software; you can redistribute it and/or modify it
 -- under the terms of the MIT license. See LICENSE for details.
 --
 
-local lume = { _version = "1.5.0" }
+local lume = { _version = "2.2.2" }
 
 local pairs, ipairs = pairs, ipairs
 local type, assert, unpack = type, assert, unpack or table.unpack
@@ -16,11 +16,18 @@ local math_floor = math.floor
 local math_ceil = math.ceil
 local math_random = math.random
 local math_cos = math.cos
-local math_atan2 = math.atan2
+local math_atan2 = math.atan2 or math.atan
 local math_sqrt = math.sqrt
 local math_abs = math.abs
 local math_pi = math.pi
 
+local noop = function()
+end
+
+local identity = function(x)
+  return x
+end
+
 local patternescape = function(str)
   return str:gsub("[%(%)%.%%%+%-%*%?%[%]%^%$]", "%%%1")
 end
@@ -35,8 +42,17 @@ local iscallable = function(x)
   return mt and mt.__call ~= nil
 end
 
-local identity = function(x)
-  return x
+local isarray = function(x)
+  return (type(x) == "table" and x[1] ~= nil) and true or false
+end
+
+local getiter = function(x)
+  if isarray(x) then
+    return ipairs
+  elseif type(x) == "table" then
+    return pairs
+  end
+  error("expected table", 3)
 end
 
 local iteratee = function(x)
@@ -62,7 +78,7 @@ end
 
 function lume.round(x, increment)
   if increment then return lume.round(x / increment) * increment end
-  return x > 0 and math_floor(x + .5) or math_ceil(x - .5)
+  return x >= 0 and math_floor(x + .5) or math_ceil(x - .5)
 end
 
 
@@ -128,15 +144,82 @@ function lume.weightedchoice(t)
 end
 
 
-function lume.shuffle(t)
-  for i = 1, #t do
-    local r = math_random(#t)
-    t[i], t[r] = t[r], t[i]
+function lume.push(t, ...)
+  local n = select("#", ...)
+  for i = 1, n do
+    t[#t + 1] = select(i, ...)
+  end
+  return ...
+end
+
+
+function lume.remove(t, x) 
+  local iter = getiter(t)
+  for i, v in iter(t) do
+    if v == x then
+      if isarray(t) then
+        table.remove(t, i)
+        break
+      else
+        t[i] = nil
+        break
+      end
+    end
+  end
+  return x
+end
+
+
+function lume.clear(t)
+  local iter = getiter(t)
+  for k, v in iter(t) do
+    t[k] = nil
   end
   return t
 end
 
 
+function lume.extend(t, ...)
+  for i = 1, select("#", ...) do
+    local x = select(i, ...)
+    if x then
+      for k, v in pairs(x) do
+        t[k] = v
+      end
+    end
+  end
+  return t
+end
+
+
+function lume.shuffle(t)
+  local rtn = {}
+  for i = 1, #t do
+    local r = math_random(i)
+    if r ~= i then
+      rtn[i] = rtn[r]
+    end
+    rtn[r] = t[i]
+  end
+  return rtn
+end
+
+
+function lume.sort(t, comp)
+  local rtn = lume.clone(t)
+  if comp then
+    if type(comp) == "string" then
+      table.sort(rtn, function(a, b) return a[comp] < b[comp] end)
+    else
+      table.sort(rtn, comp)
+    end
+  else
+    table.sort(rtn)
+  end
+  return rtn
+end
+
+
 function lume.array(...)
   local t = {}
   for x in ... do t[#t + 1] = x end
@@ -145,10 +228,11 @@ end
 
 
 function lume.each(t, fn, ...)
+  local iter = getiter(t)
   if type(fn) == "string" then
-    for _, v in pairs(t) do v[fn](v, ...) end
+    for _, v in iter(t) do v[fn](v, ...) end
   else
-    for _, v in pairs(t) do fn(v, ...) end
+    for _, v in iter(t) do fn(v, ...) end
   end
   return t
 end
@@ -156,15 +240,17 @@ end
 
 function lume.map(t, fn)
   fn = iteratee(fn)
+  local iter = getiter(t)
   local rtn = {}
-  for k, v in pairs(t) do rtn[k] = fn(v) end
+  for k, v in iter(t) do rtn[k] = fn(v) end
   return rtn
 end
 
 
 function lume.all(t, fn)
   fn = iteratee(fn)
-  for k, v in pairs(t) do
+  local iter = getiter(t)
+  for k, v in iter(t) do
     if not fn(v) then return false end
   end
   return true
@@ -173,7 +259,8 @@ end
 
 function lume.any(t, fn)
   fn = iteratee(fn)
-  for k, v in pairs(t) do
+  local iter = getiter(t)
+  for k, v in iter(t) do
     if fn(v) then return true end
   end
   return false
@@ -181,17 +268,26 @@ end
 
 
 function lume.reduce(t, fn, first)
-  local acc = first or t[1]
-  assert(acc, "reduce of an empty array with no first value")
-  for i = first and 1 or 2, #t do acc = fn(acc, t[i]) end
+  local acc = first
+  local started = first and true or false
+  local iter = getiter(t)
+  for k, v in iter(t) do
+    if started then
+      acc = fn(acc, v)
+    else
+      acc = v
+      started = true
+    end
+  end
+  assert(started, "reduce of an empty table with no first value")
   return acc
 end
 
 
-function lume.set(t, retainkeys)
+function lume.set(t)
   local rtn = {}
   for k, v in pairs(lume.invert(t)) do
-    rtn[retainkeys and v or (#rtn + 1)] = k
+    rtn[#rtn + 1] = k
   end
   return rtn
 end
@@ -199,24 +295,69 @@ end
 
 function lume.filter(t, fn, retainkeys)
   fn = iteratee(fn)
+  local iter = getiter(t)
   local rtn = {}
-  for k, v in pairs(t) do
-    if fn(v) then rtn[retainkeys and k or (#rtn + 1)] = v end
+  if retainkeys then
+    for k, v in iter(t) do
+      if fn(v) then rtn[k] = v end
+    end
+  else
+    for k, v in iter(t) do
+      if fn(v) then rtn[#rtn + 1] = v end
+    end
   end
   return rtn
 end
 
 
-function lume.merge(t, t2, retainkeys)
-  for k, v in pairs(t2) do
-    t[retainkeys and k or (#t + 1)] = v
+function lume.reject(t, fn, retainkeys)
+  fn = iteratee(fn)
+  local iter = getiter(t)
+  local rtn = {}
+  if retainkeys then
+    for k, v in iter(t) do
+      if not fn(v) then rtn[k] = v end
+    end
+  else
+    for k, v in iter(t) do
+      if not fn(v) then rtn[#rtn + 1] = v end
+    end
   end
-  return t
+  return rtn
+end
+
+
+function lume.merge(...)
+  local rtn = {}
+  for i = 1, select("#", ...) do
+    local t = select(i, ...)
+    local iter = getiter(t)
+    for k, v in iter(t) do
+      rtn[k] = v
+    end
+  end
+  return rtn
+end
+
+
+function lume.concat(...)
+  local rtn = {}
+  for i = 1, select("#", ...) do
+    local t = select(i, ...)
+    if t ~= nil then
+      local iter = getiter(t)
+      for k, v in iter(t) do
+        rtn[#rtn + 1] = v
+      end
+    end
+  end
+  return rtn
 end
 
 
 function lume.find(t, value)
-  for k, v in pairs(t) do
+  local iter = getiter(t)
+  for k, v in iter(t) do
     if v == value then return k end
   end
   return nil
@@ -225,7 +366,8 @@ end
 
 function lume.match(t, fn)
   fn = iteratee(fn)
-  for k, v in pairs(t) do
+  local iter = getiter(t)
+  for k, v in iter(t) do
     if fn(v) then return v, k end
   end
   return nil
@@ -234,13 +376,17 @@ end
 
 function lume.count(t, fn)
   local count = 0
+  local iter = getiter(t)
   if fn then
     fn = iteratee(fn)
-    for k, v in pairs(t) do
+    for k, v in iter(t) do
       if fn(v) then count = count + 1 end
     end
   else
-    for k in pairs(t) do count = count + 1 end
+    if isarray(t) then
+      return #t
+    end
+    for k in iter(t) do count = count + 1 end
   end
   return count
 end
@@ -276,9 +422,20 @@ function lume.invert(t)
 end
 
 
+function lume.pick(t, ...)
+  local rtn = {}
+  for i = 1, select("#", ...) do
+    local k = select(i, ...)
+    rtn[k] = t[k]
+  end
+  return rtn
+end
+
+
 function lume.keys(t)
   local rtn = {}
-  for k, v in pairs(t) do rtn[#rtn + 1] = k end
+  local iter = getiter(t)
+  for k, v in iter(t) do rtn[#rtn + 1] = k end
   return rtn
 end
 
@@ -292,9 +449,9 @@ end
 
 function lume.fn(fn, ...)
   assert(iscallable(fn), "expected a function as the first argument")
-  local args = {...}
+  local args = { ... }
   return function(...)
-    local a = lume.merge(lume.clone(args), {...})
+    local a = lume.concat(args, { ... })
     return fn(unpack(a))
   end
 end
@@ -330,8 +487,16 @@ end
 
 
 function lume.combine(...)
+  local n = select('#', ...)
+  if n == 0 then return noop end
+  if n == 1 then 
+    local fn = select(1, ...)
+    if not fn then return noop end
+    assert(iscallable(fn), "expected a function or nil")
+    return fn
+  end
   local funcs = {}
-  for i = 1, select("#", ...) do
+  for i = 1, n do
     local fn = select(i, ...)
     if fn ~= nil then
       assert(iscallable(fn), "expected a function or nil")
@@ -344,6 +509,13 @@ function lume.combine(...)
 end
 
 
+function lume.call(fn, ...)
+  if fn then
+    return fn(...)
+  end
+end
+
+
 function lume.time(fn, ...)
   local start = os.clock()
   local rtn = {fn(...)}
@@ -364,19 +536,41 @@ function lume.lambda(str)
 end
 
 
-function lume.serialize(x)
-  local f = { string = function(v) return string.format("%q", v) end,
-              number = tostring, boolean = tostring }
-  f.table = function(t)
+local serialize
+
+local serialize_map = {
+  [ "boolean" ] = tostring,
+  [ "nil"     ] = tostring,
+  [ "string"  ] = function(v) return string.format("%q", v) end,
+  [ "number"  ] = function(v)
+    if      v ~=  v     then return  "0/0"      --  nan
+    elseif  v ==  1 / 0 then return  "1/0"      --  inf
+    elseif  v == -1 / 0 then return "-1/0" end  -- -inf
+    return tostring(v)
+  end,
+  [ "table"   ] = function(t, stk)
+    stk = stk or {}
+    if stk[t] then error("circular reference") end
     local rtn = {}
+    stk[t] = true
     for k, v in pairs(t) do
-      rtn[#rtn + 1] = "[" .. f[type(k)](k) .. "]=" .. f[type(v)](v) .. ","
+      rtn[#rtn + 1] = "[" .. serialize(k, stk) .. "]=" .. serialize(v, stk)
     end
-    return "{" .. table.concat(rtn) .. "}"
+    stk[t] = nil
+    return "{" .. table.concat(rtn, ",") .. "}"
   end
-  local err = function(t,k) error("unsupported serialize type: " .. k) end
-  setmetatable(f, { __index = err })
-  return f[type(x)](x)
+}
+
+setmetatable(serialize_map, {
+  __index = function(t, k) error("unsupported serialize type: " .. k) end
+})
+
+serialize = function(x, stk)
+  return serialize_map[type(x)](x, stk)
+end
+
+function lume.serialize(x)
+  return serialize(x)
 end
 
 
@@ -403,6 +597,38 @@ function lume.trim(str, chars)
 end
 
 
+function lume.wordwrap(str, limit)
+  limit = limit or 72
+  local check
+  if type(limit) == "number" then
+    check = function(str) return #str >= limit end
+  else
+    check = limit
+  end
+  local rtn = {}
+  local line = ""
+  for word, spaces in str:gmatch("(%S+)(%s*)") do
+    local str = line .. word
+    if check(str) then
+      table.insert(rtn, line .. "\n")
+      line = word
+    else
+      line = str
+    end
+    for c in spaces:gmatch(".") do
+      if c == "\n" then
+        table.insert(rtn, line .. "\n")
+        line = ""
+      else
+        line = line .. c
+      end
+    end
+  end
+  table.insert(rtn, line)
+  return table.concat(rtn)
+end
+
+
 function lume.format(str, vars)
   if not vars then return str end
   local f = function(x)
@@ -414,10 +640,12 @@ end
 
 function lume.trace(...)
   local info = debug.getinfo(2, "Sl")
-  local t = { "[" .. info.short_src .. ":" .. info.currentline .. "]" }
+  local t = { info.short_src .. ":" .. info.currentline .. ":" }
   for i = 1, select("#", ...) do
     local x = select(i, ...)
-    x = (type(x) == "number") and lume.round(x, .01) or (x or "nil")
+    if type(x) == "number" then
+      x = string.format("%g", lume.round(x, .01))
+    end
     t[#t + 1] = tostring(x)
   end
   print(table.concat(t, " "))
@@ -475,6 +703,39 @@ function lume.hotswap(modname)
 end
 
 
+local ripairs_iter = function(t, i)
+  i = i - 1
+  local v = t[i]
+  if v then return i, v end
+end
+
+function lume.ripairs(t)
+  return ripairs_iter, t, (#t + 1)
+end
+
+
+function lume.color(str, mul)
+  mul = mul or 1
+  local r, g, b, a
+  r, g, b = str:match("#(%x%x)(%x%x)(%x%x)")
+  if r then
+    r = tonumber(r, 16) / 0xff
+    g = tonumber(g, 16) / 0xff
+    b = tonumber(b, 16) / 0xff
+    a = 1
+  elseif str:match("rgba?%s*%([%d%s%.,]+%)") then
+    local f = str:gmatch("[%d.]+")
+    r = (f() or 0) / 0xff
+    g = (f() or 0) / 0xff
+    b = (f() or 0) / 0xff
+    a = f() or 1
+  else
+    error(("bad color string '%s'"):format(str))
+  end
+  return r * mul, g * mul, b * mul, a * mul
+end
+
+
 function lume.rgba(color)
   local a = math_floor((color / 16777216) % 256)
   local r = math_floor((color /    65536) % 256)

test/test.lua

@@ -1,4 +1,4 @@
-local tester = require "tester"
+local tester = require "util.tester"
 
 package.path = "../?.lua;" .. package.path
 
@@ -106,15 +106,76 @@ tests["lume.weightedchoice"] = function()
   tester.test.error( lume.weightedchoice, { a = 1, b = -1 }   )
 end
 
+-- lume.push
+tests["lume.push"] = function()
+  local t = { 1, 2 }
+  lume.push(t, 3, 4)
+  testeq(t, { 1, 2, 3, 4 })
+  lume.push(t, 5, nil, 6, nil, 7)
+  testeq(t, { 1, 2, 3, 4, 5, 6, 7 })
+  lume.push(t)
+  testeq(t, { 1, 2, 3, 4, 5, 6, 7 })
+  local x, y = lume.push(t, 123, 456)
+  testeq(x, 123)
+  testeq(y, 456)
+end
+
+-- lume.remove
+tests["lume.remove"] = function()
+  local t = { 1, 2, 3, 4, 5 }
+  lume.remove(t, 3)
+  testeq(t, { 1, 2, 4, 5  })
+  lume.remove(t, 1)
+  testeq(t, { 2, 4, 5 })
+  lume.remove(t, 5)
+  testeq(t, { 2, 4 })
+  local m = { a = 1, b = 2, c = 3 }
+  local x = lume.remove(t, 123)
+  testeq(x, 123)
+end
+
+-- lume.clear
+tests["lume.clear"] = function()
+  local t = { 1, 2, 3 }
+  lume.clear(t)
+  testeq(t, {})
+  local m = { a = 1, b = 2, c = 3 }
+  lume.clear(m)
+  testeq(m, {})
+  testeq( lume.clear(t) == t, true )
+end
+
+-- lume.extend
+tests["lume.extend"] = function()
+  local t = { a = 10, b = 20, c = 30 }
+  testeq( lume.extend(t) == t, true )
+  lume.extend(t, { d = 40 }, { e = 50 })
+  testeq( t, { a = 10, b = 20, c = 30, d = 40, e = 50 } )
+  lume.extend(t, { a = "cat", b = "dog" }, { b = "owl", c = "fox" })
+  testeq( t, { a = "cat", b = "owl", c = "fox", d = 40, e = 50 } )
+end
+
 -- lume.shuffle
 tests["lume.shuffle"] = function()
   local t = {1, 2, 3, 4, 5}
-  lume.shuffle(t)
+  t = lume.shuffle(t)
   table.sort(t)
   testeq( t,                {1, 2, 3, 4, 5} )
   testeq( lume.shuffle({}), {}              )
 end
 
+-- lume.sort
+tests["lume.sort"] = function()
+  local t = { 1, 5, 2, 4, 3 }
+  local fn = function(a, b) return a > b end
+  testeq( t == lume.sort(t), false             )
+  testeq( lume.sort(t),      { 1, 2, 3, 4, 5 } )
+  testeq( lume.sort(t, fn),  { 5, 4, 3, 2, 1 } )
+  testeq( t,                 { 1, 5, 2, 4, 3 } )
+  local t = { { id = 2 }, { id = 3 }, { id = 1 } }
+  testeq( lume.sort(t, "id"), { { id = 1 }, { id = 2 }, { id = 3 } })
+end
+
 -- lume.array
 tests["lume.array"] = function()
   local t = lume.array(pairs({a=0, b=0, c=0}))
@@ -179,6 +240,9 @@ tests["lume.reduce"] = function()
   testeq( lume.reduce({1, 2, 3, 4}, add, 5),          15          )
   testeq( lume.reduce({1}, add),                      1           )
   testeq( lume.reduce({}, concat, "potato"),          "potato"    )
+  testeq( lume.reduce({a=1, b=2}, add, 5),            8           )
+  testeq( lume.reduce({a=1, b=2}, add),               3           )
+  tester.test.error(lume.reduce, {}, add)
 end
 
 -- lume.set
@@ -202,10 +266,29 @@ tests["lume.filter"] = function()
   testeq( t, {{ x=1, y=1 }, {x=1, y=3}} )
 end
 
+-- lume.reject
+tests["lume.reject"] = function()
+  local t = lume.reject({1, 2, 3, 4, 5}, function(x) return x % 2 == 0 end  ) 
+  testeq( t, {1, 3, 5} )
+  local t = lume.reject({a=1, b=2, c=3}, function(x) return x == 2 end, true) 
+  testeq( t, {a=1, c=3} )
+  local t = lume.reject({{ x=1, y=1 }, { x=2, y=2 }, { x=1, y=3 }}, { x = 1 })
+  testeq( t, {{ x=2, y=2 }} )
+end
+
 -- lume.merge
 tests["lume.merge"] = function()
-  testeq( lume.merge({1, 2, 3}, {8, 9, 0}),         {1, 2, 3, 8, 9, 0}  )
-  testeq( lume.merge({a=1, b=2}, {b=3, c=4}, true), {a=1, b=3, c=4}     )
+  testeq( lume.merge(),                       {}              )
+  testeq( lume.merge({x=1, y=2}),             {x=1, y=2}      )
+  testeq( lume.merge({a=1, b=2}, {b=3, c=4}), {a=1, b=3, c=4} )
+end
+
+-- lume.concat
+tests["lume.concat"] = function()
+  testeq( lume.concat(nil),                            {}                    )
+  testeq( lume.concat({1, 2, 3}),                      {1, 2, 3}             )
+  testeq( lume.concat({1, 2, 3}, {4, 5, 6}),           {1, 2, 3, 4, 5, 6}    )
+  testeq( lume.concat({1, 2, 3}, {4, 5, 6}, nil, {7}), {1, 2, 3, 4, 5, 6, 7} )
 end
 
 -- lume.find
@@ -290,6 +373,15 @@ tests["lume.invert"] = function()
   testeq( lume.invert(lume.invert{a = 1, b = 2}), {a = 1, b = 2}      )
 end
 
+-- lume.pick
+tests["lume.pick"] = function()
+  local t = { cat = 10, dog = 20, fox = 30, owl = 40 }
+  testeq( lume.pick(t, "cat", "dog"), { cat = 10, dog = 20 } )
+  testeq( lume.pick(t, "fox", "owl"), { fox = 30, owl = 40 } )
+  testeq( lume.pick(t, "owl"), { owl = 40 } )
+  testeq( lume.pick(t), {} )
+end
+
 -- lume.keys
 tests["lume.keys"] = function()
   testeq( lume.keys({}), {} )
@@ -349,6 +441,20 @@ tests["lume.combine"] = function()
   fn = lume.combine(nil, a, nil, b, nil)
   fn(10, 20)
   testeq( acc, 230 )
+  local x = false
+  fn = lume.combine(function() x = true end)
+  fn()
+  testeq( x, true )
+  testeq( type(lume.combine(nil)), "function" )
+  testeq( type(lume.combine()),    "function" )
+end
+
+-- lume.call
+tests["lume.call"] = function()
+  local add = function(a, b) return a + b end
+  testeq( lume.call(),              nil )
+  testeq( lume.call(nil, 1, 2, 3),  nil )
+  testeq( lume.call(add, 1, 2),     3   )
 end
 
 -- lume.time
@@ -378,6 +484,10 @@ tests["lume.serialize, lume.deserialize"] = function()
   local t = { 1, 2, 3, 4, true, false, "cat", "dog", {1, 2, 3} }
   local s = lume.serialize(t)
   testeq( lume.deserialize(s), t )
+  testeq( lume.deserialize(lume.serialize(math.huge)), math.huge )
+  testeq( lume.deserialize(lume.serialize(-math.huge)), -math.huge )
+  local x = lume.deserialize(lume.serialize(0 / 0)) -- nan
+  testeq( x ~= x, true )
 end
 
 -- lume.split
@@ -402,6 +512,16 @@ tests["lume.trim"] = function()
   testeq( lume.trim("^.hello world]^", "^.]"),  "hello world"   )
 end
 
+-- lume.wordwrap
+tests["lume.wordwrap"] = function()
+  local str = "A small string with some words and then some more   words"
+  local b = "A small string with \nsome words and then \nsome more   words"
+  local fn = function(str) return #str >= 20 end
+  testeq( lume.wordwrap(str),     str )
+  testeq( lume.wordwrap(str, 20), b   )
+  testeq( lume.wordwrap(str, fn), b   )
+end
+
 -- lume.format
 tests["lume.format"] = function()
   local str = lume.format("a {a} in a {b}", {a = "mouse", b = "house"})
@@ -419,7 +539,7 @@ tests["lume.trace"] = function()
   local oldprint = print
   local file, line, msg
   print = function(x)
-    file, line, msg = x:match("%[(.-):(.-)%] (.*)")
+    file, line, msg = x:match("(.-):(.-): (.*)")
   end
   lume.trace("Hi world", 123.456, 1, nil)
   print = oldprint
@@ -447,6 +567,34 @@ tests["lume.hotswap"] = function()
   testeq( type(err),  "string"  )
 end
 
+-- lume.ripairs
+tests["lume.ripairs"] = function()
+  local t = { "a", "b", "c" }
+  local r = {}
+  for i, v in lume.ripairs(t) do
+    table.insert(r, { i, v })
+  end
+  testeq( r, { { 3, "c" }, { 2, "b" }, { 1, "a" } })
+  tester.test.error(lume.ripairs, nil)
+end
+
+-- lume.color
+tests["lume.color"] = function()
+  testeq({ lume.color("#ff0000") },                   { 1, 0, 0, 1 }  )
+  testeq({ lume.color("#00ff00") },                   { 0, 1, 0, 1 }  )
+  testeq({ lume.color("#0000ff") },                   { 0, 0, 1, 1 }  )
+  testeq({ lume.color("rgb( 255, 255, 255 )") },      { 1, 1, 1, 1 }  )
+  testeq({ lume.color("rgb (0, 0, 0)") },             { 0, 0, 0, 1 }  )
+  testeq({ lume.color("rgba(255, 255, 255, .5)") },   { 1, 1, 1, .5 } )
+  testeq({ lume.color("#ffffff", 2) },                { 2, 2, 2, 2 }  )
+  testeq({ lume.color("rgba(255, 255, 255, 1)", 3) }, { 3, 3, 3, 3 }  )
+  tester.test.error(lume.color, "#ff00f")
+  tester.test.error(lume.color, "#xyzxyz")
+  tester.test.error(lume.color, "rgba(hello)")
+  tester.test.error(lume.color, "rgba()")
+  tester.test.error(lume.color, "rgba(1, 1, 1, 1")
+end
+
 -- lume.rgba
 tests["lume.rgba"] = function()
   local r, g, b, a = lume.rgba(0x12345678)