wraputils.lua setup_property_access shouldn't override class methods

splash/lua_modules/extras.lua

@@ -9,11 +9,12 @@ local Extras = {}
 local Extras_private = {}
 
 function Extras._create(py_extras)
-  local self = {}
-  setmetatable(self, Extras)
-  wraputils.wrap_exposed_object(py_extras, self, Extras_private, false)
-  wraputils.setup_property_access(py_extras, self, Extras)
-  return self
+  local extras = {}
+  setmetatable(extras, Extras)
+  Extras.__index = Extras
+  Extras.__newindex = rawset
+  wraputils.wrap_exposed_object(py_extras, extras, Extras_private, false)
+  return extras
 end
 
 return Extras

splash/lua_modules/request.lua

@@ -8,16 +8,19 @@ local Request = wraputils.create_metatable()
 local Request_private = {}
 
 function Request._create(py_request)
-  local self = {
+  local request = {
     info=py_request.info,
     headers=treat.as_case_insensitive(py_request.headers),
     url=py_request.url,
     method=py_request.method,
   }
-  setmetatable(self, Request)
 
-  wraputils.wrap_exposed_object(py_request, self, Request, Request_private, false)
-  return self
+  setmetatable(request, Request)
+  Request.__index = Request
+  Request.__newindex = rawset
+
+  wraputils.wrap_exposed_object(py_request, request, Request, Request_private, false)
+  return request
 end
 
 return Request

splash/lua_modules/response.lua

@@ -9,14 +9,16 @@ local Response = wraputils.create_metatable()
 local Response_private = {}
 
 function Response._create(py_response)
-  local self = {
+  local response = {
     headers=treat.as_case_insensitive(py_response.headers),
     request=Request._create(py_response.request),
   }
-  setmetatable(self, Response)
+  setmetatable(response, Response)
+  Response.__index = Response
+  Response.__newindex = rawset
 
-  wraputils.wrap_exposed_object(py_response, self, Response, Response_private, false)
-  return self
+  wraputils.wrap_exposed_object(py_response, response, Response, Response_private, false)
+  return response
 end
 
 

splash/lua_modules/splash.lua

@@ -14,10 +14,12 @@ local Splash = wraputils.create_metatable()
 local Splash_private = {}
 
 function Splash._create(py_splash)
-  local self = {args=py_splash.args}
-  setmetatable(self, Splash)
-  wraputils.wrap_exposed_object(py_splash, self, Splash, Splash_private, true)
-  return self
+  local splash = { args = py_splash.args }
+  setmetatable(splash, Splash)
+  Splash.__index = Splash
+  Splash.__newindex = rawset
+  wraputils.wrap_exposed_object(py_splash, splash, Splash, Splash_private, true)
+  return splash
 end
 
 --
@@ -46,7 +48,7 @@ function Splash:on_response_headers(cb)
   if type(cb) ~= 'function' then
     error("splash:on_response_headers callback is not a function", 2)
   end
-  Splash_private.on_response_headers(self, function (response)
+  Splash_private.on_response_headers(self, function(response)
     local res = Response._create(response)
     return cb(res)
   end)
@@ -56,7 +58,7 @@ function Splash:on_response(cb)
   if type(cb) ~= 'function' then
     error("splash:on_response callback is not a function", 2)
   end
-  Splash_private.on_response(self, function (response)
+  Splash_private.on_response(self, function(response)
     local res = Response._create(response)
     return cb(res)
   end)
@@ -70,10 +72,12 @@ local Timer = wraputils.create_metatable()
 local Timer_private = {}
 
 function Timer._create(py_timer)
-  local self = {}
-  setmetatable(self, Timer)
-  wraputils.wrap_exposed_object(py_timer, self, Timer, Timer_private, true)
-  return self
+  local timer = {}
+  setmetatable(timer, Timer)
+  Timer.__index = Timer
+  Timer.__newindex = rawset
+  wraputils.wrap_exposed_object(py_timer, timer, Timer, Timer_private, true)
+  return timer
 end
 
 function Splash:call_later(cb, delay)

splash/lua_modules/wraputils.lua

@@ -134,32 +134,33 @@ end
 -- Handle @lua_property decorators.
 --
 local function setup_property_access(py_object, self, cls)
-  local setters = {}
-  local getters = {}
+  self.setters = {}
+  self.getters = {}
+
   for name, opts in pairs(py_object.lua_properties) do
-    getters[name] = unwraps_python_result(drops_self_argument(py_object[opts.getter]))
+    self.getters[name] = unwraps_python_result(drops_self_argument(py_object[opts.getter]))
     if opts.setter ~= nil then
-      setters[name] = unwraps_python_result(drops_self_argument(py_object[opts.setter]))
+      self.setters[name] = unwraps_python_result(drops_self_argument(py_object[opts.setter]))
     else
-      setters[name] = function()
+      self.setters[name] = function()
         error("Attribute " .. name .. " is read-only.", 2)
       end
     end
   end
 
-  function cls:__newindex(index, value)
-    if setters[index] then
-      return setters[index](self, value)
+  function cls:__index(index)
+    if self.getters[index] then
+      return self.getters[index](self)
     else
-      return rawset(cls, index, value)
+      return rawget(cls, index)
     end
   end
 
-  function cls:__index(index)
-    if getters[index] then
-      return getters[index](self)
+  function cls:__newindex(index, value)
+    if self.setters[index] then
+      return self.setters[index](self, value)
     else
-      return rawget(cls, index)
+      return rawset(self, index, value)
     end
   end
 end

splash/tests/test_execute_callbacks.py

@@ -834,6 +834,35 @@ def test_error_handled_in_callback(self):
         self.assertStatusCode(resp, 200)
         self.assertEqual(resp.text, "error")
 
+    def test_multiple_calls(self):
+        resp = self.request_lua("""
+        local treat = require('treat')
+        function main(splash)
+          local o = {false, false, false, false, false, false}
+
+          local timer1 = splash:call_later(function() o[1] = true end, 0.5)
+          local timer2 = splash:call_later(function() o[2] = true end, 0.5)
+          local timer3 = splash:call_later(function() o[3] = true end, 0.5)
+          local timer4 = splash:call_later(function() o[4] = true end, 0.5)
+          local timer5 = splash:call_later(function() o[5] = true end, 0.5)
+          local timer6 = splash:call_later(function() o[6] = true end, 0.5)
+
+          timer1:cancel()
+          timer2:cancel()
+          timer3:cancel()
+          timer4:cancel()
+          timer5:cancel()
+          timer6:cancel()
+
+          splash:wait(1)
+
+          return treat.as_array(o)
+        end
+        """)
+
+        self.assertStatusCode(resp, 200)
+        self.assertEqual(resp.json(), [False, False, False, False, False, False])
+
 
 class WithTimeoutTest(BaseLuaRenderTest):
     def test_with_timeout(self):