-- -- 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