Improved LuaRef call with handler

Source/LuaBridge/detail/Invoke.h

@@ -103,6 +103,29 @@ class LuaResult
  return LuaRef(m_L);
  }
 
+#if LUABRIDGE_HAS_EXCEPTIONS
+ /**
+ * @brief
+ */
+ void raiseException() const
+ {
+ if (wasOk())
+ return;
+
+ if (std::holds_alternative<std::string>(m_data))
+ {
+ const auto& message = std::get<std::string>(m_data);
+ lua_pushlstring(m_L, message.c_str(), message.size());
+ }
+ else
+ {
+ lua_pushlstring(m_L, m_ec.message().c_str(), m_ec.message().size());
+ }
+
+ throw LuaException::fromStack(m_L, m_ec);
+ }
+#endif
+
 private:
  template <class... Args>
  friend LuaResult call(const LuaRef&, Args&&...);
@@ -253,7 +276,17 @@ template <class Impl, class LuaRef>
 template <class F, class... Args>
 LuaResult LuaRefBase<Impl, LuaRef>::callWithHandler(F&& errorHandler, Args&&... args) const
 {
- return luabridge::callWithHandler(*this, std::forward<F>(errorHandler), std::forward<Args>(args)...);
+ if constexpr (! std::is_convertible_v<F, bool>)
+ {
+ return luabridge::callWithHandler(*this, std::forward<F>(errorHandler), std::forward<Args>(args)...);
+ }
+ else
+ {
+ if (errorHandler)
+ return luabridge::callWithHandler(*this, std::forward<F>(errorHandler), std::forward<Args>(args)...);
+ }
+
+ return luabridge::call(*this, std::forward<Args>(args)...);
 }
 
 } // namespace luabridge

Source/LuaBridge/detail/LuaException.h

@@ -55,7 +55,7 @@ class LuaException : public std::exception
  LUABRIDGE_ASSERT(areExceptionsEnabled(L));
 
 #if LUABRIDGE_HAS_EXCEPTIONS
- throw LuaException(L, code, FromLua{});
+ throw LuaException::fromStack(L, code);
 #else
  unused(L, code);
 
@@ -103,6 +103,19 @@ class LuaException : public std::exception
 #endif
  }
 
+ //=============================================================================================
+ /**
+ * @brief Construct a LuaException from stack.
+ *
+ * @return A Lua exception from stack.
+ */
+ static LuaException fromStack(lua_State* L, std::error_code code = makeErrorCode(ErrorCode::LuaFunctionCallFailed))
+ {
+ auto exception = LuaException(L, code);
+ exception.whatFromStack();
+ return exception;
+ }
+
  //=============================================================================================
  /**
  * @brief Retrieve the lua_State associated with the exception.
@@ -112,15 +125,6 @@ class LuaException : public std::exception
  lua_State* state() const { return m_L; }
 
 private:
- struct FromLua {};
-
- LuaException(lua_State* L, std::error_code code, FromLua)
- : m_L(L)
- , m_code(code)
- {
- whatFromStack();
- }
-
  void whatFromStack()
  {
  std::stringstream ss;
@@ -141,7 +145,7 @@ class LuaException : public std::exception
  static int panicHandlerCallback(lua_State* L)
  {
 #if LUABRIDGE_HAS_EXCEPTIONS
- throw LuaException(L, makeErrorCode(ErrorCode::LuaFunctionCallFailed), FromLua{});
+ throw LuaException::fromStack(L);
 #else
  unused(L);
 

Tests/Source/LuaRefTests.cpp

@@ -510,18 +510,39 @@ TEST_F(LuaRefTests, Callable)
  EXPECT_EQ(200, obj["i"].unsafe_cast<int>());
 }
 
-TEST_F(LuaRefTests, CallableWithHandler)
+#if LUABRIDGE_HAS_EXCEPTIONS
+TEST_F(LuaRefTests, CallableWithThrowingHandler)
+{
+ runLua("function f(x) error('we failed ' .. x) end");
+ auto f = luabridge::getGlobal(L, "f");
+ EXPECT_TRUE(f.isCallable());
+
+ bool calledHandler = false;
+ auto handler = [&](lua_State*) -> int
+ {
+ calledHandler = true;
+ return 0;
+ };
+
+ EXPECT_ANY_THROW(f.callWithHandler(handler, "badly").raiseException());
+ EXPECT_TRUE(calledHandler);
+}
+#endif
+
+TEST_F(LuaRefTests, CallableWithAndWithoutHandler)
 {
  runLua("function f(x) error('we failed ' .. x) end");
  auto f = luabridge::getGlobal(L, "f");
  EXPECT_TRUE(f.isCallable());
 
+ // Call without
 #if LUABRIDGE_HAS_EXCEPTIONS
  EXPECT_ANY_THROW(f.call("badly"));
 #else
  EXPECT_FALSE(f.call("badly"));
 #endif
 
+ // Call with
  bool calledHandler = false;
  std::string errorMessage;
  auto handler = [&](lua_State*) -> int
@@ -540,6 +561,66 @@ TEST_F(LuaRefTests, CallableWithHandler)
  EXPECT_TRUE(errorMessage.find("we failed badly") != std::string::npos);
 }
 
+TEST_F(LuaRefTests, CallableWithStdFunction)
+{
+ runLua("function f(x) error('we failed ' .. x) end");
+ auto f = luabridge::getGlobal(L, "f");
+ EXPECT_TRUE(f.isCallable());
+
+ bool calledHandler = false;
+ std::string errorMessage;
+ auto handler = [&](lua_State*) -> int
+ {
+ calledHandler = true;
+
+ if (auto msg = lua_tostring(L, 1))
+ errorMessage = msg;
+
+ return 0;
+ };
+
+ std::function<int(lua_State*)> pHandler = handler;
+
+ EXPECT_FALSE(f.callWithHandler(pHandler, "badly"));
+ EXPECT_TRUE(calledHandler);
+ EXPECT_TRUE(errorMessage.find("we failed badly") != std::string::npos);
+}
+
+TEST_F(LuaRefTests, CallableWithNullifiedStdFunction)
+{
+ runLua("function f(x) error('we failed ' .. x) end");
+ auto f = luabridge::getGlobal(L, "f");
+ EXPECT_TRUE(f.isCallable());
+
+ std::function<int(lua_State*)> pHandler = nullptr;
+ EXPECT_FALSE(f.callWithHandler(pHandler, "badly"));
+}
+
+TEST_F(LuaRefTests, CallableWithCFunction)
+{
+ runLua("function f(x) error('we failed ' .. x) end");
+ auto f = luabridge::getGlobal(L, "f");
+ EXPECT_TRUE(f.isCallable());
+
+ lua_CFunction pHandler = +[](lua_State* L) { return 0; };
+ EXPECT_FALSE(f.callWithHandler(pHandler, "badly"));
+}
+
+TEST_F(LuaRefTests, CallableWithNullCFunction)
+{
+ runLua("function f(x) error('we failed ' .. x) end");
+ auto f = luabridge::getGlobal(L, "f");
+ EXPECT_TRUE(f.isCallable());
+
+ lua_CFunction pHandler = nullptr;
+
+#if LUABRIDGE_HAS_EXCEPTIONS
+ EXPECT_ANY_THROW(f.callWithHandler(pHandler, "badly"));
+#else
+ EXPECT_FALSE(f.callWithHandler(pHandler, "badly"));
+#endif
+}
+
 TEST_F(LuaRefTests, Pop)
 {
  lua_pushstring(L, "hello");