changed name to Observer

Author: ChristophLHR

README.md

@@ -1,17 +1,17 @@
-# subscriber-lib
+# Observer-lib
 
 A library which allows to listen to changes in any table
 
 # Example
 
 ```lua
-local createSubscriber = require("../subscriber")
+local createObserver = require("../observer")
 
 local t = {
     [1] = "example",
     [2] = "example 2"
 }
-local s = createSubscriber(t)
+local s = createObserver(t)
 
 local id = s.subscribe(function(event, data)
     print(event) -- 1. "Insert" | "Modify" | "Delete"

files.txt

@@ -1 +1 @@
-subscriber.lua
+observer.lua

observer.lua

@@ -0,0 +1,95 @@
+local function deepcopy(tbl, copyTo)
+    if type(tbl) ~= "table" then return tbl end
+    copyTo = copyTo or {}
+    for k, v in pairs(tbl) do
+        copyTo[deepcopy(k)] = deepcopy(v)
+    end
+    return copyTo
+end
+local function emptyTable(tbl)
+    for k, _ in pairs(tbl) do
+        tbl[k] = nil
+    end
+end
+
+
+
+---@param object table The table which the subscribtion should be created for
+local CreateObserver = function(object)
+    ---@class Observer
+    local Observer = {
+        obj = {},
+        listeners = {},
+        listenerID = 1,
+        originalMetaTable = getmetatable(object),
+        running = true
+    }
+
+    local function init()
+        assert(type(object) == "table",
+            "Observer can only be created for tables. Got a " .. type(object) .. " instead.")
+        Observer.obj = deepcopy(object)
+        Observer.listenerID = 1
+        Observer.listeners = {}
+        Observer.originalMetaTable = deepcopy(getmetatable(object) or {})
+
+        emptyTable(object)
+        local mt
+        mt = deepcopy(getmetatable(object) or {})
+
+        mt.__newindex = function(_, key, value)
+            if value == nil then
+                Observer.notify("Delete", { key, value, Observer.obj[key] })
+            elseif Observer.obj[key] == nil then
+                Observer.notify("Insert", { key, value })
+            else
+                Observer.notify("Modify", { key, value, Observer.obj[key] })
+            end
+            rawset(Observer.obj, key, value)
+        end
+        mt.__index = function(_, key)
+            return rawget(Observer.obj, key)
+        end
+        setmetatable(object, mt)
+    end
+
+    local function returnToOriginalState()
+        Observer.listeners = nil
+        Observer.running = false
+        setmetatable(object, Observer.originalMetaTable)
+        deepcopy(Observer.obj, object)
+        Observer.obj = nil
+    end
+
+    function Observer.subscribe(listener)
+        if Observer.running == false then
+            init()
+        end
+        Observer.listeners[Observer.listenerID] = listener
+        Observer.listenerID = Observer.listenerID + 1
+        return Observer.listenerID - 1
+    end
+
+    function Observer.notify(event, data)
+        if Observer.listeners == nil then
+            return
+        end
+        for _, listener in pairs(Observer.listeners) do
+            listener(event, data)
+        end
+    end
+
+    function Observer.unsubscribe(ID)
+        Observer.listeners[ID] = nil
+    end
+
+    function Observer.unsubscribeAll()
+        returnToOriginalState()
+    end
+
+    init()
+
+    return Observer
+end
+
+return CreateObserver

subscriber.lua

@@ -27,13 +27,13 @@
 ---@field equal function
 assert = assert
 
-local subscriber = require("../subscriber")
+local observer = require("../observer")
 
 describe("Subscribe", function()
     it("Table behaves normal", function()
         local t = { [1] = "test", [2] = "test2" }
         assert.are.equal("test", t[1])
-        local sub = subscriber(t)
+        local sub = observer(t)
         t[3] = "test3"
 
         -- old table should still have the same values
@@ -48,8 +48,8 @@ describe("Subscribe", function()
     end)
     it("Delete should trigger", function()
         local t = { [1] = "test", [2] = "test2" }
-        local sub = subscriber(t)
-        sub.subscribe(function(event, data)
+        local o = observer(t)
+        o.subscribe(function(event, data)
             assert.are.equal("Delete", event)
             assert.are.equal(1, data[1])
             assert.are.equal(nil, data[2])
@@ -61,8 +61,8 @@ describe("Subscribe", function()
     end)
     it("Modify should trigger", function()
         local t = { [1] = "test", [2] = "test2" }
-        local sub = subscriber(t)
-        sub.subscribe(function(event, data)
+        local o = observer(t)
+        o.subscribe(function(event, data)
             assert.are.equal("Modify", event)
             assert.are.equal("test3", data[2])
             assert.is_true("test" == data[3])
@@ -73,8 +73,8 @@ describe("Subscribe", function()
     end)
     it("Insert should trigger", function()
         local t = {}
-        local sub = subscriber(t)
-        sub.subscribe(function(event, data)
+        local o = observer(t)
+        o.subscribe(function(event, data)
             assert.are.equal("Insert", event)
             assert.True(("test" == data[2]) or ("test2" == data[2]))
         end)
@@ -85,26 +85,26 @@ describe("Subscribe", function()
     end)
     it("Unsubscribe should work", function()
         local t = { [1] = "test", [2] = "test2" }
-        local sub = subscriber(t)
-        local id = sub.subscribe(function(event, data)
+        local o = observer(t)
+        local id = o.subscribe(function(event, data)
             assert.are.equal("Modify", event)
             assert.are.equal("new Test", data[2])
         end)
         t[1] = "new Test"
         assert.are.equal("new Test", t[1])
-        sub.unsubscribe(id)
+        o.unsubscribe(id)
         t[2] = "new Test 2"
         assert.are.equal("new Test 2", t[2])
     end)
     describe("Multiple subscribers", function()
         it("Multiple Subscribtions shoud work", function()
             local t = { [1] = "test", [2] = "test2" }
-            local sub = subscriber(t)
+            local o = observer(t)
             local calls = 0
-            sub.subscribe(function(_, _)
+            o.subscribe(function(_, _)
                 calls = calls + 1
             end)
-            sub.subscribe(function(event, data)
+            o.subscribe(function(event, data)
                 calls = calls + 1
                 assert.are.equal("Modify", event)
                 assert.are.equal("new Test 2", data[2])
@@ -115,17 +115,17 @@ describe("Subscribe", function()
         end)
         it("Unsubscribing once should work", function()
             local t = { [1] = "test", [2] = "test2" }
-            local sub = subscriber(t)
+            local o = observer(t)
             local calls = 0
-            local id = sub.subscribe(function(_, _)
+            local id = o.subscribe(function(_, _)
                 calls = calls + 1
             end)
-            sub.subscribe(function(event, data)
+            o.subscribe(function(event, data)
                 calls = calls + 1
                 assert.are.equal("Modify", event)
                 assert.are.equal("new Test 2", data[2])
             end)
-            sub.unsubscribe(id)
+            o.unsubscribe(id)
             t[2] = "new Test 2"
             assert.are.equal("new Test 2", t[2])
             assert.are.equal(1, calls)
@@ -134,8 +134,8 @@ describe("Subscribe", function()
     describe("Metatables", function()
         it("Metatable should be set", function()
             local t = { [1] = "test" }
-            local sub = subscriber(t)
-            assert.False(sub.originalMetaTable == getmetatable(t))
+            local o = observer(t)
+            assert.False(o.originalMetaTable == getmetatable(t))
         end)
         it("Metatable should be reset", function()
             local t = { [1] = "test" }
@@ -150,17 +150,17 @@ describe("Subscribe", function()
                 end
             }
             setmetatable(t, metatable)
-            local sub = subscriber(t)
+            local o = observer(t)
             local newCalls = 0
-            sub.subscribe(function(event, data)
+            o.subscribe(function(event, data)
                 assert.are.equal("Modify", event)
                 assert.are.equal("new Test", data[2])
                 newCalls = newCalls + 1
             end)
             t[1] = "new Test"
             assert.are.equal(1, newCalls)
-            sub.unsubscribeAll()
-            sub = nil
+            o.unsubscribeAll()
+            o = nil
             t[2] = "new Test 2"
             assert.are.equal(1, oldCall)
             assert.are.equal(metatable.__newindex, getmetatable(t).__newindex)
@@ -172,16 +172,16 @@ describe("Subscribe", function()
     describe("Resetting", function()
         it("Should reset and then Restart", function()
             local t = { [1] = "test", [2] = "test2" }
-            local sub = subscriber(t)
-            sub.subscribe(function(event, data)
+            local o = observer(t)
+            o.subscribe(function(event, data)
                 assert.are.equal("Modify", event)
                 assert.are.equal("new Test", data[2])
             end)
             t[1] = "new Test"
             assert.are.equal("new Test", t[1])
-            local t2 = sub.unsubscribeAll()
+            local t2 = o.unsubscribeAll()
             assert.are.equal("new Test", t[1])
-            sub.subscribe(function(event, data)
+            o.subscribe(function(event, data)
                 assert.are.equal("Modify", event)
                 assert.are.equal("new Test 2", data[2])
             end)