sweet-moon 0.0.2 → 0.0.5

data/components/interpreters/54/interpreter.rb

@@ -1,86 +1,99 @@
 require_relative '../../../logic/interpreters/interpreter_54'
 
+require_relative 'function'
 require_relative 'reader'
-require_relative 'writer'
 require_relative 'table'
+require_relative 'writer'
 
 module Component
   module V54
     Interpreter = {
       version: Logic::V54::Interpreter[:version],
+      logic: Logic::V54,
 
       create_state!: ->(api) {
         state = api.luaL_newstate
-        { 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.luaL_openlibs(state)
+        api.luaL_openlibs(state[:lua])
         { 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_loadstring(state, value)
+        result = api.luaL_loadstring(state[:lua], 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::V54, value)
         { state: state }
       },
 
       pop_and_set_as!: ->(api, state, variable) {
-        api.lua_setglobal(state, variable)
+        api.lua_setglobal(state[:lua], variable)
         { state: state }
       },
 
       get_variable_and_push!: ->(api, state, variable, key = nil) {
-        api.lua_getglobal(state, variable.to_s)
+        api.lua_getglobal(state[:lua], variable.to_s)
 
         unless key.nil?
-          if api.lua_typename(state, api.lua_type(state, -1)).read_string == 'table'
-            Table[:read_field!].(api, state, key, -1)
+          if api.lua_typename(state[:lua],
+                              api.lua_type(state[:lua], -1)).read_string == 'table'
+            Table[:read_field!].(api, state, Component::V54, key, -1)
           else
-            api.lua_pushnil(state)
+            api.lua_pushnil(state[:lua])
           end
         end
 
-        { state: state }
+        { state: state, extra_pop: true }
       },
 
       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::V54::Reader[:read!].(api, state, stack_index)
+        result = Component::V54::Reader[:read!].(api, state, Component::V54,
+                                                 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::V54)
 
         { 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 = {}) {
@@ -89,7 +102,7 @@ module Component
         ] || :error
 
         if code.is_a?(Numeric) && code >= 2
-          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/54/reader.rb

@@ -7,58 +7,61 @@ require_relative 'table'
 module Component
   module V54
     Reader = {
-      read_all!: ->(api, state) {
-        (1..api.lua_gettop(state)).map do
-          Interpreter[:read_and_pop!].(api, state)[:output]
+      read_all!: ->(api, state, component) {
+        (1..api.lua_gettop(state[:lua])).map do
+          component::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
+      read!: ->(api, state, component, 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'
-          Reader[:read_string!].(api, state, stack_index)
+          component::Reader[:read_string!].(api, state, stack_index)
         when 'number'
-          Reader[:read_number!].(api, state, stack_index)
+          component::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)
+          component::Reader[:read_boolean!].(api, state, stack_index)
         when 'table'
-          Table[:read!].(api, state, stack_index)
+          component::Table[:read!].(api, state, component, stack_index)
         when 'function'
-          Function[:read!].(api, state, stack_index)
+          component::Function[:read!].(api, state, component, stack_index)
         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/54/table.rb

@@ -6,41 +6,47 @@ require_relative 'reader'
 module Component
   module V54
     Table = {
-      push!: ->(api, state, list, stack_index = -1) {
-        stack_index = api.lua_gettop(state) if stack_index == -1
+      create_table!: ->(api, state, list) {
+        api.lua_createtable(state[:lua], list.size, 0)
+      },
+
+      push!: ->(api, state, component, list, stack_index = -1) {
+        stack_index = api.lua_gettop(state[:lua]) if stack_index == -1
 
-        api.lua_createtable(state, list.size, 0)
+        component::Table[:create_table!].(api, state, list)
 
         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)
+            component::Writer[:push!].(api, state, component, key)
+            component::Writer[:push!].(api, state, component, 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, stack_index + 1)
+            component::Writer[:push!].(api, state, component, index + 1)
+            component::Writer[:push!].(api, state, component, value)
+            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
+      read!: ->(api, state, component, stack_index) {
+        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?
-          value = Reader[:read!].(api, state, stack_index + 2)
-          key = Reader[:read!].(api, state, stack_index + 1)
-          api.lua_settop(state, -2) if value[:pop]
+        while api.lua_next(state[:lua], stack_index).positive?
+          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]
 
           tuples << [key[:value], value[:value]]
 
@@ -50,10 +56,10 @@ module Component
         { value: Logic::Tables[:to_hash_or_array].(tuples), pop: true }
       },
 
-      read_field!: ->(api, state, expected_key, stack_index) {
+      read_field!: ->(api, state, _component, expected_key, stack_index) {
         expected_key = expected_key.to_s if expected_key.is_a? Symbol
 
-        api.lua_getfield(state, stack_index, expected_key)
+        api.lua_getfield(state[:lua], stack_index, expected_key)
       }
     }
   end

data/components/interpreters/54/writer.rb

@@ -4,29 +4,29 @@ require_relative 'table'
 module Component
   module V54
     Writer = {
-      push!: ->(api, state, value) {
-        case Writer[:_to_lua_type].(value)
+      push!: ->(api, state, component, value) {
+        case component::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)
+          component::Table[:push!].(api, state, component, value)
         when 'function'
-          Function[:push!].(api, state, value)
+          component::Function[:push!].(api, state, component, 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
       },

data/config/tests.sample.yml

@@ -1,39 +1,43 @@
 # Available at https://github.com/gbaptista/sweet-moon-test
 
+fennel-dev: '/home/me/sweet-moon-test/fennel/dev/?.lua'
+
 luarocks:
-  - /home/me/.luarocks/share/lua/5.4/?.lua
-  - /home/me/.luarocks/share/lua/5.4/?/init.lua
-  - /home/me/.luarocks/lib/lua/5.4/?.so
+  path:
+    - /home/me/.luarocks/share/lua/5.4/?.lua
+    - /home/me/.luarocks/share/lua/5.4/?/init.lua
+    - /home/me/.luarocks/lib/lua/5.4/?.so
+  expected: ['supernova', 'dkjson', 'lfs']
 
 jit:2.0.5:
   description: 'Lua Jit 2.0.5 + Fennel 1.0.0'
   shared_object: /home/me/sweet-moon-test/libluajit.so.2.0.5
-  fennel: /home/me/sweet-moon-test/fennel-100.lua
+  fennel: /home/me/sweet-moon-test/fennel/100/?.lua
 
 5.4.4:
   description: 'Lua 5.4.4 + Fennel 1.0.0'
   shared_object: /home/me/sweet-moon-test/liblua.so.5.4.4
-  fennel: /home/me/sweet-moon-test/fennel-100.lua
+  fennel: /home/me/sweet-moon-test/fennel/100/?.lua
 
 5.4.2:
   description: 'Lua 5.4.2 + Fennel 1.0.0'
   shared_object: /home/me/sweet-moon-test/liblua.so.5.4.2
-  fennel: /home/me/sweet-moon-test/fennel-100.lua
+  fennel: /home/me/sweet-moon-test/fennel/100/?.lua
 
 5.3.3:
   description: 'Lua 5.3.3'
   shared_object: /home/me/sweet-moon-test/liblua.so.5.3.3
-  fennel: /home/me/sweet-moon-test/fennel-100.lua
+  fennel: /home/me/sweet-moon-test/fennel/100/?.lua
 
 5.2.4:
   description: 'Lua 5.2.4'
   shared_object: /home/me/sweet-moon-test/liblua.so.5.2.4
-  fennel: /home/me/sweet-moon-test/fennel-100.lua
+  fennel: /home/me/sweet-moon-test/fennel/100/?.lua
 
 5.1.5:
   description: 'Lua 5.1.5'
   shared_object: /home/me/sweet-moon-test/liblua.so.5.1.5
-  fennel: /home/me/sweet-moon-test/fennel-100.lua
+  fennel: /home/me/sweet-moon-test/fennel/100/?.lua
 
 5.0.3:
   description: 'Lua 5.0.3'

data/controllers/state.rb

@@ -26,23 +26,48 @@ module Controller
     },
 
     get!: ->(api, interpreter, state, variable, key = nil) {
+      if key.nil?
+        key = variable
+        variable = '_G'
+      end
+
+      State[:_get_key!].(api, interpreter, state, variable, key)
+    },
+
+    _get_key!: ->(api, interpreter, state, variable, key) {
       result = State[:_check!].(
         interpreter[:get_variable_and_push!].(api, state, variable, key)
       )
 
-      result = State[:_check!].(interpreter[:read_and_pop!].(
-                                  api, result[:state], -1, extra_pop: !key.nil?
-                                ))
+      result = State[:_check!].(
+        interpreter[:read_and_pop!].(
+          api, result[:state], -1, extra_pop: result[:extra_pop]
+        )
+      )
 
       { state: result[:state], output: result[:output] }
     },
 
-    set!: ->(api, interpreter, state, variable, value) {
-      result = State[:_check!].(interpreter[:push_value!].(api, state, value))
-
-      result = State[:_check!].(
-        interpreter[:pop_and_set_as!].(api, result[:state], variable.to_s)
-      )
+    set!: ->(api, interpreter, state, variable, key_or_value, value = nil) {
+      if value.nil?
+        result = State[:_check!].(interpreter[:push_value!].(api, state,
+                                                             key_or_value))
+
+        result = State[:_check!].(
+          interpreter[:pop_and_set_as!].(api, result[:state], variable.to_s)
+        )
+      else
+        result = State[:_check!].(
+          interpreter[:get_variable_and_push!].(api, state, variable)
+        )
+
+        result = State[:_check!].(interpreter[:push_value!].(api, result[:state],
+                                                             key_or_value))
+        result = State[:_check!].(interpreter[:push_value!].(api, result[:state],
+                                                             value))
+
+        result = State[:_check!].(interpreter[:set_table!].(api, result[:state]))
+      end
 
       { state: result[:state], output: result[:output] }
     },
@@ -62,10 +87,20 @@ module Controller
     },
 
     _check!: ->(result) {
+      ruby_error = result[:state] && result[:state][:ruby_error_info]
+
+      result[:state][:ruby_error_info] = nil if ruby_error
+
       if result[:error]
-        raise SweetMoon::Errors::SweetMoonErrorHelper.for(
-          result[:error][:status]
-        ), result[:error][:value]
+        if ruby_error
+          raise SweetMoon::Errors::SweetMoonErrorHelper.merge_traceback!(
+            ruby_error, result[:error][:value]
+          )
+        else
+          raise SweetMoon::Errors::SweetMoonErrorHelper.for(
+            result[:error][:status]
+          ), result[:error][:value]
+        end
       end
 
       result

data/dsl/errors.rb

@@ -10,6 +10,14 @@ module SweetMoon
     class LuaFileError < LuaError; end
 
     module SweetMoonErrorHelper
+      def merge_traceback!(ruby_error, lua_traceback)
+        ruby_error.set_backtrace(
+          ruby_error.backtrace.concat(lua_traceback.split("\n"))
+        )
+
+        ruby_error
+      end
+
       def for(status)
         case status
         when :runtime           then LuaRuntimeError
@@ -22,7 +30,7 @@ module SweetMoon
         end
       end
 
-      module_function :for
+      module_function :for, :merge_traceback!
     end
   end
 end

data/dsl/fennel.rb

@@ -11,6 +11,8 @@ module DSL
         'table.insert(package.loaders or package.searchers, fennel.searcher)'
       )
 
+      @state.eval('debug.traceback = fennel.traceback')
+
       @eval = @state.get(:fennel, :eval)
       @dofile = @state.get(:fennel, :dofile)
       @version = @state.get(:fennel, :version)

data/dsl/state.rb

@@ -7,7 +7,7 @@ module DSL
     include DSL::Concerns::Packages
     include DSL::Concerns::Fennel
 
-    attr_reader :meta
+    attr_reader :meta, :api
 
     def initialize(api_component, interpreter_component, controller, options = {})
       @api = api_component[:api]
@@ -22,6 +22,10 @@ module DSL
       add_package_cpath(options[:package_cpath]) if options[:package_cpath]
     end
 
+    def raw
+      @state
+    end
+
     def eval(input, outputs = 1)
       @controller[:eval!].(@api, @interpreter, state, input, outputs)[:output]
     end
@@ -34,8 +38,10 @@ module DSL
       @controller[:get!].(@api, @interpreter, state, variable, key)[:output]
     end
 
-    def set(variable, value)
-      @controller[:set!].(@api, @interpreter, state, variable, value)[:output]
+    def set(variable, key_or_value, value = nil)
+      @controller[:set!].(
+        @api, @interpreter, state, variable, key_or_value, value
+      )[:output]
     end
 
     def destroy

data/logic/interpreters/interpreter_50.rb

@@ -6,6 +6,7 @@ module Logic
       LUA_REGISTRYINDEX: -10_000,
       LUA_GLOBALSINDEX: -10_001,
 
+      # lua_isinteger lua_pushinteger lua_tointeger
       requires: %i[
         lua_close lua_gettable lua_gettop lua_insert lua_newtable lua_next lua_open
         lua_pcall lua_pushboolean lua_pushcclosure lua_pushnil lua_pushnumber

data/logic/interpreters/interpreter_54.rb

@@ -12,11 +12,11 @@ module Logic
 
       # lua_isinteger lua_pushinteger lua_tointeger
       requires: %i[
-        lua_close lua_createtable lua_getfield lua_getglobal lua_gettop lua_next
-        lua_pcall lua_pushboolean lua_pushcclosure lua_pushnil lua_pushnumber
-        lua_pushstring lua_rawgeti lua_setglobal lua_settable lua_settop lua_toboolean
-        lua_tonumber lua_topointer lua_tostring lua_type lua_typename luaL_loadfile
-        luaL_loadstring luaL_newstate luaL_openlibs luaL_ref
+        lua_close lua_createtable lua_getfield lua_gettop lua_next lua_pcall
+        lua_pushboolean lua_pushcclosure lua_pushnil lua_pushnumber lua_pushstring
+        lua_rawgeti lua_settable lua_settop lua_toboolean lua_tonumber lua_topointer
+        lua_tostring lua_type lua_typename luaL_loadfile luaL_loadstring luaL_newstate
+        luaL_openlibs luaL_ref lua_getglobal lua_setglobal
       ],
 
       status: {

data/logic/spec.rb

@@ -2,7 +2,7 @@ module Logic
   Spec = {
     name: 'sweet-moon',
     command: 'sweet-moon',
-    version: '0.0.2',
+    version: '0.0.5',
     author: 'gbaptista',
     summary: 'Lua / Fennel from Ruby and vice versa. Support to LuaJIT, Lua 5.0, ' \
              'and 5.1. Lua C API for Lua 5, 4, and 3. LuaRocks and fnx integration.',

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sweet-moon
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.5
 platform: ruby
 authors:
 - gbaptista
 autorequire:
 bindir: ports/in/shell
 cert_chain: []
-date: 2022-03-22 00:00:00.000000000 Z
+date: 2022-03-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi