Initial commit

test/mock.luau

@@ -0,0 +1,254 @@
+local Instance = {} do
+    local Signal = require "test/goodsignal"
+    type Signal = Signal.Type
+
+    type userdata = { __USERDATA: true }
+
+    --[[
+
+    attempt to mimic roblox engine's method of userdata proxy to actual instance data
+    proxy can gc independantly of actual instance data
+    proxy prevents gc of actual instance data
+    luau code never has direct access to actual instance data, only to proxy
+
+    proxy knows data
+    data does not know proxy
+    separate weak map kept data -> proxy
+    
+    ]]
+
+    type ProxyMT = {
+        proxy: userdata,
+        data: Data,
+        __index: any,
+        __newindex: any
+    }
+
+    type Data = {
+        name: string,
+        parent: Data?,
+        children: { Data },
+        changed: { [string]: Signal },
+        properties: { [string]: unknown },
+        destroying: Signal,
+        class: string,
+        type: "Instance"
+    }
+
+    local function deep_clone<T>(template: T & {}): T
+        local t = table.clone(template :: {}) :: {}
+
+        for i, v in next, t do
+            if type(v) == "table" then
+                t[i] = deep_clone(v)
+            end
+        end
+
+        return t :: T & {}
+    end
+
+    
+
+    local proxies = {} :: { [Data]: userdata? }
+    setmetatable(proxies :: any, { __mode = "v" })
+
+    local function get_data(userdata: userdata): Data
+        local function f(userdata: userdata): ProxyMT
+            return getmetatable(userdata :: any)
+        end
+
+        return f(userdata).data
+    end
+
+    local function is_instance(value: unknown): boolean
+        local mt = getmetatable(value :: any)
+        return mt and mt.data and mt.data.type == "Instance"
+    end
+
+    local methods = {}
+
+    local function __index(userdata: userdata, property: string): ()
+        local data = get_data(userdata)
+        return if methods[property] then methods[property]
+            elseif property == "Name" then data.name
+            elseif property == "Parent" then data.parent
+            elseif property == "Destroying" then data.destroying
+            else data.properties[property] 
+    end
+
+    local function __newindex(userdata: userdata, property: string, value: unknown)
+        local data = get_data(userdata)
+        if property == "Name" then
+            data.name = value :: string
+        elseif property == "Parent" then
+            assert(value == nil or is_instance(value), "attempt to set non-instance as parent")
+            local parent = data.parent
+            if parent then
+                data.parent = nil
+                table.remove(parent.children, table.find(parent.children, data))
+            end
+            if value then
+                data.parent = get_data(value :: userdata)
+                table.insert(get_data(value :: userdata).children, data)
+            end
+        else
+            data.properties[property] = value
+        end
+
+        if data.changed[property] then
+            data.changed[property]:Fire()
+        end
+    end
+
+    local function get_proxy(data: Data): userdata
+        return proxies[data] or (function()
+            local userdata = newproxy(true)
+            local proxy = getmetatable(userdata)
+            proxy.proxy = userdata
+            proxy.data = data
+            proxy.__index = __index
+            proxy.__newindex = __newindex
+            proxies[data] = userdata   
+            return userdata
+        end)()
+    end
+
+    function Instance.new(class: string): Instance
+        local data = {
+            name = "UNNAMED",
+            parent = nil,
+            children = {},
+            changed = {},
+            properties = {},
+            class = class,
+            destroying = Signal.new() :: any,
+            type = "Instance" :: "Instance"
+        }
+
+        return get_proxy(data) :: any
+    end
+
+    function Instance.is_instance(value: unknown): boolean
+        return is_instance(value)
+    end
+
+    function methods.Clone(userdata: userdata): userdata
+        local data = get_data(userdata)
+        local clone_userdata = (Instance.new("") :: any) :: userdata
+        local clone_data = get_data(clone_userdata)
+
+        for i, v in next, deep_clone(data) do
+            clone_data[i] = v
+        end
+
+        return clone_userdata
+    end
+
+    function methods.FindFirstChild(userdata: userdata, target: string): userdata?
+        local data = get_data(userdata)
+        for _, child in data.children do
+            if child.name == target then
+                return get_proxy(child)
+            end
+        end
+        return nil
+    end
+
+    function methods.GetChildren(userdata: userdata): { userdata }
+        local children = get_data(userdata).children
+        local userdatas = table.create(#children)
+
+        for i, child in next, children do
+            userdatas[i] = get_proxy(child)
+        end
+
+        return userdatas
+    end
+
+    function methods.GetPropertyChangedSignal(userdata: userdata, property: string): RBXScriptSignal
+        local data = get_data(userdata)
+        if not data.changed[property] then
+            data.changed[property] = Signal.new() :: any
+        end
+        return data.changed[property]
+    end
+
+    function methods.Destroy(userdata: userdata)
+        local data = get_data(userdata);
+        data.destroying:Fire()
+        data.parent = nil
+        if data.changed["Parent"] then
+            data.changed["Parent"]:Fire()
+        end
+    end
+end
+
+local Color3 = {} do
+    function Color3.new(r, g, b): Color3
+        return setmetatable({ r = r, g = g, b = b}, Color3) :: any
+    end
+
+    function Color3.__eq(a, b)
+        return a.r == b.r and a.g == b.g and a.b == b.b
+    end
+end
+
+local Vector3 = {} do
+    function Vector3.new(x, y, z): Vector3
+        return setmetatable({ x = x, y = y, z = z}, Vector3) :: any
+    end
+
+    function Vector3.__eq(a, b)
+        return a.x == b.x and a.y == b.y and a.z == b.z
+    end
+end
+
+local Vector2 = {} do
+    function Vector2.new(x, y): Vector2
+        return setmetatable({ x = x, y = y }, Vector2) :: any
+    end
+
+    function Vector2.__eq(a, b)
+        return a.x == b.x and a.y == b.y
+    end
+end
+
+local UDim2 = {} do
+    function UDim2.fromScale(x, y): UDim2
+        return setmetatable({ x = { scale = x, offset = 0 }, y = { scale = y, offset = 0 } }, UDim2) :: any
+    end
+
+    function UDim2.__eq(a, b)
+        return a.x.scale == b.x.scale and
+            b.x.offset == b.x.offset and
+            a.y.scale == b.y.scale and
+            a.y.offset == b.y.offset
+    end
+end
+
+local Enum = {} :: any do
+    setmetatable(Enum, { __index = function(self, index)
+        local v = setmetatable({}, { __index = function(self, index) 
+            self[index] = true
+            return true
+        end})
+        self[index] = v
+        return v
+    end})
+end
+
+local function typeof(v): string
+    return if Instance.is_instance(v) then "Instance"
+        elseif getmetatable(v) and getmetatable(v).__type then getmetatable(v).__type
+        else type(v)
+end
+
+return {
+    Instance = Instance,
+    Color3 = Color3,
+    Vector3 = Vector3,
+    Vector2 = Vector2,
+    UDim2 = UDim2,
+    Enum = Enum,
+    typeof = typeof
+}