sweet-moon 0.0.1 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1e1ed99acf5622e7a68168e97a5543a952da6cbd057b29d35dcac167cdd7ed3e
-  data.tar.gz: 30ffaf5cd2c96429114950db5e44c39c328cdefeb711df44eba1d5b288d34a1e
+  metadata.gz: bdfabe100158948ea2c29fadca09e82cd9567d71230627f6bd0e8ba3a04f523d
+  data.tar.gz: 3bb2925b0ef437c3942a837a67bb94261d89c9aaf5a011973dcf4b98db07e6b9
 SHA512:
-  metadata.gz: 375db63fb25932d6d1e0d1fda599c996a62efd2f51691528785e34b2bba37078dcb98db1f05f669375759852671cf0792aed27110fea91e8d351406ba219823f
-  data.tar.gz: bd4732726abfb6f8ce2dcf0b4bc81d858bb03d9cde60610f0e02372e29c2951cf47f2b2d6cebd3f2eb5d25b23daa29ec6097f8603e578d4dfcd572486b3c1eee
+  metadata.gz: 582a792771b05e59a577349070709e78bb2a569ef14cdb955fb2666e826eb401ba4aa4e7b19297c30fd64f98eda244d656caf2e904f9c1af95e971807aed8820
+  data.tar.gz: 38307987e564f998b40b2792fd97a3e107095d6e46992689663d63d67bf248dfc16c3a8838f8461bf7a8765857e7b5c04da4e4ac3c636cd6a419abb85bab2e5b

data/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2022 Guilherme Baptista
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -1,4 +1,5 @@
 # Sweet Moon
+[![Gem Version](https://badge.fury.io/rb/sweet-moon.svg)](https://badge.fury.io/rb/sweet-moon)
 
 _Sweet Moon_ is a resilient solution that makes working with [Lua](https://www.lua.org) / [Fennel](https://fennel-lang.org) from [Ruby](https://www.ruby-lang.org) and vice versa a delightful experience.
 
@@ -20,12 +21,15 @@ _Sweet Moon_ is a resilient solution that makes working with [Lua](https://www.l
     - [Tables, Arrays, and Hashes](#tables-arrays-and-hashes)
     - [Functions](#functions)
     - [Other Types](#other-types)
+    - [Lua Global vs Local Variables](#lua-global-vs-local-variables)
   - [_destroy_ and _clear_](#destroy-and-clear)
 - [Modules, Packages and LuaRocks](#modules-packages-and-luarocks)
   - [Integration with LuaRocks](#integration-with-luarocks)
 - [Fennel](#fennel)
   - [Fennel Usage](#fennel-usage)
+  - [Fennel Global vs Local Variables](#fennel-global-vs-local-variables)
   - [Fennel Setup](#fennel-setup)
+  - [Integration with fnx](#integration-with-fnx)
 - [Global vs Isolated](#global-vs-isolated)
 - [Error Handling](#error-handling)
 - [Where can I find .so files?](#where-can-i-find-so-files)
@@ -38,6 +42,9 @@ _Sweet Moon_ is a resilient solution that makes working with [Lua](https://www.l
     - [Lua 5.4](#lua-54)
     - [Lua 4.0](#lua-40)
 - [Development](#development)
+  - [Tests Setup](#tests-setup)
+  - [Running](#running)
+  - [Supporting New Versions](#supporting-new-versions)
 
 ## Supported Versions
 
@@ -64,7 +71,7 @@ gem install sweet-moon
 > **Disclaimer:** It's an early-stage project, and you should expect breaking changes.
 
 ```ruby
-gem 'sweet-moon', '~> 0.0.1'
+gem 'sweet-moon', '~> 0.0.4'
 ```
 
 ```ruby
@@ -204,6 +211,7 @@ Compared to: [rufus-lua](https://github.com/jmettraux/rufus-lua), [YAML](https:/
   - [Tables, Arrays, and Hashes](#tables-arrays-and-hashes)
   - [Functions](#functions)
   - [Other Types](#other-types)
+  - [Lua Global vs Local Variables](#lua-global-vs-local-variables)
 - [_destroy_ and _clear_](#destroy-and-clear)
 
 ### Setup
@@ -384,6 +392,20 @@ state.eval('lua_value = {a = "text", b = 1.5, c = true}') # => nil
 state.get(:lua_value, :b) # => 1.5
 ```
 
+With `set`, you can use a second parameter to set a field:
+
+```ruby
+require 'sweet-moon'
+
+state = SweetMoon::State.new
+
+state.set(:myTable, {}) # => nil
+
+state.set(:myTable, :a, 3) # => nil
+
+state.eval('return myTable["a"]') # => 3
+```
+
 Caveats:
 
 - Ruby `Symbol` (e.g. `:value`) is converted to Lua `string`.
@@ -507,6 +529,24 @@ fennel_eval = state.get(:fennel_eval)
 fennel_eval.(['(+ 1 1)']) # => 2
 ```
 
+#### Lua Global vs Local Variables
+
+You can't exchange _local_ variables, only [_global_](https://www.lua.org/pil/1.2.html) ones:
+
+```ruby
+require 'sweet-moon'
+
+state = SweetMoon::State.new
+
+state.eval('lua_value = "Lua Text"') # => nil
+
+state.get('lua_value') # => 'Lua Text'
+
+state.eval('local lua_b = "b"') # => nil
+
+state.get('lua_b') # => nil
+```
+
 ## _destroy_ and _clear_
 
 You can destroy a state:
@@ -552,8 +592,8 @@ require 'sweet-moon'
 
 state = SweetMoon::State.new
 
-state.eval('package.path = package.path .. ";/my-modules/?.lua"')
-state.eval('package.cpath = package.cpath .. ";/my-modules/?.so"')
+state.eval('package.path = "/my-modules/?.lua;" .. package.path')
+state.eval('package.cpath = "/my-modules/?.so;" .. package.cpath')
 
 state.eval('some_package = require("my_module")')
 ```
@@ -682,7 +722,7 @@ For global:
 ```ruby
 require 'sweet-moon'
 
-SweetMoon.global.config.new(
+SweetMoon.global.config(
   package_path: [
     '/home/me/.luarocks/share/lua/5.4/?.lua',
     '/home/me/.luarocks/share/lua/5.4/?/init.lua'
@@ -709,8 +749,8 @@ state = SweetMoon::State.new
 
 state.fennel.eval('(+ 1 2)') # => 3
 
-state.fennel.eval('(global mySum (fn [a b] (+ a b)))')
-state.fennel.eval('(mySum 2 3)') # => 5
+state.fennel.eval('(set _G.mySum (fn [a b] (+ a b)))')
+state.fennel.eval('(_G.mySum 2 3)') # => 5
 
 mySum = state.fennel.get(:mySum)
 
@@ -720,7 +760,7 @@ sum_list = -> (list) { list.sum }
 
 state.set('sumList', sum_list) # => nil
 
-state.fennel.eval('(sumList [2 3 5])') # => 10
+state.fennel.eval('(_G.sumList [2 3 5])') # => 10
 
 state.fennel.load('file.fnl')
 ```
@@ -735,6 +775,49 @@ state = SweetMoon::State.new.fennel
 state.eval('(+ 1 2)') # => 3
 ```
 
+### Fennel Global vs Local Variables
+
+Fennel encourages you to explicitly use the [_`_G`_](https://www.lua.org/manual/5.4/manual.html#pdf-_G) table to access global variables:
+
+```ruby
+require 'sweet-moon'
+
+fennel = SweetMoon::State.new.fennel
+
+fennel.eval('(set _G.a? 2)')
+
+fennel.get('a?') # => 2
+fennel.get('_G', 'a?') # => 2
+
+fennel.set('b', 3)
+
+fennel.eval('(print _G.b)') # => 3
+```
+
+Although older versions have the expression `(global name "value")`, it's deprecated, and you should avoid using that. _Sweet Moon_ has no commitments in supporting this deprecated expression, and you should prefer the `_G` way.
+
+As is [true for Lua](#lua-global-vs-local-variables), you can't exchange _local_ variables, only [_global_](https://www.lua.org/pil/1.2.html) ones:
+
+```ruby
+require 'sweet-moon'
+
+fennel = SweetMoon::State.new.fennel
+
+fennel.eval('(local name "value")')
+
+fennel.get('name') # => nil
+
+fennel.eval('(set _G.name "value")')
+
+fennel.get('name') # => "value"
+
+fennel.set('var-b', 35) # => nil
+
+fennel.eval('var-b') # => nil
+
+fennel.eval('_G.var-b') # => 35
+```
+
 ### Fennel Setup
 
 To ensure that the Fennel module is available, you can set up the [_LuaRocks_](#integration-withluarocks) integration or manually add the `package_path` for the module.
@@ -783,6 +866,28 @@ SweetMoon.global.config(package_path: '/folder/fennel.lua')
 SweetMoon.global.state.fennel.eval('(+ 1 1)') # => 2
 ```
 
+### Integration with fnx
+
+[fnx](https://github.com/gbaptista/fnx) is a package manager for the Fennel language.
+
+After installing `fnx` and configuring it for [_Embedding_](https://github.com/gbaptista/fnx#embedding), you can:
+
+```ruby
+require 'sweet-moon'
+
+fennel = SweetMoon::State.new.fennel
+
+fennel.eval('(let [fnx (require :fnx)] (fnx.bootstrap!))')
+```
+
+Done. It will automatically inject all your dependencies according to your `.fnx.fnl` file, similar to using the `fnx` command.
+
+To enforce the path for the `.fnx.fnl` file:
+
+```ruby
+fennel.eval('(let [fnx (require :fnx)] (fnx.bootstrap! "/project/.fnx.fnl"))')
+```
+
 ## Global vs Isolated
 
 You can use the **global** helper that provides an _API_ and a _State_ for quick-and-dirty coding. It uses internally a Ruby [_Singleton_](https://docs.ruby-lang.org/en/3.1/Singleton.html):
@@ -821,8 +926,8 @@ You may want to use an isolated API for scenarios like interacting with two Lua
 ```ruby
 require 'sweet-moon'
 
-api_5 = SweetMoon.global.config(shared_object: '/usr/lib/liblua5.s')
-api_3 = SweetMoon.global.config(shared_object: '/usr/lib/liblua3.so')
+api_5 = SweetMoon::API.new(shared_object: '/usr/lib/liblua5.s')
+api_3 = SweetMoon::API.new(shared_object: '/usr/lib/liblua3.so')
 
 api_5.luaL_newstate
 
@@ -882,7 +987,7 @@ require 'sweet-moon'
 
 begin
   SweetMoon.global.state.eval('return 1 + true')
-rescue SweetMoon::Errors::LuaSyntaxError => error
+rescue SweetMoon::Errors::LuaRuntimeError => error
   puts error.message
   # => [string "return 1 + true"]:1: attempt to perform arithmetic on a boolean value
 end
@@ -896,7 +1001,7 @@ require 'sweet-moon/errors'
 
 begin
   SweetMoon.global.state.eval('return 1 + true')
-rescue LuaSyntaxError => error
+rescue LuaRuntimeError => error
   puts error.message
   # => [string "return 1 + true"]:1: attempt to perform arithmetic on a boolean value
 end
@@ -904,9 +1009,9 @@ end
 
 ## Where can I find .so files?
 
-Due to the Lua's popularity, you likely have it already on your system, and _Sweet Moon_ will be able to find the files on its own.
+Due to the Lua's popularity, you likely have it already on your system, and _Sweet Moon_ will be able to find the files by itself.
 
-Either way, you can download it from this page:
+Either way, you can download it from:
 - [Lua Binaries](http://luabinaries.sourceforge.net)
 - [LuaJIT releases](http://luajit.org/download.html)
 
@@ -1138,6 +1243,26 @@ rubocop -a
 rspec
 ```
 
+### Tests Setup
+
+To setup tests:
+
+```
+cp config/tests.sample.yml config/tests.yml
+```
+
+Clone the [sweet-moon-test](https://github.com/gbaptista/sweet-moon-test) repo somewhere:
+
+```sh
+git clone git@github.com:gbaptista/sweet-moon-test.git
+```
+
+Update the [`config/tests.yml`](https://github.com/gbaptista/sweet-moon/blob/main/config/tests.sample.yml) accordingly.
+
+Alternatively: Find or build the _Shared Objects_ for your Operating System on your own.
+
+### Running
+
 ```sh
 ./ports/in/shell/sweet-moon version
 
@@ -1147,3 +1272,21 @@ bundle exec sweet-moon signatures /lua/lib/542 542.rb
 
 bundle exec ruby some/file.rb
 ```
+
+### Supporting New Versions
+
+Download both the source code and the libraries.
+
+Example: For [Lua 5.4.2](https://sourceforge.net/projects/luabinaries/files/5.4.2/), you would download _"Linux Libraries"_ and _"Docs and Sources."_
+
+Extract everything to a folder, e.g., `lua-542-source-libs`.
+
+Run the command to extract the signatures:
+
+```shell
+bundle exec sweet-moon signatures /home/me/lua-542-source-libs 542.rb
+```
+
+Check the `542.rb` file for the output and then start coding.
+
+You can use the [`logic/signatures`](https://github.com/gbaptista/sweet-moon/tree/main/logic/signatures) folder as a reference starting point.

data/components/interpreters/50/function.rb

@@ -9,23 +9,26 @@ module Component
     Function = {
       push!: ->(api, state, closure) {
         handler = ->(current_state) {
-          input = Reader[:read_all!].(api, current_state)
+          updated_state = state.merge(lua: current_state)
+          input = Reader[:read_all!].(api, updated_state)
           result = closure.(*input)
-          Writer[:push!].(api, current_state, result)
+          Writer[:push!].(api, updated_state, result)
           return 1
         }
 
-        api.lua_pushcclosure(state, handler, 0)
+        state[:avoid_gc] << handler
+
+        api.lua_pushcclosure(state[:lua], handler, 0)
       },
 
       read!: ->(api, state, _stack_index) {
         reference = api.luaL_ref(
-          state, Logic::V50::Interpreter[:LUA_REGISTRYINDEX]
+          state[:lua], Logic::V50::Interpreter[:LUA_REGISTRYINDEX]
         )
 
         { value: ->(input = [], output = 1) {
           api.lua_rawgeti(
-            state, Logic::V50::Interpreter[:LUA_REGISTRYINDEX], reference
+            state[:lua], Logic::V50::Interpreter[:LUA_REGISTRYINDEX], reference
           )
 
           input.each do |value|

data/components/interpreters/50/interpreter.rb

@@ -11,34 +11,40 @@ module Component
 
       create_state!: ->(api) {
         state = api.lua_open
-        { state: state, error: state ? nil : :MemoryAllocation }
+        { state: { lua: state, avoid_gc: [] },
+          error: state ? nil : :MemoryAllocation }
       },
 
       open_standard_libraries!: ->(api, state) {
-        api.luaopen_base(state)
-        api.luaopen_table(state)
-        api.luaopen_io(state)
-        api.luaopen_string(state)
-        api.luaopen_math(state)
+        api.luaopen_base(state[:lua])
+        api.luaopen_table(state[:lua])
+        api.luaopen_io(state[:lua])
+        api.luaopen_string(state[:lua])
+        api.luaopen_math(state[:lua])
 
-        api.lua_settop(state, -7 - 1)
+        api.lua_settop(state[:lua], -7 - 1)
 
         { state: state }
       },
 
       load_file_and_push_chunck!: ->(api, state, path) {
-        result = api.luaL_loadfile(state, path)
+        result = api.luaL_loadfile(state[:lua], path)
         { state: state, error: Interpreter[:_error].(api, state, result, pull: true) }
       },
 
       push_chunk!: ->(api, state, value) {
-        result = api.luaL_loadbuffer(state, value, value.size, value)
+        result = api.luaL_loadbuffer(state[:lua], value, value.size, value)
 
         { state: state, error: Interpreter[:_error].(api, state, result, pull: true) }
       },
 
-      set_table!: ->(api, state, variable, value) {
-        Table[:set!].(api, state, variable, value)
+      set_table!: ->(api, state) {
+        result = api.lua_settable(state[:lua], -3)
+
+        api.lua_settop(state[:lua], -2)
+
+        { state: state,
+          error: Interpreter[:_error].(api, state, result, pull: false) }
       },
 
       push_value!: ->(api, state, value) {
@@ -47,31 +53,38 @@ module Component
       },
 
       pop_and_set_as!: ->(api, state, variable) {
-        api.lua_pushstring(state, variable)
-        api.lua_insert(state, -2)
-        api.lua_settable(state, Logic::V50::Interpreter[:LUA_GLOBALSINDEX])
+        api.lua_pushstring(state[:lua], variable)
+        api.lua_insert(state[:lua], -2)
+        api.lua_settable(state[:lua], Logic::V50::Interpreter[:LUA_GLOBALSINDEX])
         { state: state }
       },
 
       get_variable_and_push!: ->(api, state, variable, key = nil) {
-        api.lua_pushstring(state, variable.to_s)
-        api.lua_gettable(state, Logic::V50::Interpreter[:LUA_GLOBALSINDEX])
+        extra_pop = true
+        if variable == '_G'
+          variable = key
+          key = nil
+          extra_pop = false
+        end
+
+        api.lua_pushstring(state[:lua], variable.to_s)
+        api.lua_gettable(state[:lua], Logic::V50::Interpreter[:LUA_GLOBALSINDEX])
 
         Table[:read_field_and_push!].(api, state, key, -1) unless key.nil?
 
-        { state: state }
+        { state: state, extra_pop: extra_pop }
       },
 
       call!: ->(api, state, inputs = 0, outputs = 1) {
-        result = api.lua_pcall(state, inputs, outputs, 0)
+        result = api.lua_pcall(state[:lua], inputs, outputs, 0)
         { state: state, error: Interpreter[:_error].(api, state, result, pull: true) }
       },
 
       read_and_pop!: ->(api, state, stack_index = -1, extra_pop: false) {
         result = Component::V50::Reader[:read!].(api, state, stack_index)
 
-        api.lua_settop(state, -2) if result[:pop]
-        api.lua_settop(state, -2) if extra_pop
+        api.lua_settop(state[:lua], -2) if result[:pop]
+        api.lua_settop(state[:lua], -2) if extra_pop
 
         { state: state, output: result[:value] }
       },
@@ -83,9 +96,12 @@ module Component
       },
 
       destroy_state!: ->(api, state) {
-        result = api.lua_close(state)
+        result = api.lua_close(state[:lua])
+
+        state.delete(:lua)
+        state.delete(:avoid_gc)
 
-        { state: nil, error: Interpreter[:_error].(api, state, result) }
+        { state: nil, error: Interpreter[:_error].(api, nil, result) }
       },
 
       _error: ->(api, state, code, options = {}) {
@@ -94,7 +110,7 @@ module Component
         ] || :error
 
         if code.is_a?(Numeric) && code >= 1
-          return { status: status } unless options[:pull]
+          return { status: status } unless options[:pull] && state
 
           { status: status,
             value: Interpreter[:read_and_pop!].(api, state, -1)[:output] }

data/components/interpreters/50/reader.rb

@@ -8,15 +8,16 @@ module Component
   module V50
     Reader = {
       read_all!: ->(api, state) {
-        (1..api.lua_gettop(state)).map do
+        (1..api.lua_gettop(state[:lua])).map do
           Interpreter[:read_and_pop!].(api, state)[:output]
         end.reverse
       },
 
       read!: ->(api, state, stack_index = -1) {
-        stack_index = api.lua_gettop(state) if stack_index == -1
+        stack_index = api.lua_gettop(state[:lua]) if stack_index == -1
 
-        type = api.lua_typename(state, api.lua_type(state, stack_index)).read_string
+        type = api.lua_typename(state[:lua],
+                                api.lua_type(state[:lua], stack_index)).read_string
 
         case type
         when 'string'
@@ -36,29 +37,30 @@ module Component
         else
           # none nil boolean lightuserdata number
           # string table function userdata thread
-          { value: "#{type}: 0x#{api.lua_topointer(state, stack_index).address}",
+          { value:
+              "#{type}: 0x#{api.lua_topointer(state[:lua], stack_index).address}",
             type: type, pop: true }
         end
       },
 
       read_string!: ->(api, state, stack_index) {
-        { value: api.lua_tostring(state, stack_index).read_string,
+        { value: api.lua_tostring(state[:lua], stack_index).read_string,
           pop: true }
       },
 
       read_number!: ->(api, state, stack_index) {
         if api.respond_to?(:lua_isinteger) &&
            api.respond_to?(:lua_tointeger) &&
-           api.lua_isinteger(state, stack_index) == 1
+           api.lua_isinteger(state[:lua], stack_index) == 1
 
-          return { value: api.lua_tointeger(state, stack_index), pop: true }
+          return { value: api.lua_tointeger(state[:lua], stack_index), pop: true }
         end
 
-        { value: api.lua_tonumber(state, stack_index), pop: true }
+        { value: api.lua_tonumber(state[:lua], stack_index), pop: true }
       },
 
       read_boolean!: ->(api, state, stack_index) {
-        { value: api.lua_toboolean(state, stack_index) == 1, pop: true }
+        { value: api.lua_toboolean(state[:lua], stack_index) == 1, pop: true }
       }
     }
   end

data/components/interpreters/50/table.rb

@@ -7,68 +7,70 @@ module Component
   module V50
     Table = {
       push!: ->(api, state, list, stack_index = -1) {
-        stack_index = api.lua_gettop(state) if stack_index == -1
+        stack_index = api.lua_gettop(state[:lua]) if stack_index == -1
 
-        api.lua_newtable(state)
+        api.lua_newtable(state[:lua])
 
         if list.is_a? Hash
           list.each_key do |key|
             Writer[:push!].(api, state, key)
             Writer[:push!].(api, state, list[key])
-            api.lua_settable(state, stack_index + 1)
+            api.lua_settable(state[:lua], stack_index + 1)
           end
         else
           list.each_with_index do |value, index|
             Writer[:push!].(api, state, index + 1)
             Writer[:push!].(api, state, value)
-            api.lua_settable(state, stack_index + 1)
+            api.lua_settable(state[:lua], stack_index + 1)
           end
         end
       },
 
       read!: ->(api, state, stack_index) {
-        stack_index = api.lua_gettop(state) if stack_index == -1
+        stack_index = api.lua_gettop(state[:lua]) if stack_index == -1
 
-        type = api.lua_typename(state, api.lua_type(state, stack_index)).read_string
+        type = api.lua_typename(state[:lua],
+                                api.lua_type(state[:lua], stack_index)).read_string
 
-        api.lua_pushnil(state)
+        api.lua_pushnil(state[:lua])
 
         return nil if type != 'table'
 
         tuples = []
 
-        while api.lua_next(state, stack_index).positive?
+        while api.lua_next(state[:lua], stack_index).positive?
           value = Reader[:read!].(api, state, stack_index + 2)
           key = Reader[:read!].(api, state, stack_index + 1)
-          api.lua_settop(state, -2) if value[:pop]
+          api.lua_settop(state[:lua], -2) if value[:pop]
 
           tuples << [key[:value], value[:value]]
 
-          break if value[:type] == 'no value'
+          break if value[:type] == 'no value' || key[:value].instance_of?(Proc)
         end
 
         { value: Logic::Tables[:to_hash_or_array].(tuples), pop: true }
       },
 
       read_field_and_push!: ->(api, state, expected_key, stack_index) {
-        stack_index = api.lua_gettop(state) if stack_index == -1
+        stack_index = api.lua_gettop(state[:lua]) if stack_index == -1
 
-        type = api.lua_typename(state, api.lua_type(state, stack_index)).read_string
+        type = api.lua_typename(state[:lua],
+                                api.lua_type(state[:lua], stack_index)).read_string
 
-        api.lua_pushnil(state)
+        api.lua_pushnil(state[:lua])
 
         return nil if type != 'table'
 
         result = nil
 
-        while api.lua_next(state, stack_index).positive?
+        while api.lua_next(state[:lua], stack_index).positive?
           value = Reader[:read!].(api, state, stack_index + 2)
           key = Reader[:read!].(api, state, stack_index + 1)
 
-          api.lua_settop(state, -2) if value[:pop]
+          api.lua_settop(state[:lua], -2) if value[:pop]
 
           key_type = api.lua_typename(
-            state, api.lua_type(state, stack_index + 1)
+            state[:lua], api.lua_type(state[:lua], stack_index + 1)
           ).read_string
 
           if Table[:is_same_key].(key_type, key[:value], expected_key)
@@ -76,10 +78,10 @@ module Component
             break
           end
 
-          break if value[:type] == 'no value'
+          break if value[:type] == 'no value' || key[:value].instance_of?(Proc)
         end
 
-        api.lua_settop(state, -2)
+        api.lua_settop(state[:lua], -2)
 
         Writer[:push!].(api, state, result)
       },

data/components/interpreters/50/writer.rb

@@ -7,26 +7,26 @@ module Component
       push!: ->(api, state, value) {
         case Writer[:_to_lua_type].(value)
         when 'string'
-          api.lua_pushstring(state, value.to_s)
+          api.lua_pushstring(state[:lua], value.to_s)
         when 'number'
-          api.lua_pushnumber(state, value)
+          api.lua_pushnumber(state[:lua], value)
         when 'integer'
           if api.respond_to? :lua_pushinteger
-            api.lua_pushinteger(state, value)
+            api.lua_pushinteger(state[:lua], value)
           else
-            api.lua_pushnumber(state, value)
+            api.lua_pushnumber(state[:lua], value)
           end
         when 'nil'
-          api.lua_pushnil(state)
+          api.lua_pushnil(state[:lua])
         when 'boolean'
-          api.lua_pushboolean(state, value ? 1 : 0)
+          api.lua_pushboolean(state[:lua], value ? 1 : 0)
         when 'table'
           Table[:push!].(api, state, value)
         when 'function'
           Function[:push!].(api, state, value)
         else
           api.lua_pushstring(
-            state, "#<#{value.class}:0x#{format('%016x', value.object_id)}>"
+            state[:lua], "#<#{value.class}:0x#{format('%016x', value.object_id)}>"
           )
         end
       },