sweet-moon 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bdfabe100158948ea2c29fadca09e82cd9567d71230627f6bd0e8ba3a04f523d
-  data.tar.gz: 3bb2925b0ef437c3942a837a67bb94261d89c9aaf5a011973dcf4b98db07e6b9
+  metadata.gz: 8e216a8bf96c191f08675bad6b2d4d9a1dceb9649a5e856ce4d6b4894e09b35e
+  data.tar.gz: b807eb9b92df1e53a0e0011f6132724c95b11a76dafab1073a46d2c5bf35c6ab
 SHA512:
-  metadata.gz: 582a792771b05e59a577349070709e78bb2a569ef14cdb955fb2666e826eb401ba4aa4e7b19297c30fd64f98eda244d656caf2e904f9c1af95e971807aed8820
-  data.tar.gz: 38307987e564f998b40b2792fd97a3e107095d6e46992689663d63d67bf248dfc16c3a8838f8461bf7a8765857e7b5c04da4e4ac3c636cd6a419abb85bab2e5b
+  metadata.gz: 538a7a773c11fe66a13c0be49efeb1f8d37da83f52a85d32fe8a7c52b3b590d155b0cdfb50efec3755181947db6a7b67a238b31c10bc382362b70301594949fb
+  data.tar.gz: 95d84ea3cf24919e4646c766f66302308f22392434ba5f76b0ae7743d4ef9ad3868d90b13b3d4bf26d58d7500d276b88be7ee26393818cf00950f08f4e6c4fc6

data/.rubocop.yml

@@ -5,6 +5,9 @@ AllCops:
 Style/Documentation:
   Enabled: false
 
+Lint/RescueException:
+  Exclude: ['components/interpreters/**/function.rb']
+
 Layout/LineLength:
   Max: 86
   Exclude: ['spec/**/*', 'logic/signatures/*']

data/README.md

@@ -32,6 +32,7 @@ _Sweet Moon_ is a resilient solution that makes working with [Lua](https://www.l
   - [Integration with fnx](#integration-with-fnx)
 - [Global vs Isolated](#global-vs-isolated)
 - [Error Handling](#error-handling)
+  - [Ruby feat. Lua Errors](#ruby-feat-lua-errors)
 - [Where can I find .so files?](#where-can-i-find-so-files)
 - [Low-Level C API](#low-level-c-api)
   - [The API](#the-api)
@@ -71,7 +72,7 @@ gem install sweet-moon
 > **Disclaimer:** It's an early-stage project, and you should expect breaking changes.
 
 ```ruby
-gem 'sweet-moon', '~> 0.0.4'
+gem 'sweet-moon', '~> 0.0.5'
 ```
 
 ```ruby
@@ -612,21 +613,21 @@ state.add_package_path('/home/me/my-lua-modules/?/init.lua')
 
 state.add_package_cpath('/home/me/my-lua-modules/?.so')
 
-state.add_package_path('/home/me/fennel.lua')
+state.add_package_path('/home/me/fennel/?.lua')
 
-state.add_package_cpath('/home/me/lib.so')
+state.add_package_cpath('/home/me/?.so')
 
 state.package_path
 # => ['./?.lua',
  #    './?/init.lua',
  #    '/home/me/my-lua-modules/?.lua',
  #    '/home/me/my-lua-modules/?/init.lua',
- #    '/home/me/fennel.lua']
+ #    '/home/me/fennel/?.lua']
 
 state.package_cpath
 # => ['./?.so',
 #     '/home/me/my-lua-modules/?.so',
-#     '/home/me/lib.so']
+#     '/home/me/?.so']
 ```
 
 Requiring a module:
@@ -646,8 +647,8 @@ You can set packages in State constructors:
 require 'sweet-moon'
 
 SweetMoon::State.new(
-  package_path: '/folder/lib.lua',
-  package_cpath: '/lib/lib.so',
+  package_path: '/folder/lib/?.lua',
+  package_cpath: '/lib/lib/?.so',
 )
 ```
 
@@ -657,8 +658,8 @@ Also, you can add packages through the global config:
 require 'sweet-moon'
 
 SweetMoon.global.config(
-  package_path: '/folder/lib.lua',
-  package_cpath: '/lib/lib.so',
+  package_path: '/folder/lib/?.lua',
+  package_cpath: '/lib/lib/?.so',
 )
 ```
 
@@ -831,7 +832,7 @@ require 'sweet-moon'
 
 state = SweetMoon::State.new
 
-state.add_package_path('/folder/fennel.lua')
+state.add_package_path('/folder/fennel/?.lua')
 
 state.fennel.eval('(+ 1 1)') # => 2
 ```
@@ -841,7 +842,7 @@ With the constructor:
 ```ruby
 require 'sweet-moon'
 
-fennel = SweetMoon::State.new(package_path: '/folder/fennel.lua').fennel
+fennel = SweetMoon::State.new(package_path: '/folder/fennel/?.lua').fennel
 
 fennel.eval('(+ 1 1)') # => 2
 ```
@@ -851,7 +852,7 @@ With global:
 ```ruby
 require 'sweet-moon'
 
-SweetMoon.global.state.add_package_path('/folder/fennel.lua')
+SweetMoon.global.state.add_package_path('/folder/fennel/?.lua')
 
 SweetMoon.global.state.fennel.eval('(+ 1 1)') # => 2
 ```
@@ -861,7 +862,7 @@ Alternatively:
 ```ruby
 require 'sweet-moon'
 
-SweetMoon.global.config(package_path: '/folder/fennel.lua')
+SweetMoon.global.config(package_path: '/folder/fennel/?.lua')
 
 SweetMoon.global.state.fennel.eval('(+ 1 1)') # => 2
 ```
@@ -1007,6 +1008,108 @@ rescue LuaRuntimeError => error
 end
 ```
 
+### Ruby feat. Lua Errors
+
+Lua errors can be rescued inside Ruby:
+
+```lua
+-- source.lua
+error('error from lua')
+```
+
+```ruby
+require 'sweet-moon'
+require 'sweet-moon/errors'
+
+state = SweetMoon::State.new
+
+begin
+  state.load('source.lua')
+rescue LuaRuntimeError => e
+  puts e.message
+  # => source.lua:2: error from lua
+end
+```
+
+Ruby errors can be handled inside Lua:
+
+```ruby
+require 'sweet-moon'
+
+state = SweetMoon::State.new
+
+state.set(:rubyFn, -> { raise 'error from ruby' })
+
+state.load('source.lua')
+```
+
+```lua
+-- source.lua
+local status, err = pcall(rubyFn)
+
+print(status) -- => false
+
+print(err)
+-- [string "    return function (...)..."]:5: RuntimeError: error from ruby stack traceback:
+--         [string "    return function (...)..."]:5: in function 'rubyFn'
+--         [C]: in function 'pcall'
+--         source.lua:2: in main chunk
+```
+
+Ruby errors not handled inside Lua can be rescued inside Ruby again, with an additional Lua backtrace:
+
+```lua
+-- source.lua
+a = 1
+
+rubyFn()
+```
+
+```ruby
+require 'sweet-moon'
+
+state = SweetMoon::State.new
+
+state.set(:rubyFn, -> { raise 'error from ruby' })
+
+begin
+  state.load('source.lua')
+rescue RuntimeError => e
+  puts e.message # => error from ruby
+
+  puts e.backtrace.last
+  # => source.lua:4: in main chunk
+end
+```
+
+Lua errors inside Lua functions can be rescued inside Ruby:
+
+```lua
+-- source.lua
+function luaFn()
+  error('lua function error')
+end
+```
+
+```ruby
+require 'sweet-moon'
+require 'sweet-moon/errors'
+
+state = SweetMoon::State.new
+
+state.load('source.lua')
+
+lua_fn = state.get(:luaFn)
+
+begin
+  lua_fn.()
+rescue LuaRuntimeError => e
+  puts e.message # => "source.lua:3: lua function error"
+end
+```
+
+For Fennel, all the examples above are equally true, with additional stack traceback as well.
+
 ## 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 by itself.

data/components/injections/injections_503.rb

@@ -6,7 +6,8 @@ module Component
           ffi: [:cfunction, [:pointer], :int],
           overwrite: {
             lua_pushcclosure: [%i[pointer cfunction int], :void],
-            lua_tocfunction: [%i[pointer int], :cfunction]
+            lua_tocfunction: [%i[pointer int], :cfunction],
+            lua_atpanic: [%i[pointer cfunction], :cfunction]
           }
         }
       ],

data/components/injections/injections_514.rb

@@ -6,7 +6,8 @@ module Component
           ffi: [:cfunction, [:pointer], :int],
           overwrite: {
             lua_pushcclosure: [%i[pointer cfunction int], :void],
-            lua_tocfunction: [%i[pointer int], :cfunction]
+            lua_tocfunction: [%i[pointer int], :cfunction],
+            lua_atpanic: [%i[pointer cfunction], :cfunction]
           }
         }
       ],

data/components/injections/injections_542.rb

@@ -6,7 +6,8 @@ module Component
           ffi: [:cfunction, [:pointer], :int],
           overwrite: {
             lua_pushcclosure: [%i[pointer cfunction int], :void],
-            lua_tocfunction: [%i[pointer int], :cfunction]
+            lua_tocfunction: [%i[pointer int], :cfunction],
+            lua_atpanic: [%i[pointer cfunction], :cfunction]
           }
         }
       ],

data/components/interpreters/50/function.rb

@@ -1,55 +1,19 @@
-require_relative '../../../logic/interpreters/interpreter_50'
-require_relative '../../../dsl/errors'
-
-require_relative 'writer'
-require_relative 'reader'
+require_relative '../54/function'
 
 module Component
   module V50
-    Function = {
-      push!: ->(api, state, closure) {
-        handler = ->(current_state) {
-          updated_state = state.merge(lua: current_state)
-          input = Reader[:read_all!].(api, updated_state)
-          result = closure.(*input)
-          Writer[:push!].(api, updated_state, result)
-          return 1
-        }
-
-        state[:avoid_gc] << handler
-
-        api.lua_pushcclosure(state[:lua], handler, 0)
-      },
-
-      read!: ->(api, state, _stack_index) {
-        reference = api.luaL_ref(
-          state[:lua], Logic::V50::Interpreter[:LUA_REGISTRYINDEX]
-        )
-
-        { value: ->(input = [], output = 1) {
-          api.lua_rawgeti(
-            state[:lua], Logic::V50::Interpreter[:LUA_REGISTRYINDEX], reference
-          )
-
-          input.each do |value|
-            Writer[:push!].(api, state, value)
-          end
-
-          result = Interpreter[:call!].(api, state, input.size, output)
-
-          if result[:error]
-            raise SweetMoon::Errors::SweetMoonErrorHelper.for(
-              result[:error][:status]
-            ), result[:error][:value]
-          end
-
-          result = Reader[:read_all!].(api, state)
-
-          return result.first if output == 1
-
-          result
-        }, pop: false }
-      }
-    }
+    Function = Component::V54::Function
+
+    LUA_HANDLER = <<LUA
+    return function (...)
+      result = _ruby(unpack(arg))
+
+      if result['error'] then
+        error(result['output'])
+      else
+        return result['output']
+      end
+    end
+LUA
   end
 end

data/components/interpreters/50/interpreter.rb

@@ -1,17 +1,19 @@
 require_relative '../../../logic/interpreters/interpreter_50'
 
+require_relative 'function'
 require_relative 'reader'
-require_relative 'writer'
 require_relative 'table'
+require_relative 'writer'
 
 module Component
   module V50
     Interpreter = {
       version: Logic::V50::Interpreter[:version],
+      logic: Logic::V50,
 
       create_state!: ->(api) {
         state = api.lua_open
-        { state: { lua: state, avoid_gc: [] },
+        { state: { lua: state, avoid_gc: [], ruby_error_info: nil },
           error: state ? nil : :MemoryAllocation }
       },
 
@@ -48,7 +50,7 @@ module Component
       },
 
       push_value!: ->(api, state, value) {
-        Writer[:push!].(api, state, value)
+        Writer[:push!].(api, state, Component::V50, value)
         { state: state }
       },
 
@@ -70,7 +72,10 @@ module Component
         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?
+        unless key.nil?
+          Table[:read_field_and_push!].(api, state, Component::V50, key,
+                                        -1)
+        end
 
         { state: state, extra_pop: extra_pop }
       },
@@ -81,7 +86,8 @@ module Component
       },
 
       read_and_pop!: ->(api, state, stack_index = -1, extra_pop: false) {
-        result = Component::V50::Reader[:read!].(api, state, stack_index)
+        result = Component::V50::Reader[:read!].(api, state, Component::V50,
+                                                 stack_index)
 
         api.lua_settop(state[:lua], -2) if result[:pop]
         api.lua_settop(state[:lua], -2) if extra_pop
@@ -90,7 +96,7 @@ module Component
       },
 
       read_all!: ->(api, state) {
-        result = Reader[:read_all!].(api, state)
+        result = Reader[:read_all!].(api, state, Component::V50)
 
         { state: state, output: result }
       },

data/components/interpreters/50/reader.rb

@@ -1,67 +1,7 @@
-require 'ffi'
-
-require_relative 'interpreter'
-require_relative 'function'
-require_relative 'table'
+require_relative '../54/reader'
 
 module Component
   module V50
-    Reader = {
-      read_all!: ->(api, state) {
-        (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[:lua]) if stack_index == -1
-
-        type = api.lua_typename(state[:lua],
-                                api.lua_type(state[:lua], stack_index)).read_string
-
-        case type
-        when 'string'
-          Reader[:read_string!].(api, state, stack_index)
-        when 'number'
-          Reader[:read_number!].(api, state, stack_index)
-        when 'no value'
-          { value: nil, pop: true, type: type }
-        when 'nil'
-          { value: nil, pop: true }
-        when 'boolean'
-          Reader[:read_boolean!].(api, state, stack_index)
-        when 'table'
-          Table[:read!].(api, state, stack_index)
-        when 'function'
-          Function[:read!].(api, state, stack_index)
-        else
-          # none nil boolean lightuserdata number
-          # string table function userdata thread
-          { 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[: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[:lua], stack_index) == 1
-
-          return { value: api.lua_tointeger(state[:lua], stack_index), pop: true }
-        end
-
-        { value: api.lua_tonumber(state[:lua], stack_index), pop: true }
-      },
-
-      read_boolean!: ->(api, state, stack_index) {
-        { value: api.lua_toboolean(state[:lua], stack_index) == 1, pop: true }
-      }
-    }
+    Reader = Component::V54::Reader
   end
 end

data/components/interpreters/50/table.rb

@@ -6,56 +6,19 @@ require_relative 'reader'
 module Component
   module V50
     Table = {
-      push!: ->(api, state, list, stack_index = -1) {
-        stack_index = api.lua_gettop(state[:lua]) if stack_index == -1
-
+      create_table!: ->(api, state, _list) {
         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[: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[:lua], stack_index + 1)
-          end
-        end
       },
 
-      read!: ->(api, state, stack_index) {
-        stack_index = api.lua_gettop(state[:lua]) if stack_index == -1
-
-        type = api.lua_typename(state[:lua],
-                                api.lua_type(state[:lua], stack_index)).read_string
-
-        api.lua_pushnil(state[:lua])
-
-        return nil if type != 'table'
-
-        tuples = []
-
-        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[:lua], -2) if value[:pop]
-
-          tuples << [key[:value], value[:value]]
-
-          break if value[:type] == 'no value' || key[:value].instance_of?(Proc)
-        end
-
-        { value: Logic::Tables[:to_hash_or_array].(tuples), pop: true }
-      },
+      push!: Component::V54::Table[:push!],
+      read!: Component::V54::Table[:read!],
 
-      read_field_and_push!: ->(api, state, expected_key, stack_index) {
+      read_field_and_push!: ->(api, state, component, expected_key, stack_index) {
         stack_index = api.lua_gettop(state[:lua]) if stack_index == -1
 
-        type = api.lua_typename(state[:lua],
-                                api.lua_type(state[:lua], stack_index)).read_string
+        type = api.lua_typename(
+          state[:lua], api.lua_type(state[:lua], stack_index)
+        ).read_string
 
         api.lua_pushnil(state[:lua])
 
@@ -64,8 +27,8 @@ module Component
         result = nil
 
         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)
+          value = component::Reader[:read!].(api, state, component, stack_index + 2)
+          key = component::Reader[:read!].(api, state, component, stack_index + 1)
 
           api.lua_settop(state[:lua], -2) if value[:pop]
 
@@ -73,7 +36,7 @@ module Component
             state[:lua], api.lua_type(state[:lua], stack_index + 1)
           ).read_string
 
-          if Table[:is_same_key].(key_type, key[:value], expected_key)
+          if component::Table[:is_same_key].(key_type, key[:value], expected_key)
             result = value[:value]
             break
           end
@@ -83,7 +46,7 @@ module Component
 
         api.lua_settop(state[:lua], -2)
 
-        Writer[:push!].(api, state, result)
+        component::Writer[:push!].(api, state, component, result)
       },
 
       is_same_key: ->(lua_key_type, lua_key, ruby_key) {

data/components/interpreters/50/writer.rb

@@ -1,45 +1,7 @@
-require_relative 'function'
-require_relative 'table'
+require_relative '../54/writer'
 
 module Component
   module V50
-    Writer = {
-      push!: ->(api, state, value) {
-        case Writer[:_to_lua_type].(value)
-        when 'string'
-          api.lua_pushstring(state[:lua], value.to_s)
-        when 'number'
-          api.lua_pushnumber(state[:lua], value)
-        when 'integer'
-          if api.respond_to? :lua_pushinteger
-            api.lua_pushinteger(state[:lua], value)
-          else
-            api.lua_pushnumber(state[:lua], value)
-          end
-        when 'nil'
-          api.lua_pushnil(state[:lua])
-        when 'boolean'
-          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[:lua], "#<#{value.class}:0x#{format('%016x', value.object_id)}>"
-          )
-        end
-      },
-
-      _to_lua_type: ->(value) {
-        return 'nil' if value.nil?
-        return 'function' if value.is_a?(Proc)
-        return 'integer' if value.is_a? Integer
-        return 'number' if value.is_a? Float
-        return 'table' if value.is_a?(Hash) || value.is_a?(Array)
-        return 'string' if value.is_a?(String) || value.instance_of?(Symbol)
-        return 'boolean' if [true, false].include? value
-      }
-    }
+    Writer = Component::V54::Writer
   end
 end

data/components/interpreters/51/function.rb

@@ -1,55 +1,9 @@
-require_relative '../../../logic/interpreters/interpreter_51'
-require_relative '../../../dsl/errors'
-
-require_relative 'writer'
-require_relative 'reader'
+require_relative '../54/function'
 
 module Component
   module V51
-    Function = {
-      push!: ->(api, state, closure) {
-        handler = ->(current_state) {
-          updated_state = state.merge(lua: current_state)
-          input = Reader[:read_all!].(api, updated_state)
-          result = closure.(*input)
-          Writer[:push!].(api, updated_state, result)
-          return 1
-        }
-
-        state[:avoid_gc] << handler
-
-        api.lua_pushcclosure(state[:lua], handler, 0)
-      },
-
-      read!: ->(api, state, _stack_index) {
-        reference = api.luaL_ref(
-          state[:lua], Logic::V51::Interpreter[:LUA_REGISTRYINDEX]
-        )
-
-        { value: ->(input = [], output = 1) {
-          api.lua_rawgeti(
-            state[:lua], Logic::V51::Interpreter[:LUA_REGISTRYINDEX], reference
-          )
-
-          input.each do |value|
-            Writer[:push!].(api, state, value)
-          end
-
-          result = Interpreter[:call!].(api, state, input.size, output)
-
-          if result[:error]
-            raise SweetMoon::Errors::SweetMoonErrorHelper.for(
-              result[:error][:status]
-            ), result[:error][:value]
-          end
-
-          result = Reader[:read_all!].(api, state)
-
-          return result.first if output == 1
+    Function = Component::V54::Function
 
-          result
-        }, pop: false }
-      }
-    }
+    LUA_HANDLER = Component::V54::LUA_HANDLER
   end
 end