sweet-moon 0.0.2 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7bc6ba34912c2d5c9e26b95b385e4a992b186b6adbe81e40e0e6068cc363a948
-  data.tar.gz: 751f266193c94b533cf8f0b38f99745870688a2efd01e5277bb25d0aafe4b314
+  metadata.gz: 8e216a8bf96c191f08675bad6b2d4d9a1dceb9649a5e856ce4d6b4894e09b35e
+  data.tar.gz: b807eb9b92df1e53a0e0011f6132724c95b11a76dafab1073a46d2c5bf35c6ab
 SHA512:
-  metadata.gz: 1fac3cd35cc1afd5cf1918f98326237203f9e12c631ccde66946a6496d24d90e69cf06a43413b1f58527c486f81f50098d7d866547389936becac5b6ba8eda84
-  data.tar.gz: e14b5c3eecbdeefa68747f4b2cf8377c0b99289783bfd5dd3eec5c295368bea65eca70be594f4272777cbd811ecdb6a3fef36ce73103349831072d44851a51bb
+  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

@@ -21,15 +21,18 @@ _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)
+  - [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)
@@ -69,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.2'
+gem 'sweet-moon', '~> 0.0.5'
 ```
 
 ```ruby
@@ -209,6 +212,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
@@ -389,6 +393,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`.
@@ -512,6 +530,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:
@@ -577,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:
@@ -611,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',
 )
 ```
 
@@ -622,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',
 )
 ```
 
@@ -714,8 +750,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)
 
@@ -725,7 +761,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')
 ```
@@ -740,6 +776,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.
@@ -753,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
 ```
@@ -763,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
 ```
@@ -773,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
 ```
@@ -783,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
 ```
@@ -929,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,52 +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) {
-          input = Reader[:read_all!].(api, current_state)
-          result = closure.(*input)
-          Writer[:push!].(api, current_state, result)
-          return 1
-        }
-
-        api.lua_pushcclosure(state, handler, 0)
-      },
-
-      read!: ->(api, state, _stack_index) {
-        reference = api.luaL_ref(
-          state, Logic::V50::Interpreter[:LUA_REGISTRYINDEX]
-        )
-
-        { value: ->(input = [], output = 1) {
-          api.lua_rawgeti(
-            state, 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,91 +1,113 @@
 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: state, error: state ? nil : :MemoryAllocation }
+        { state: { lua: state, avoid_gc: [], ruby_error_info: nil },
+          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) {
-        Writer[:push!].(api, state, value)
+        Writer[:push!].(api, state, Component::V50, value)
         { state: state }
       },
 
       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
 
-        Table[:read_field_and_push!].(api, state, key, -1) unless key.nil?
+        api.lua_pushstring(state[:lua], variable.to_s)
+        api.lua_gettable(state[:lua], Logic::V50::Interpreter[:LUA_GLOBALSINDEX])
 
-        { state: state }
+        unless key.nil?
+          Table[:read_field_and_push!].(api, state, Component::V50, key,
+                                        -1)
+        end
+
+        { 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)
+        result = Component::V50::Reader[:read!].(api, state, Component::V50,
+                                                 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] }
       },
 
       read_all!: ->(api, state) {
-        result = Reader[:read_all!].(api, state)
+        result = Reader[:read_all!].(api, state, Component::V50)
 
         { state: state, output: result }
       },
 
       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 +116,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

@@ -1,65 +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)).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
-
-        type = api.lua_typename(state, api.lua_type(state, 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, stack_index).address}",
-            type: type, pop: true }
-        end
-      },
-
-      read_string!: ->(api, state, stack_index) {
-        { value: api.lua_tostring(state, 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
-
-          return { value: api.lua_tointeger(state, stack_index), pop: true }
-        end
-
-        { value: api.lua_tonumber(state, stack_index), pop: true }
-      },
-
-      read_boolean!: ->(api, state, stack_index) {
-        { value: api.lua_toboolean(state, stack_index) == 1, pop: true }
-      }
-    }
+    Reader = Component::V54::Reader
   end
 end