satelito

lume.lua (15772B)

---

 --
 -- lume
 --
 -- Copyright (c) 2020 rxi
 --
 -- Permission is hereby granted, free of charge, to any person obtaining a copy of
 -- this software and associated documentation files (the "Software"), to deal in
 -- the Software without restriction, including without limitation the rights to
 -- use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
 -- of the Software, and to permit persons to whom the Software is furnished to do
 -- so, subject to the following conditions:
 --
 -- The above copyright notice and this permission notice shall be included in all
 -- copies or substantial portions of the Software.
 --
 -- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 -- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 -- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 -- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 -- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 -- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 -- SOFTWARE.
 --
 
 local lume = { _version = "2.3.0" }
 
 local pairs, ipairs = pairs, ipairs
 local type, assert, unpack = type, assert, unpack or table.unpack
 local tostring, tonumber = tostring, tonumber
 local math_floor = math.floor
 local math_ceil = math.ceil
 local math_atan2 = math.atan2 or math.atan
 local math_sqrt = math.sqrt
 local math_abs = math.abs
 
 local noop = function()
 end
 
 local identity = function(x)
   return x
 end
 
 local patternescape = function(str)
   return str:gsub("[%(%)%.%%%+%-%*%?%[%]%^%$]", "%%%1")
 end
 
 local absindex = function(len, i)
   return i < 0 and (len + i + 1) or i
 end
 
 local iscallable = function(x)
   if type(x) == "function" then return true end
   local mt = getmetatable(x)
   return mt and mt.__call ~= nil
 end
 
 local getiter = function(x)
   if lume.isarray(x) then
     return ipairs
   elseif type(x) == "table" then
     return pairs
   end
   error("expected table", 3)
 end
 
 local iteratee = function(x)
   if x == nil then return identity end
   if iscallable(x) then return x end
   if type(x) == "table" then
     return function(z)
       for k, v in pairs(x) do
         if z[k] ~= v then return false end
       end
       return true
     end
   end
   return function(z) return z[x] end
 end
 
 
 
 function lume.clamp(x, min, max)
   return x < min and min or (x > max and max or x)
 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)
 end
 
 
 function lume.sign(x)
   return x < 0 and -1 or 1
 end
 
 
 function lume.lerp(a, b, amount)
   return a + (b - a) * lume.clamp(amount, 0, 1)
 end
 
 
 function lume.smooth(a, b, amount)
   local t = lume.clamp(amount, 0, 1)
   local m = t * t * (3 - 2 * t)
   return a + (b - a) * m
 end
 
 
 function lume.pingpong(x)
   return 1 - math_abs(1 - x % 2)
 end
 
 
 function lume.distance(x1, y1, x2, y2, squared)
   local dx = x1 - x2
   local dy = y1 - y2
   local s = dx * dx + dy * dy
   return squared and s or math_sqrt(s)
 end
 
 
 function lume.angle(x1, y1, x2, y2)
   return math_atan2(y2 - y1, x2 - x1)
 end
 
 
 function lume.vector(angle, magnitude)
   return math.cos(angle) * magnitude, math.sin(angle) * magnitude
 end
 
 
 function lume.random(a, b)
   if not a then a, b = 0, 1 end
   if not b then b = 0 end
   return a + math.random() * (b - a)
 end
 
 
 function lume.randomchoice(t)
   return t[math.random(#t)]
 end
 
 
 function lume.weightedchoice(t)
   local sum = 0
   for _, v in pairs(t) do
     assert(v >= 0, "weight value less than zero")
     sum = sum + v
   end
   assert(sum ~= 0, "all weights are zero")
   local rnd = lume.random(sum)
   for k, v in pairs(t) do
     if rnd < v then return k end
     rnd = rnd - v
   end
 end
 
 
 function lume.isarray(x)
   return type(x) == "table" and x[1] ~= nil
 end
 
 
 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 lume.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 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
   return t
 end
 
 
 function lume.each(t, fn, ...)
   local iter = getiter(t)
   if type(fn) == "string" then
     for _, v in iter(t) do v[fn](v, ...) end
   else
     for _, v in iter(t) do fn(v, ...) end
   end
   return t
 end
 
 
 function lume.map(t, fn)
   fn = iteratee(fn)
   local iter = getiter(t)
   local rtn = {}
   for k, v in iter(t) do rtn[k] = fn(v) end
   return rtn
 end
 
 
 function lume.all(t, fn)
   fn = iteratee(fn)
   local iter = getiter(t)
   for _, v in iter(t) do
     if not fn(v) then return false end
   end
   return true
 end
 
 
 function lume.any(t, fn)
   fn = iteratee(fn)
   local iter = getiter(t)
   for _, v in iter(t) do
     if fn(v) then return true end
   end
   return false
 end
 
 
 function lume.reduce(t, fn, first)
   local started = first ~= nil
   local acc = first
   local iter = getiter(t)
   for _, 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.unique(t)
   local rtn = {}
   for k in pairs(lume.invert(t)) do
     rtn[#rtn + 1] = k
   end
   return rtn
 end
 
 
 function lume.filter(t, fn, retainkeys)
   fn = iteratee(fn)
   local iter = getiter(t)
   local rtn = {}
   if retainkeys then
     for k, v in iter(t) do
       if fn(v) then rtn[k] = v end
     end
   else
     for _, v in iter(t) do
       if fn(v) then rtn[#rtn + 1] = v end
     end
   end
   return rtn
 end
 
 
 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 _, v in iter(t) do
       if not fn(v) then rtn[#rtn + 1] = v end
     end
   end
   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 _, v in iter(t) do
         rtn[#rtn + 1] = v
       end
     end
   end
   return rtn
 end
 
 
 function lume.find(t, value)
   local iter = getiter(t)
   for k, v in iter(t) do
     if v == value then return k end
   end
   return nil
 end
 
 
 function lume.match(t, fn)
   fn = iteratee(fn)
   local iter = getiter(t)
   for k, v in iter(t) do
     if fn(v) then return v, k end
   end
   return nil
 end
 
 
 function lume.count(t, fn)
   local count = 0
   local iter = getiter(t)
   if fn then
     fn = iteratee(fn)
     for _, v in iter(t) do
       if fn(v) then count = count + 1 end
     end
   else
     if lume.isarray(t) then
       return #t
     end
     for _ in iter(t) do count = count + 1 end
   end
   return count
 end
 
 
 function lume.slice(t, i, j)
   i = i and absindex(#t, i) or 1
   j = j and absindex(#t, j) or #t
   local rtn = {}
   for x = i < 1 and 1 or i, j > #t and #t or j do
     rtn[#rtn + 1] = t[x]
   end
   return rtn
 end
 
 
 function lume.first(t, n)
   if not n then return t[1] end
   return lume.slice(t, 1, n)
 end
 
 
 function lume.last(t, n)
   if not n then return t[#t] end
   return lume.slice(t, -n, -1)
 end
 
 
 function lume.invert(t)
   local rtn = {}
   for k, v in pairs(t) do rtn[v] = k end
   return rtn
 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 = {}
   local iter = getiter(t)
   for k in iter(t) do rtn[#rtn + 1] = k end
   return rtn
 end
 
 
 function lume.clone(t)
   local rtn = {}
   for k, v in pairs(t) do rtn[k] = v end
   return rtn
 end
 
 
 function lume.fn(fn, ...)
   assert(iscallable(fn), "expected a function as the first argument")
   local args = { ... }
   return function(...)
     local a = lume.concat(args, { ... })
     return fn(unpack(a))
   end
 end
 
 
 function lume.once(fn, ...)
   local f = lume.fn(fn, ...)
   local done = false
   return function(...)
     if done then return end
     done = true
     return f(...)
   end
 end
 
 
 local memoize_fnkey = {}
 local memoize_nil = {}
 
 function lume.memoize(fn)
   local cache = {}
   return function(...)
     local c = cache
     for i = 1, select("#", ...) do
       local a = select(i, ...) or memoize_nil
       c[a] = c[a] or {}
       c = c[a]
     end
     c[memoize_fnkey] = c[memoize_fnkey] or {fn(...)}
     return unpack(c[memoize_fnkey])
   end
 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, n do
     local fn = select(i, ...)
     if fn ~= nil then
       assert(iscallable(fn), "expected a function or nil")
       funcs[#funcs + 1] = fn
     end
   end
   return function(...)
     for _, f in ipairs(funcs) do f(...) end
   end
 end
 
 
 function lume.call(fn, ...)
   if fn then
     return fn(...)
   end
 end
 
 
 function lume.time(fn, ...)
   local start = os.clock()
   local rtn = {fn(...)}
   return (os.clock() - start), unpack(rtn)
 end
 
 
 local lambda_cache = {}
 
 function lume.lambda(str)
   if not lambda_cache[str] then
     local args, body = str:match([[^([%w,_ ]-)%->(.-)$]])
     assert(args and body, "bad string lambda")
     local s = "return function(" .. args .. ")\nreturn " .. body .. "\nend"
     lambda_cache[str] = lume.dostring(s)
   end
   return lambda_cache[str]
 end
 
 
 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] = "[" .. serialize(k, stk) .. "]=" .. serialize(v, stk)
     end
     stk[t] = nil
     return "{" .. table.concat(rtn, ",") .. "}"
   end
 }
 
 setmetatable(serialize_map, {
   __index = function(_, 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
 
 
 function lume.deserialize(str)
   return lume.dostring("return " .. str)
 end
 
 
 function lume.split(str, sep)
   if not sep then
     return lume.array(str:gmatch("([%S]+)"))
   else
     assert(sep ~= "", "empty separator")
     local psep = patternescape(sep)
     return lume.array((str..sep):gmatch("(.-)("..psep..")"))
   end
 end
 
 
 function lume.trim(str, chars)
   if not chars then return str:match("^[%s]*(.-)[%s]*$") end
   chars = patternescape(chars)
   return str:match("^[" .. chars .. "]*(.-)[" .. chars .. "]*$")
 end
 
 
 function lume.wordwrap(str, limit)
   limit = limit or 72
   local check
   if type(limit) == "number" then
     check = function(s) return #s >= limit end
   else
     check = limit
   end
   local rtn = {}
   local line = ""
   for word, spaces in str:gmatch("(%S+)(%s*)") do
     local s = line .. word
     if check(s) then
       table.insert(rtn, line .. "\n")
       line = word
     else
       line = s
     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)
     return tostring(vars[x] or vars[tonumber(x)] or "{" .. x .. "}")
   end
   return (str:gsub("{(.-)}", f))
 end
 
 
 function lume.trace(...)
   local info = debug.getinfo(2, "Sl")
   local t = { info.short_src .. ":" .. info.currentline .. ":" }
   for i = 1, select("#", ...) do
     local x = select(i, ...)
     if type(x) == "number" then
       x = string.format("%g", lume.round(x, .01))
     end
     t[#t + 1] = tostring(x)
   end
   print(table.concat(t, " "))
 end
 
 
 function lume.dostring(str)
   return assert((loadstring or load)(str))()
 end
 
 
 function lume.uuid()
   local fn = function(x)
     local r = math.random(16) - 1
     r = (x == "x") and (r + 1) or (r % 4) + 9
     return ("0123456789abcdef"):sub(r, r)
   end
   return (("xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx"):gsub("[xy]", fn))
 end
 
 
 function lume.hotswap(modname)
   local oldglobal = lume.clone(_G)
   local updated = {}
   local function update(old, new)
     if updated[old] then return end
     updated[old] = true
     local oldmt, newmt = getmetatable(old), getmetatable(new)
     if oldmt and newmt then update(oldmt, newmt) end
     for k, v in pairs(new) do
       if type(v) == "table" then update(old[k], v) else old[k] = v end
     end
   end
   local err = nil
   local function onerror(e)
     for k in pairs(_G) do _G[k] = oldglobal[k] end
     err = lume.trim(e)
   end
   local ok, oldmod = pcall(require, modname)
   oldmod = ok and oldmod or nil
   xpcall(function()
     package.loaded[modname] = nil
     local newmod = require(modname)
     if type(oldmod) == "table" then update(oldmod, newmod) end
     for k, v in pairs(oldglobal) do
       if v ~= _G[k] and type(v) == "table" then
         update(v, _G[k])
         _G[k] = v
       end
     end
   end, onerror)
   package.loaded[modname] = oldmod
   if err then return nil, err end
   return oldmod
 end
 
 
 local ripairs_iter = function(t, i)
   i = i - 1
   local v = t[i]
   if v ~= nil 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
 
 
 local chain_mt = {}
 chain_mt.__index = lume.map(lume.filter(lume, iscallable, true),
   function(fn)
     return function(self, ...)
       self._value = fn(self._value, ...)
       return self
     end
   end)
 chain_mt.__index.result = function(x) return x._value end
 
 function lume.chain(value)
   return setmetatable({ _value = value }, chain_mt)
 end
 
 setmetatable(lume,  {
   __call = function(_, ...)
     return lume.chain(...)
   end
 })
 
 
 return lume