sweet-moon 0.0.2 → 0.0.5

data/components/interpreters/50/table.rb

@@ -6,82 +6,47 @@ require_relative 'reader'
 module Component
   module V50
     Table = {
-      push!: ->(api, state, list, stack_index = -1) {
-        stack_index = api.lua_gettop(state) if stack_index == -1
-
-        api.lua_newtable(state)
-
-        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)
-          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)
-          end
-        end
+      create_table!: ->(api, state, _list) {
+        api.lua_newtable(state[:lua])
       },
 
-      read!: ->(api, state, stack_index) {
-        stack_index = api.lua_gettop(state) if stack_index == -1
-
-        type = api.lua_typename(state, api.lua_type(state, stack_index)).read_string
-
-        api.lua_pushnil(state)
-
-        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]
-
-          tuples << [key[:value], value[:value]]
-
-          break if value[:type] == 'no value'
-        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) {
-        stack_index = api.lua_gettop(state) if stack_index == -1
+      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, 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?
-          value = Reader[:read!].(api, state, stack_index + 2)
-          key = Reader[:read!].(api, state, stack_index + 1)
+        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, -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)
+          if component::Table[:is_same_key].(key_type, key[:value], expected_key)
             result = value[:value]
             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)
+        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, value.to_s)
-        when 'number'
-          api.lua_pushnumber(state, value)
-        when 'integer'
-          if api.respond_to? :lua_pushinteger
-            api.lua_pushinteger(state, value)
-          else
-            api.lua_pushnumber(state, value)
-          end
-        when 'nil'
-          api.lua_pushnil(state)
-        when 'boolean'
-          api.lua_pushboolean(state, 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)}>"
-          )
-        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,52 +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) {
-          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::V51::Interpreter[:LUA_REGISTRYINDEX]
-        )
-
-        { value: ->(input = [], output = 1) {
-          api.lua_rawgeti(
-            state, 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

data/components/interpreters/51/interpreter.rb

@@ -1,90 +1,101 @@
 require_relative '../../../logic/interpreters/interpreter_51'
 
+require_relative 'function'
 require_relative 'reader'
-require_relative 'writer'
 require_relative 'table'
+require_relative 'writer'
 
 module Component
   module V51
     Interpreter = {
       version: Logic::V51::Interpreter[:version],
+      logic: Logic::V51,
 
       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::V51, 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::V51::Interpreter[:LUA_GLOBALSINDEX])
+        api.lua_pushstring(state[:lua], variable)
+        api.lua_insert(state[:lua], -2)
+        api.lua_settable(state[:lua], Logic::V51::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::V51::Interpreter[:LUA_GLOBALSINDEX])
+        api.lua_pushstring(state[:lua], variable.to_s)
+        api.lua_gettable(state[:lua], Logic::V51::Interpreter[:LUA_GLOBALSINDEX])
 
         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::V51, 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::V51::Reader[:read!].(api, state, stack_index)
+        result = Reader[:read!].(api, state, Component::V51, 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::V51)
 
         { 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 = {}) {
@@ -93,7 +104,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/51/reader.rb

@@ -1,65 +1,7 @@
-require 'ffi'
-
-require_relative 'interpreter'
-require_relative 'function'
-require_relative 'table'
+require_relative '../54/reader'
 
 module Component
   module V51
-    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

data/components/interpreters/51/table.rb

@@ -1,60 +1,7 @@
-require_relative '../../../logic/tables'
-
-require_relative 'writer'
-require_relative 'reader'
+require_relative '../54/table'
 
 module Component
   module V51
-    Table = {
-      push!: ->(api, state, list, stack_index = -1) {
-        stack_index = api.lua_gettop(state) if stack_index == -1
-
-        api.lua_createtable(state, list.size, 0)
-
-        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)
-          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)
-          end
-        end
-      },
-
-      read!: ->(api, state, stack_index) {
-        stack_index = api.lua_gettop(state) if stack_index == -1
-
-        type = api.lua_typename(state, api.lua_type(state, stack_index)).read_string
-
-        api.lua_pushnil(state)
-
-        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]
-
-          tuples << [key[:value], value[:value]]
-
-          break if value[:type] == 'no value'
-        end
-
-        { value: Logic::Tables[:to_hash_or_array].(tuples), pop: true }
-      },
-
-      read_field!: ->(api, state, expected_key, stack_index) {
-        expected_key = expected_key.to_s if expected_key.is_a? Symbol
-
-        api.lua_getfield(state, stack_index, expected_key)
-      }
-    }
+    Table = Component::V54::Table
   end
 end

data/components/interpreters/51/writer.rb

@@ -1,45 +1,7 @@
-require_relative 'function'
-require_relative 'table'
+require_relative '../54/writer'
 
 module Component
   module V51
-    Writer = {
-      push!: ->(api, state, value) {
-        case Writer[:_to_lua_type].(value)
-        when 'string'
-          api.lua_pushstring(state, value.to_s)
-        when 'number'
-          api.lua_pushnumber(state, value)
-        when 'integer'
-          if api.respond_to? :lua_pushinteger
-            api.lua_pushinteger(state, value)
-          else
-            api.lua_pushnumber(state, value)
-          end
-        when 'nil'
-          api.lua_pushnil(state)
-        when 'boolean'
-          api.lua_pushboolean(state, 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)}>"
-          )
-        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/54/function.rb

@@ -1,52 +1,111 @@
 require_relative '../../../logic/interpreters/interpreter_54'
 require_relative '../../../dsl/errors'
 
-require_relative 'writer'
+require_relative 'interpreter'
 require_relative 'reader'
+require_relative 'writer'
 
 module Component
   module V54
     Function = {
-      push!: ->(api, state, closure) {
-        handler = ->(current_state) {
-          input = Reader[:read_all!].(api, current_state)
-          result = closure.(*input)
-          Writer[:push!].(api, current_state, result)
+      push!: ->(api, state, component, closure) {
+        handler = component::Function[:build_handler!].(
+          api, state, component, closure
+        )
+
+        state[:avoid_gc] << handler
+
+        lua_name = "_sweet_moon_ruby_#{handler.object_id}"
+
+        api.lua_pushcclosure(state[:lua], handler, 0)
+        component::Interpreter[:pop_and_set_as!].(api, state, lua_name)
+
+        result = component::Interpreter[:push_chunk!].(
+          api, state, component::LUA_HANDLER.sub('_ruby', lua_name)
+        )
+
+        unless result[:error].nil?
+          raise SweetMoon::Errors::SweetMoonErrorHelper.for(
+            result[:error][:status]
+          ), result[:error][:value]
+        end
+
+        component::Interpreter[:call!].(api, state, 0, 1)
+      },
+
+      build_handler!: ->(api, state, component, closure) {
+        ->(current_state) {
+          updated_state = state.merge(lua: current_state)
+          input = component::Reader[:read_all!].(api, updated_state, component)
+          begin
+            result = closure.(*input)
+            component::Writer[:push!].(
+              api, updated_state, component, { error: nil, output: result }
+            )
+          rescue Exception => e
+            state[:ruby_error_info] = e
+            component::Writer[:push!].(
+              api, updated_state, component, {
+                error: true, output: "#{e.class}: #{e.message}"
+              }
+            )
+          end
           return 1
         }
-
-        api.lua_pushcclosure(state, handler, 0)
       },
 
-      read!: ->(api, state, _stack_index) {
-        reference = api.luaL_ref(
-          state, Logic::V54::Interpreter[:LUA_REGISTRYINDEX]
-        )
+      read!: ->(api, state, component, _stack_index) {
+        lua_registry_index = component::Interpreter[:logic]::Interpreter[
+          :LUA_REGISTRYINDEX
+        ]
+
+        reference = api.luaL_ref(state[:lua], lua_registry_index)
 
         { value: ->(input = [], output = 1) {
-          api.lua_rawgeti(
-            state, Logic::V54::Interpreter[:LUA_REGISTRYINDEX], reference
-          )
+          api.lua_rawgeti(state[:lua], lua_registry_index, reference)
 
           input.each do |value|
-            Writer[:push!].(api, state, value)
+            component::Writer[:push!].(api, state, component, value)
           end
 
-          result = Interpreter[:call!].(api, state, input.size, output)
+          result = component::Interpreter[:call!].(api, state, input.size, output)
 
-          if result[:error]
-            raise SweetMoon::Errors::SweetMoonErrorHelper.for(
-              result[:error][:status]
-            ), result[:error][:value]
-          end
+          component::Function[:raise_error!].(state, result) if result[:error]
 
-          result = Reader[:read_all!].(api, state)
+          result = component::Reader[:read_all!].(api, state, component)
 
           return result.first if output == 1
 
           result
         }, pop: false }
+      },
+
+      raise_error!: ->(state, result) {
+        if state[:ruby_error_info].nil?
+          raise SweetMoon::Errors::SweetMoonErrorHelper.for(
+            result[:error][:status]
+          ), result[:error][:value]
+        else
+          ruby_error = state[:ruby_error_info]
+          state[:ruby_error_info] = nil
+
+          raise SweetMoon::Errors::SweetMoonErrorHelper.merge_traceback!(
+            ruby_error, result[:error][:value]
+          )
+        end
       }
     }
+
+    LUA_HANDLER = <<LUA
+    return function (...)
+      result = _ruby(...)
+
+      if result['error'] then
+        error(result['output'] .. ' ' .. debug.traceback())
+      else
+        return result['output']
+      end
+    end
+LUA
   end
 end