Sandbox

-- TODO: return true if instance or event
local needssandboxing = function(i) end
sandbox = {}

-- a map of sandboxed items to their original counterparts. TODO: weak keys/values?
sandbox.cache = {}

sandbox.mt = {
    __index = function(self, k)
        local original = sandbox.cache[self]

        -- todo: add logic here to filter property/method reading

        local v = original[k]

        return sandbox.any(v)
    end,
    __newindex = function(self, k, v)
        local original = sandbox.cache[self]

        -- todo: add logic here to filter property writing

        original[k] = unsandbox.any(v)
    end
}
--sandbox any object
function sandbox.any(a)
    if sandbox.cache[a] then
        -- already sandboxed
        return a
    elseif type(a) == "function" then
        return sandbox.func(a)
    elseif type(a) == "table" then
        return sandbox.table(a)
    elseif needssandboxing(a) then
        return sandbox.object(a)
    else
        --doesn't need sandboxing
        return value
    end
end
--sandbox instances and events
function sandbox.object(o)
    local sandboxed = setmetatable({}, sandbox.mt)
    sandbox.cache[sandboxed] = o
    return sandboxed
end
--sandbox a function
function sandbox.func(f)
    local sandboxed = function(...)
        return sandbox(f(unsandbox(...)))
    end
    sandbox.cache[sandboxed] = f
    return sandboxed
end
--sandbox a table. TODO: prevent crash on recursive tables.
function sandbox.table(t)
    local sandboxed = {}
    for k, v in pairs(t) do
        --by sandboxing every key and every value
        sandboxed[sandbox.any(k)] = sandbox.any(v)
    end
    return sandboxed
end
unsandbox = {}
--unsandbox any objects
unsandbox.any = function(a)
    if sandbox.cache[a] then
        --if we have it cached, return it
        return sandbox.cache[a]
    elseif type(a) == "function" then
        return unsandbox.func(a)
    elseif type(a) == "table"
        return unsandbox.table(a)
    else
        return a
    end
end
--unsandbox a table. TODO: prevent crash on recursive tables.
unsandbox.table = function(t)
    local unsandboxed = {}
    for k, v in pairs(t) do
        --by unsandboxing every key and every value
        unsandboxed[unsandbox.any(k)] = unsandbox.any(v)
    end
    return unsandboxed
end
--unsandbox a function (sandboxed -> sandboxed), such as one passed to an event handler, making it (raw -> raw)
unsandbox.func = function(f)
    local raw = function(...)
        return unsandbox(f(sandbox(...)))
    end
    sandbox.cache[f] = raw
    return raw
end

-- make sandbox and unsandbox function acting on tuples
local callable_mt = {
   __call = function(self, first, ...)
       if select('#', ...) == 0 then
           return self.any(first)
       else
           return self.any(first), self(...)
       end
   end
}

setmetatable(sandbox, callable_mt)
setmetatable(unsandbox, callable_mt)