sweet-moon 0.0.1

data/components/interpreters/51/interpreter.rb

@@ -0,0 +1,104 @@
+require_relative '../../../logic/interpreters/interpreter_51'
+
+require_relative 'reader'
+require_relative 'writer'
+require_relative 'table'
+
+module Component
+  module V51
+    Interpreter = {
+      version: Logic::V51::Interpreter[:version],
+
+      create_state!: ->(api) {
+        state = api.luaL_newstate
+        { state: state, error: state ? nil : :MemoryAllocation }
+      },
+
+      open_standard_libraries!: ->(api, state) {
+        api.luaL_openlibs(state)
+
+        { state: state }
+      },
+
+      load_file_and_push_chunck!: ->(api, state, path) {
+        result = api.luaL_loadfile(state, path)
+        { state: state, error: Interpreter[:_error].(api, state, result, pull: true) }
+      },
+
+      push_chunk!: ->(api, state, value) {
+        result = api.luaL_loadstring(state, value)
+        { state: state, error: Interpreter[:_error].(api, state, result, pull: true) }
+      },
+
+      set_table!: ->(api, state, variable, value) {
+        Table[:set!].(api, state, variable, value)
+      },
+
+      push_value!: ->(api, state, value) {
+        Writer[:push!].(api, state, 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])
+        { 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])
+
+        unless key.nil?
+          if api.lua_typename(state, api.lua_type(state, -1)).read_string == 'table'
+            Table[:read_field!].(api, state, key, -1)
+          else
+            api.lua_pushnil(state)
+          end
+        end
+
+        { state: state }
+      },
+
+      call!: ->(api, state, inputs = 0, outputs = 1) {
+        result = api.lua_pcall(state, 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)
+
+        api.lua_settop(state, -2) if result[:pop]
+        api.lua_settop(state, -2) if extra_pop
+
+        { state: state, output: result[:value] }
+      },
+
+      read_all!: ->(api, state) {
+        result = Reader[:read_all!].(api, state)
+
+        { state: state, output: result }
+      },
+
+      destroy_state!: ->(api, state) {
+        result = api.lua_close(state)
+
+        { state: nil, error: Interpreter[:_error].(api, state, result) }
+      },
+
+      _error: ->(api, state, code, options = {}) {
+        status = Logic::V51::Interpreter[:error][
+          Logic::V51::Interpreter[:status][code]
+        ] || :error
+
+        if code.is_a?(Numeric) && code >= 2
+          return { status: status } unless options[:pull]
+
+          { status: status,
+            value: Interpreter[:read_and_pop!].(api, state, -1)[:output] }
+        end
+      }
+    }
+  end
+end

data/components/interpreters/51/reader.rb

@@ -0,0 +1,65 @@
+require 'ffi'
+
+require_relative 'interpreter'
+require_relative 'function'
+require_relative 'table'
+
+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 }
+      }
+    }
+  end
+end

data/components/interpreters/51/table.rb

@@ -0,0 +1,60 @@
+require_relative '../../../logic/tables'
+
+require_relative 'writer'
+require_relative 'reader'
+
+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)
+      }
+    }
+  end
+end

data/components/interpreters/51/writer.rb

@@ -0,0 +1,45 @@
+require_relative 'function'
+require_relative 'table'
+
+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
+      }
+    }
+  end
+end

data/components/interpreters/54/function.rb

@@ -0,0 +1,52 @@
+require_relative '../../../logic/interpreters/interpreter_54'
+require_relative '../../../dsl/errors'
+
+require_relative 'writer'
+require_relative 'reader'
+
+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)
+          return 1
+        }
+
+        api.lua_pushcclosure(state, handler, 0)
+      },
+
+      read!: ->(api, state, _stack_index) {
+        reference = api.luaL_ref(
+          state, Logic::V54::Interpreter[:LUA_REGISTRYINDEX]
+        )
+
+        { value: ->(input = [], output = 1) {
+          api.lua_rawgeti(
+            state, Logic::V54::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 }
+      }
+    }
+  end
+end

data/components/interpreters/54/interpreter.rb

@@ -0,0 +1,100 @@
+require_relative '../../../logic/interpreters/interpreter_54'
+
+require_relative 'reader'
+require_relative 'writer'
+require_relative 'table'
+
+module Component
+  module V54
+    Interpreter = {
+      version: Logic::V54::Interpreter[:version],
+
+      create_state!: ->(api) {
+        state = api.luaL_newstate
+        { state: state, error: state ? nil : :MemoryAllocation }
+      },
+
+      open_standard_libraries!: ->(api, state) {
+        api.luaL_openlibs(state)
+        { state: state }
+      },
+
+      load_file_and_push_chunck!: ->(api, state, path) {
+        result = api.luaL_loadfile(state, path)
+        { state: state, error: Interpreter[:_error].(api, state, result, pull: true) }
+      },
+
+      push_chunk!: ->(api, state, value) {
+        result = api.luaL_loadstring(state, value)
+        { state: state, error: Interpreter[:_error].(api, state, result, pull: true) }
+      },
+
+      set_table!: ->(api, state, variable, value) {
+        Table[:set!].(api, state, variable, value)
+      },
+
+      push_value!: ->(api, state, value) {
+        Writer[:push!].(api, state, value)
+        { state: state }
+      },
+
+      pop_and_set_as!: ->(api, state, variable) {
+        api.lua_setglobal(state, variable)
+        { state: state }
+      },
+
+      get_variable_and_push!: ->(api, state, variable, key = nil) {
+        api.lua_getglobal(state, 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)
+          else
+            api.lua_pushnil(state)
+          end
+        end
+
+        { state: state }
+      },
+
+      call!: ->(api, state, inputs = 0, outputs = 1) {
+        result = api.lua_pcall(state, 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)
+
+        api.lua_settop(state, -2) if result[:pop]
+        api.lua_settop(state, -2) if extra_pop
+
+        { state: state, output: result[:value] }
+      },
+
+      read_all!: ->(api, state) {
+        result = Reader[:read_all!].(api, state)
+
+        { state: state, output: result }
+      },
+
+      destroy_state!: ->(api, state) {
+        result = api.lua_close(state)
+
+        { state: nil, error: Interpreter[:_error].(api, state, result) }
+      },
+
+      _error: ->(api, state, code, options = {}) {
+        status = Logic::V54::Interpreter[:error][
+          Logic::V54::Interpreter[:status][code]
+        ] || :error
+
+        if code.is_a?(Numeric) && code >= 2
+          return { status: status } unless options[:pull]
+
+          { status: status,
+            value: Interpreter[:read_and_pop!].(api, state, -1)[:output] }
+        end
+      }
+    }
+  end
+end

data/components/interpreters/54/reader.rb

@@ -0,0 +1,65 @@
+require 'ffi'
+
+require_relative 'interpreter'
+require_relative 'function'
+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]
+        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 }
+      }
+    }
+  end
+end

data/components/interpreters/54/table.rb

@@ -0,0 +1,60 @@
+require_relative '../../../logic/tables'
+
+require_relative 'writer'
+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
+
+        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' || key[:value].instance_of?(Proc)
+        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)
+      }
+    }
+  end
+end

data/components/interpreters/54/writer.rb

@@ -0,0 +1,45 @@
+require_relative 'function'
+require_relative 'table'
+
+module Component
+  module V54
+    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
+      }
+    }
+  end
+end

data/components/interpreters.rb

@@ -0,0 +1,11 @@
+require_relative 'interpreters/50/interpreter'
+require_relative 'interpreters/51/interpreter'
+require_relative 'interpreters/54/interpreter'
+
+module Component
+  Interpreters = {
+    '5.0' => { version: '5.0', interpreter: V50::Interpreter },
+    '5.1' => { version: '5.1', interpreter: V51::Interpreter },
+    '5.4' => { version: '5.4', interpreter: V54::Interpreter }
+  }
+end

data/components/io.rb

@@ -0,0 +1,11 @@
+require 'find'
+
+module Component
+  IO = {
+    read!: ->(path) { File.read(path) },
+    write!: ->(path, content) { File.write(path, content) },
+    find_by_pattern!: ->(pattern) { Dir.glob(pattern) },
+    find_recursively!: ->(initial_path) { Find.find(initial_path) },
+    reject_non_existent!: ->(paths) { paths.select { |path| File.file?(path) } }
+  }
+end

data/config/tests.sample.yml

@@ -0,0 +1,15 @@
+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
+
+5.4.4:
+  description: 'Lua 5.4.4 + Fennel 1.0.0'
+  shared_object: /resources/liblua.so.5.4.4
+  fennel: /resources/fennel.lua
+
+4.0.1:
+  description: 'Lua 4.0.1'
+  shared_objects:
+    - /resources/liblua.so.4.0.1
+    - /resources/liblualib.so.4.0.1