Adds requires feature - Closes #90

Function name for getting the status was actually changed to status in all places... being consistent, yay

docs/source/api/protected_function.rst

@@ -1,7 +1,7 @@
 protected_function
 ==================
-Lua function calls that trap errors and provide error handler
+Lua function calls that trap errors and provide error handling
--------------------------------------------------------------
+--------------------------------------------------------------
 
 .. code-block:: cpp
 	

docs/source/api/proxy.rst

@@ -176,8 +176,8 @@ stack_proxy
 
 .. _note 1:
 
-On Function Objects and proxies
+on function objects and proxies
-----------------------------------
+-------------------------------
 
 Consider the following:
 

docs/source/features.rst

@@ -92,7 +92,7 @@ Explanations for a few categories are below (rest are self-explanatory).
 |                           |   plain C   | luawrapper | lua-intf | luabind |  Selene  |    Sol2   |   oolua   |   lua-api-pp   |  kaguya  |    SLB   |    SWIG   | luacppinterface | luwra  |
 |                           |             |            |          |         |          |           |           |                |          |          |           |                 |        |
 +===========================+=============+============+==========+=========+==========+===========+===========+================+==========+==========+===========+=================+========+
-| optional                  |      ~      |     ✗      |     ✗    |    ✗    |     ✗    |     ✔     |     ✗     |        ✗       |     ✗    |     ✗    |     ✗     |        ✗        |    ✗   |
+| optional                  |      ~      |     ✗      |     ✔    |    ✗    |     ✗    |     ✔     |     ✗     |        ✗       |     ✗    |     ✗    |     ✗     |        ✗        |    ✗   |
 +---------------------------+-------------+------------+----------+---------+----------+-----------+-----------+----------------+----------+----------+-----------+-----------------+--------+
 | tables                    |      ~      |     ~      |     ~    |    ✔    |     ✔    |     ✔     |     ~     |        ✔       |     ✔    |     ✗    |     ✗     |        ~        |    ✔   |
 +---------------------------+-------------+------------+----------+---------+----------+-----------+-----------+----------------+----------+----------+-----------+-----------------+--------+
@@ -114,11 +114,11 @@ Explanations for a few categories are below (rest are self-explanatory).
 +---------------------------+-------------+------------+----------+---------+----------+-----------+-----------+----------------+----------+----------+-----------+-----------------+--------+
 | protected function        |      ~      |     ✗      |     ~    |    ~    |     ~    |     ✔     |     ~     |        ✔       |     ~    |     ~    |     ~     |        ~        |    ~   |
 +---------------------------+-------------+------------+----------+---------+----------+-----------+-----------+----------------+----------+----------+-----------+-----------------+--------+
-| multi-return              |      ~      |     ✗      |     ✔    |    ✔    |     ✔    |     ✔     |     ~     |        ✔       |     ✔    |     ~    |     ✔     |        ~        |    ~   |
+| multi-return              |      ~      |     ✗      |     ✔    |    ✔    |     ✔    |     ✔     |     ~     |        ✔       |     ✔    |     ~    |     ✔     |        ~        |    ✔   |
 +---------------------------+-------------+------------+----------+---------+----------+-----------+-----------+----------------+----------+----------+-----------+-----------------+--------+
 | variadic/variant argument |      ~      |     ✔      |     ✔    |    ✔    |     ✔    |     ✔     |     ~     |        ✔       |     ✔    |     ~    |     ~     |        ~        |    ✗   |
 +---------------------------+-------------+------------+----------+---------+----------+-----------+-----------+----------------+----------+----------+-----------+-----------------+--------+
-| inheritance               |      ~      |     ✔      |     ~    |    ✔    |     ✔    |     ✔     |     ~     |        ~       |     ✔    |     ~    |     ✔     |        ~        |    ✗   |
+| inheritance               |      ~      |     ✔      |     ✔    |    ✔    |     ✔    |     ✔     |     ~     |        ~       |     ✔    |     ~    |     ✔     |        ~        |    ✗   |
 +---------------------------+-------------+------------+----------+---------+----------+-----------+-----------+----------------+----------+----------+-----------+-----------------+--------+
 | overloading               |      ~      |     ✗      |     ✗    |    ✗    |     ✗    |     ✔     |     ✗     |        ✗       |     ✔    |     ✔    |     ✔     |        ✗        |    ✗   |
 +---------------------------+-------------+------------+----------+---------+----------+-----------+-----------+----------------+----------+----------+-----------+-----------------+--------+
@@ -126,17 +126,17 @@ Explanations for a few categories are below (rest are self-explanatory).
 +---------------------------+-------------+------------+----------+---------+----------+-----------+-----------+----------------+----------+----------+-----------+-----------------+--------+
 | coroutines                |      ~      |     ✗      |     ~    |    ✔    |     ✔    |     ✔     |     ✗     |        ✗       |     ✔    |     ✗    |     ✗     |        ✔        |    ✗   |
 +---------------------------+-------------+------------+----------+---------+----------+-----------+-----------+----------------+----------+----------+-----------+-----------------+--------+
-| no-rtti support           |      ✔      |     ✗      |     ✔    |    ✗    |     ✗    |     ✔     |     ✔     |        ✗       |     ✔    |     ✔    |     ~     |        ✔        |    ~   |
+| no-rtti support           |      ✔      |     ✗      |     ✔    |    ✗    |     ✗    |     ✔     |     ✔     |        ✗       |     ✔    |     ✔    |     ~     |        ✔        |    ✔   |
 +---------------------------+-------------+------------+----------+---------+----------+-----------+-----------+----------------+----------+----------+-----------+-----------------+--------+
-| no-exception support      |      ✔      |     ✗      |     ✔    |    ~    |     ✗    |     ✔     |     ✔     |        ✗       |     ✔    |     ✔    |     ~     |        ✔        |    ✗   |
+| no-exception support      |      ✔      |     ✗      |     ✔    |    ~    |     ✗    |     ✔     |     ✔     |        ✗       |     ✔    |     ✔    |     ~     |        ✔        |    ✔   |
 +---------------------------+-------------+------------+----------+---------+----------+-----------+-----------+----------------+----------+----------+-----------+-----------------+--------+
-| Lua 5.1                   |      ✔      |     ✔      |     ✔    |    ✔    |     ✗    |     ✔     |     ✔     |        ✔       |     ✔    |     ✔    |     ✔     |        ✗        |    ~   |
+| Lua 5.1                   |      ✔      |     ✔      |     ✔    |    ✔    |     ✗    |     ✔     |     ✔     |        ✔       |     ✔    |     ✔    |     ✔     |        ✗        |    ✔   |
 +---------------------------+-------------+------------+----------+---------+----------+-----------+-----------+----------------+----------+----------+-----------+-----------------+--------+
 | Lua 5.2                   |      ✔      |     ✔      |     ✔    |    ✔    |     ✔    |     ✔     |     ✔     |        ✔       |     ✔    |     ✔    |     ✔     |        ✔        |    ✔   |
 +---------------------------+-------------+------------+----------+---------+----------+-----------+-----------+----------------+----------+----------+-----------+-----------------+--------+
 | Lua 5.3                   |      ✔      |     ✔      |     ✔    |    ✔    |     ✔    |     ✔     |     ✔     |        ✔       |     ✔    |     ✔    |     ✔     |        ✔        |    ✔   |
 +---------------------------+-------------+------------+----------+---------+----------+-----------+-----------+----------------+----------+----------+-----------+-----------------+--------+
-| luajit                    |      ✔      |     ✔      |     ✔    |    ✔    |     ~    |     ✔     |     ✔     |        ✔       |     ✔    |     ✔    |     ✔     |        ✗        |    ~   |
+| luajit                    |      ✔      |     ✔      |     ✔    |    ✔    |     ~    |     ✔     |     ✔     |        ✔       |     ✔    |     ✔    |     ✔     |        ✗        |    ✔   |
 +---------------------------+-------------+------------+----------+---------+----------+-----------+-----------+----------------+----------+----------+-----------+-----------------+--------+
 | distribution              |   compile   |    header  |   both   | compile |  header  |   header  |  compile  |     compile    |  header  |  compile | generated |     compile     | header |
 +---------------------------+-------------+------------+----------+---------+----------+-----------+-----------+----------------+----------+----------+-----------+-----------------+--------+
@@ -250,7 +250,7 @@ oolua -
 
 luwra - 
 
-* How do you store stateful functors / lambas ? Cannot find a way to support
+* How do you store stateful functors / lambas? So far, no support for such.
 * Cannot pull functions without first leaving them on the stack: manual cleanup becomes a thing
 * Doesn't understand ``std::function`` conversions and the like (but with some extra code can get it to work)
 * Recently improved by a lot: can chain tables and such, even if performance is a bit sad for that use case

sol/load_result.hpp

@@ -72,12 +72,12 @@ namespace sol {
 
     public:
         load_result() = default;
-        load_result(lua_State* L, int index = -1, int returncount = 0, int popcount = 0, load_status err = load_status::ok) : L(L), index(index), returncount(returncount), popcount(popcount), err(err) {
+        load_result(lua_State* L, int index = -1, int returncount = 0, int popcount = 0, load_status err = load_status::ok) noexcept : L(L), index(index), returncount(returncount), popcount(popcount), err(err) {
 
         }
         load_result(const load_result&) = default;
         load_result& operator=(const load_result&) = default;
-        load_result(load_result&& o) : L(o.L), index(o.index), returncount(o.returncount), popcount(o.popcount), err(o.err) {
+        load_result(load_result&& o) noexcept : L(o.L), index(o.index), returncount(o.returncount), popcount(o.popcount), err(o.err) {
             // Must be manual, otherwise destructor will screw us
             // return count being 0 is enough to keep things clean
             // but we will be thorough
@@ -87,7 +87,7 @@ namespace sol {
             o.popcount = 0;
             o.err = load_status::syntax;
         }
-        load_result& operator=(load_result&& o) {
+        load_result& operator=(load_result&& o) noexcept {
             L = o.L;
             index = o.index;
             returncount = o.returncount;
@@ -104,12 +104,12 @@ namespace sol {
             return *this;
         }
 
-        load_status error() const {
+        load_status status() const noexcept {
             return err;
         }
 
-        bool valid() const {
+        bool valid() const noexcept {
-            return error() == load_status::ok;
+            return status() == load_status::ok;
         }
 
         template<typename T>
@@ -127,8 +127,8 @@ namespace sol {
             return call<>(std::forward<Args>(args)...);
         }
 
-        lua_State* lua_state() const { return L; };
+        lua_State* lua_state() const noexcept { return L; };
-        int stack_index() const { return index; };
+        int stack_index() const noexcept { return index; };
 
         ~load_result() {
             stack::remove(L, index, popcount);

sol/protected_function_result.hpp

@@ -73,12 +73,12 @@ private:
 
 public:
     protected_function_result() = default;
-    protected_function_result(lua_State* L, int index = -1, int returncount = 0, int popcount = 0, call_status err = call_status::ok): L(L), index(index), returncount(returncount), popcount(popcount), err(err) {
+    protected_function_result(lua_State* L, int index = -1, int returncount = 0, int popcount = 0, call_status err = call_status::ok) noexcept : L(L), index(index), returncount(returncount), popcount(popcount), err(err) {
         
     }
     protected_function_result(const protected_function_result&) = default;
     protected_function_result& operator=(const protected_function_result&) = default;
-    protected_function_result(protected_function_result&& o) : L(o.L), index(o.index), returncount(o.returncount), popcount(o.popcount), err(o.err) {
+    protected_function_result(protected_function_result&& o) noexcept : L(o.L), index(o.index), returncount(o.returncount), popcount(o.popcount), err(o.err) {
         // Must be manual, otherwise destructor will screw us
         // return count being 0 is enough to keep things clean
         // but we will be thorough
@@ -88,7 +88,7 @@ public:
         o.popcount = 0;
         o.err = call_status::runtime;
     }
-    protected_function_result& operator=(protected_function_result&& o) {
+    protected_function_result& operator=(protected_function_result&& o) noexcept {
         L = o.L;
         index = o.index;
         returncount = o.returncount;
@@ -105,12 +105,12 @@ public:
         return *this;
     }
 
-    call_status error() const {
+    call_status status() const noexcept {
         return err;
     }
 
-    bool valid() const {
+    bool valid() const noexcept {
-        return error() == call_status::ok || error() == call_status::yielded;
+        return status() == call_status::ok || status() == call_status::yielded;
     }
 
     template<typename T>
@@ -118,8 +118,8 @@ public:
         return tagged_get(types<meta::unqualified_t<T>>());
     }
 
-    lua_State* lua_state() const { return L; };
+    lua_State* lua_state() const noexcept { return L; };
-    int stack_index() const { return index; };
+    int stack_index() const noexcept { return index; };
 
     ~protected_function_result() {
         stack::remove(L, index, popcount);

sol/state_view.hpp

@@ -49,6 +49,24 @@ private:
     lua_State* L;
     table reg;
     global_table global;
+
+    template <typename T>
+    void ensure_package(const std::string& key, T&& sr) {
+        auto pkg = (*this)["package"];
+        if (!pkg.valid()) {
+            pkg = create_table_with("loaded", create_table_with(key, sr));
+        }
+	   else {
+            auto ld = pkg["loaded"];
+            if (!ld.valid()) {
+                ld = create_table_with(key, sr);
+            }
+            else {
+                ld[key] = sr;
+            }
+        }
+    }
+
 public:
     typedef global_table::iterator iterator;
     typedef global_table::const_iterator const_iterator;
@@ -132,11 +150,13 @@ public:
             case lib::ffi:
 #ifdef SOL_LUAJIT
                 luaL_requiref(L, "ffi", luaopen_ffi, 1);
+                lua_pop(L, 1);
 #endif
                 break;
             case lib::jit:
 #ifdef SOL_LUAJIT
                 luaL_requiref(L, "jit", luaopen_jit, 1);
+                lua_pop(L, 1);
 #endif
                 break;
             case lib::count:
@@ -146,6 +166,44 @@ public:
         }
     }
 
+    template <typename Fx>
+    object require(const std::string& key, Fx&& open_function, bool is_global_library = true) {
+        auto openfx = [fx = std::forward<Fx>(open_function)](lua_State* L){ 
+            typedef lua_bind_traits<meta::unqualified_t<Fx>> traits;
+            return stack::call(typename traits::return_type(), typename traits::args_type(), L, fx); 
+        };
+        stack::push(L, function_args<function_sig<>>(std::forward<Fx>(openfx)));
+	   lua_CFunction openf = stack::pop<lua_CFunction>(L);
+        luaL_requiref(L, key.c_str(), openf, is_global_library ? 1 : 0);
+        object r stack::pop<object>(L);
+	   lua_pop(L, 1);
+	   return r;
+    }
+
+    object require_script(const std::string& key, const std::string& code) {
+        optional<object> loaded = traverse_get<optional<object>>("package", "loaded", key);
+        bool ismod = loaded && !(loaded->is<bool>() && !loaded->as<bool>());
+        if (ismod)
+            return std::move(*loaded);
+        script(code);
+        auto sr = stack::get<stack_reference>(L);
+        set(key, sr);
+        ensure_package(key, sr);
+	   return stack::pop<object>(L);
+    }
+
+    object require_file(const std::string& key, const std::string& file) {
+        auto loaded = traverse_get<optional<object>>("package", "loaded", key);
+        bool ismod = loaded && !(loaded->is<bool>() && !loaded->as<bool>());
+        if (loaded)
+            return std::move(*loaded);
+        script_file(file);
+        auto sr = stack::get<stack_reference>(L);
+        set(key, sr);
+        ensure_package(key, sr);
+	   return stack::pop<object>(L);
+    }
+
     void script(const std::string& code) {
         if(luaL_dostring(L, code.c_str())) {
             lua_error(L);

sol/table_core.hpp

@@ -156,8 +156,15 @@ public:
     typedef iterator const_iterator;
 
     basic_table_core( ) noexcept : base_t( ) { }
-    template <typename T, meta::enable<meta::boolean<!top_level>, meta::neg<std::is_same<meta::unqualified_t<T>, basic_table_core>>, std::is_same<meta::unqualified_t<T>, global_table>> = meta::enabler>
+    template <typename T, meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_table_core>>, std::is_base_of<base_t, meta::unqualified_t<T>>> = meta::enabler>
-    basic_table_core( T&& r ) noexcept : base_t( std::forward<T>(r) ) { }
+    basic_table_core( T&& r ) noexcept : base_t( std::forward<T>(r) ) {
+#ifdef SOL_CHECK_ARGUMENTS
+        if (!is_table<meta::unqualified_t<T>>::value) {
+            auto pp = stack::push_pop(*this);
+            stack::check<basic_table_core>(base_t::lua_state(), -1, type_panic);
+        }
+#endif // Safety
+    }
     basic_table_core(const basic_table_core&) = default;
     basic_table_core(basic_table_core&&) = default;
     basic_table_core& operator=(const basic_table_core&) = default;

sol/types.hpp

@@ -547,6 +547,12 @@ public:
 	static const std::size_t arity = base_t::arity - meta::count_for<is_transparent_argument, typename base_t::args_type>::value;
 };
 
+template <typename T>
+struct is_table : std::false_type {};
+
+template <bool x, typename T>
+struct is_table<basic_table_core<x, T>> : std::true_type {};
+
 template<typename T>
 inline type type_of() {
     return lua_type_of<meta::unqualified_t<T>>::value;

test_strings.cpp

@@ -69,3 +69,19 @@ TEST_CASE("stack/strings", "test that strings can be roundtripped") {
     REQUIRE(wide_to_char32 == utf32str[0]);
 }
 #endif // Shit C++
+
+
+TEST_CASE("state/strings", "opening strings as 'requires' clauses") {
+    std::string code = "return { modfunc = function () return 221 end }";
+
+    sol::state lua;
+    sol::table thingy1 = lua.require_script("thingy", code);
+    sol::table thingy2 = lua.require_script("thingy", code);
+
+    int val1 = thingy1["modfunc"]();
+    int val2 = thingy2["modfunc"]();
+    REQUIRE(val1 == 221);
+    REQUIRE(val2 == 221);
+    // must have loaded the same table
+    REQUIRE(thingy1 == thingy2);   
+}