From dec3dc205fe138585598f1af5dc3b9e43b766489 Mon Sep 17 00:00:00 2001
From: Bruce Hill <bitbucket@bruce-hill.com>
Date: Mon, 23 Apr 2018 16:21:47 -0700
Subject: [PATCH] Added __missing metamethod and updated tests.

---
 README.md    | 23 +++++++++++++++++++++++
 limmutable.c | 18 +++++++++++++-----
 tests.lua    | 30 ++++++++++++++++--------------
 3 files changed, 52 insertions(+), 19 deletions(-)

diff --git a/README.md b/README.md
index d31d949..6403293 100644
--- a/README.md
+++ b/README.md
@@ -69,6 +69,29 @@ assert(({[t1]='yep'})[Tuple(1,2)])
 assert(tostring(Tuple(1,2)) == "(1, 2)")
 ```
 
+## New Metamethods
+This library adds support for two new metamethods: `__new` and `__missing`. `__new` is called when an instance is created. It takes as arguments the immutable class and all arguments the user passed in, and whatever values it returns are used to create the instance. This is pretty handy for default or derived values.
+```lua
+local Foo = immutable({"x","y","xy"}, {
+    __new = function(cls, x, y)
+        y = y or 3
+        return x, y, x*y
+    end
+})
+assert(Foo(2).xy == 6)
+```
+`__missing` is similar to `__index`, except that it only gets called when accessing a key that is neither one of the immutable class's instance keys, nor one of the keys in the class table.
+```lua
+local Foo = immutable({"x","y"}, {
+    classvar = 23,
+    __missing = function(self, key)
+        return "MISSING"
+    end
+})
+local f = Foo(1, nil)
+assert(f.x == 1 and f.y == nil and f.classvar == 23 and f.asdf == "MISSING")
+```
+
 ## General purpose immutable table recipe
 Using tuples, you can make a function that returns an immutable version of a table with arbitrary keys, though it is a little bit hacky.
 ```lua
diff --git a/limmutable.c b/limmutable.c
index 7a5f704..1b2f61c 100644
--- a/limmutable.c
+++ b/limmutable.c
@@ -370,6 +370,16 @@ static int Lindex(lua_State *L)
   class_fallback:
     lua_pushvalue(L, 2);
     lua_gettable(L, 3);
+    if (lua_isnil(L, -1)) {
+        lua_getfield(L, 3, "__missing");
+        if (! lua_isnil(L, -1)) {
+            lua_pushvalue(L, 1);
+            lua_pushvalue(L, 2);
+            lua_call(L, 2, 1);
+            return 1;
+        }
+        return 0;
+    }
     return 1;
 }
 
@@ -623,11 +633,9 @@ static int Lmake_class(lua_State *L)
             // Stack: [CLS, method_name, method_value]
             lua_pushvalue(L, -2);
             // Stack: [CLS, method_name, method_value, method_name]
-            lua_pushvalue(L, -2);
-            // Stack: [CLS, method_name, method_value, method_name, method_value]
-            lua_settable(L, -5);
-            // Stack: [CLS, method_name, method_value]
-            lua_pop(L, 1);
+            lua_insert(L, -2);
+            // Stack: [CLS, method_name, method_name, method_value]
+            lua_settable(L, -4);
             // Stack: [CLS, method_name]
         }
         // Stack: [CLS]
diff --git a/tests.lua b/tests.lua
index a5a48d9..6919108 100644
--- a/tests.lua
+++ b/tests.lua
@@ -161,10 +161,22 @@ test("Testing garbage collection", function()
     assert(next(Foo.__instances) == nil)
 end)
 
-test("Testing stupid metamethods", function()
-    local Five = immutable({"x"}, {__index=function() return 5 end, derp = 99})
-    local f = Five(99)
-    assert(f.x == 5 and f.asdf == 5 and f.derp == 5)
+test("Testing __missing", function()
+    local Foo = immutable({"x","y"}, {
+        classvar = 99,
+        __missing=function(self,k) return tostring(k)..tostring(self.x) end
+    })
+    local f = Foo(23, nil)
+    assert(f.x == 23 and f.y == nil and f.classvar == 99 and f.asdf == "asdf23")
+end)
+
+test("Testing __index", function()
+    local Baz = immutable({"x","y"}, {z=99})
+    local b = Baz(1,nil)
+    assert(b.x == 1 and b.y == nil and b.z == 99 and b.asdf == nil)
+    local Foo = immutable({"x","y"}, {z=99, __index=function() return "foo" end})
+    local f = Foo(1,nil)
+    assert(f.x == "foo" and f.y == "foo" and f.z == "foo" and f.asdf == "foo")
 end)
 
 test("Testing similar class", function()
@@ -296,16 +308,6 @@ test("Testing __new with #args", function()
     assert(f.x == 3 and f.y == 4)
 end)
 
-test("Testing __new with #args", function()
-    local Foo = immutable({"x","y"}, {
-        __new=function(cls,x,y,z)
-            return x+z,y+z
-        end
-    })
-    local f = Foo(2,3,1)
-    assert(f.x == 3 and f.y == 4)
-end)
-
 test("Testing __new with varargs", function()
     local Foo = immutable(nil, {
         __new=function(cls,...)