sweet-moon 0.0.4 → 0.0.7

data/components/interpreters/54/interpreter.rb

@@ -1,17 +1,19 @@
 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: { lua: state, avoid_gc: [] },
+        { state: { lua: state, avoid_gc: [], ruby_error_info: nil },
           error: state ? nil : :MemoryAllocation }
       },
 
@@ -40,7 +42,7 @@ module Component
       },
 
       push_value!: ->(api, state, value) {
-        Writer[:push!].(api, state, value)
+        Writer[:push!].(api, state, Component::V54, value)
         { state: state }
       },
 
@@ -55,7 +57,7 @@ module Component
         unless key.nil?
           if api.lua_typename(state[:lua],
                               api.lua_type(state[:lua], -1)).read_string == 'table'
-            Table[:read_field!].(api, state, key, -1)
+            Table[:read_field!].(api, state, Component::V54, key, -1)
           else
             api.lua_pushnil(state[:lua])
           end
@@ -70,7 +72,8 @@ module Component
       },
 
       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[:lua], -2) if result[:pop]
         api.lua_settop(state[:lua], -2) if extra_pop
@@ -79,7 +82,7 @@ module Component
       },
 
       read_all!: ->(api, state) {
-        result = Reader[:read_all!].(api, state)
+        result = Reader[:read_all!].(api, state, Component::V54)
 
         { state: state, output: result }
       },

data/components/interpreters/54/reader.rb

@@ -7,33 +7,34 @@ require_relative 'table'
 module Component
   module V54
     Reader = {
-      read_all!: ->(api, state) {
+      read_all!: ->(api, state, component) {
         (1..api.lua_gettop(state[:lua])).map do
-          Interpreter[:read_and_pop!].(api, state)[:output]
+          component::Interpreter[:read_and_pop!].(api, state)[:output]
         end.reverse
       },
 
-      read!: ->(api, state, 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[: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
 
         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

data/components/interpreters/54/table.rb

@@ -6,31 +6,36 @@ require_relative 'reader'
 module Component
   module V54
     Table = {
-      push!: ->(api, state, list, 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[:lua], 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])
+            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)
+            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) {
+      read!: ->(api, state, component, 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])
 
@@ -39,8 +44,8 @@ module Component
         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)
+          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]]
@@ -51,7 +56,7 @@ 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[:lua], stack_index, expected_key)

data/components/interpreters/54/writer.rb

@@ -4,8 +4,8 @@ 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[:lua], value.to_s)
         when 'number'
@@ -21,9 +21,9 @@ module Component
         when 'boolean'
           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[:lua], "#<#{value.class}:0x#{format('%016x', value.object_id)}>"

data/config/tests.sample.yml

@@ -1,43 +1,44 @@
 # Available at https://github.com/gbaptista/sweet-moon-test
 
-fennel-dev: '/home/me/sweet-moon-test/fennel-dev.lua'
+fennel-dev: '/home/gbaptista/Fennel/?.lua'
 
 luarocks:
+  expected: ['dkjson', 'supernova', 'readline']
   path:
     - /home/me/.luarocks/share/lua/5.4/?.lua
     - /home/me/.luarocks/share/lua/5.4/?/init.lua
+  cpath:
     - /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/api.rb

@@ -1,5 +1,6 @@
 require_relative '../components/injections'
 require_relative '../components/api'
+require_relative '../components/default'
 require_relative '../components/io'
 require_relative '../dsl/errors'
 
@@ -11,7 +12,9 @@ module Controller
     handle!: ->(options) {
       shared_objects = API[:elect_shared_objects!].(options[:shared_objects])
 
-      api = Component::API[:open!].(shared_objects)
+      api = Component::API[:open!].(
+        shared_objects, options, Component::Default.instance.options
+      )
 
       api_reference = API[:elect_api_reference!].(
         api.ffi_libraries, options[:api_reference]

data/controllers/state.rb

@@ -87,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/api.rb

@@ -1,3 +1,5 @@
+require_relative '../components/default'
+
 module DSL
   class Api
     attr_reader :functions, :meta
@@ -7,13 +9,31 @@ module DSL
 
       @functions = @component[:signatures].keys
 
-      @meta = Struct.new(
-        *@component[:meta][:elected].keys
-      ).new(*@component[:meta][:elected].values)
+      build_meta
 
       extend @component[:api]
     end
 
+    def build_global_ffi
+      global_ffi = Component::Default.instance.options[:global_ffi]
+
+      unless @component[:meta][:options][:global_ffi].nil?
+        global_ffi = @component[:meta][:options][:global_ffi]
+      end
+
+      global_ffi
+    end
+
+    def build_meta
+      meta_data = @component[:meta][:elected].clone
+
+      meta_data[:global_ffi] = build_global_ffi
+
+      @meta = Struct.new(
+        *meta_data.keys
+      ).new(*meta_data.values)
+    end
+
     def signature_for(function)
       @component[:signatures][function.to_sym]
     end

data/dsl/cache.rb

@@ -7,112 +7,126 @@ require_relative '../controllers/state'
 require_relative 'api'
 require_relative 'sweet_moon'
 
-class Cache
-  include Singleton
+module DSL
+  class Cache
+    include Singleton
 
-  def clear_global!
-    @cache[:global_state]&._unsafely_destroy
+    API_KEYS = %i[shared_objects api_reference global_ffi]
+    STATE_KEYS = %i[interpreter package_path package_cpath]
 
-    @cache.each_key { |key| @cache.delete(key) if key[/^global/] }
-  end
+    def api_keys?(options)
+      API_KEYS.each { |key| return true if options.key?(key) }
+      false
+    end
 
-  def keys
-    @cache.keys
-  end
+    def state_keys?(options)
+      STATE_KEYS.each { |key| return true if options.key?(key) }
+      false
+    end
 
-  def initialize
-    @cache = {}
-  end
+    def clear_global!
+      @cache[:global_state]&._unsafely_destroy
 
-  def global_state(options = {}, recreate: false)
-    key = :global_state
+      @cache.each_key { |key| @cache.delete(key) if key[/^global/] }
+    end
 
-    clear_global_state_cache!(options) if recreate
+    def keys
+      @cache.keys
+    end
 
-    return @cache[key] if @cache[key]
+    def initialize
+      @cache = {}
+    end
 
-    api = Cache.instance.api_module(options, :global_api_module)
-    interpreter = Cache.instance.interpreter_module(
-      api, options, :global_interpreter_module
-    )
+    def global_state(options = {}, recreate: false)
+      key = :global_state
 
-    @cache[key] = DSL::State.new(api, interpreter, Controller::State, options)
-    @cache[key].instance_eval('undef :destroy', __FILE__, __LINE__)
+      clear_global_state_cache!(options) if recreate
 
-    @cache[key]
-  end
+      return @cache[key] if @cache[key]
 
-  def global_api(options = {}, recreate: false)
-    key = :global_api
+      api = Cache.instance.api_module(options, :global_api_module)
+      interpreter = Cache.instance.interpreter_module(
+        api, options, :global_interpreter_module
+      )
 
-    clear_global_api_cache! if recreate
+      @cache[key] = DSL::State.new(api, interpreter, Controller::State, options)
+      @cache[key].instance_eval('undef :destroy', __FILE__, __LINE__)
 
-    @cache[key] ||= api(options, :global_api, :global_api_module)
-  end
+      @cache[key]
+    end
 
-  def api(options = {}, key = nil, api_module_key = nil)
-    key ||= cache_key_for(:api, options, %i[shared_objects api_reference])
-    @cache[key] ||= DSL::Api.new(api_module(options, api_module_key))
-  end
+    def global_api(options = {}, recreate: false)
+      key = :global_api
 
-  def api_module(options = {}, key = nil)
-    key ||= cache_key_for(:api_module, options, %i[shared_objects api_reference])
-    @cache[key] ||= Controller::API[:handle!].(options)
-  end
+      clear_global_api_cache! if recreate
 
-  def interpreter_module(api, options = {}, key = nil)
-    key ||= cache_key_for(
-      :interpreter_module,
-      { shared_objects: api[:meta][:elected][:shared_objects],
-        api_reference: api[:meta][:elected][:api_reference],
-        interpreter: options[:interpreter], package_path: options[:package_path],
-        package_cpath: options[:package_cpath] },
-      %i[shared_objects api_reference interpreter package_path package_cpath]
-    )
-
-    @cache[key] ||= Controller::Interpreter[:handle!].(api, options)
-  end
+      @cache[key] ||= api(options, :global_api, :global_api_module)
+    end
 
-  private
+    def api(options = {}, key = nil, api_module_key = nil)
+      key ||= cache_key_for(:api, options, API_KEYS)
+      @cache[key] ||= DSL::Api.new(api_module(options, api_module_key))
+    end
 
-  def clear_global_api_cache!
-    @cache[:global_state]&._unsafely_destroy
+    def api_module(options = {}, key = nil)
+      key ||= cache_key_for(:api_module, options, API_KEYS)
+      @cache[key] ||= Controller::API[:handle!].(options)
+    end
 
-    %i[global_api global_api_module
-       global_interpreter_module
-       global_state].each do |key|
-      @cache.delete(key)
+    def interpreter_module(api, options = {}, key = nil)
+      key ||= cache_key_for(
+        :interpreter_module,
+        { shared_objects: api[:meta][:elected][:shared_objects],
+          api_reference: api[:meta][:elected][:api_reference],
+          global_ffi: api[:meta][:global_ffi],
+          interpreter: options[:interpreter], package_path: options[:package_path],
+          package_cpath: options[:package_cpath] },
+        API_KEYS.concat(STATE_KEYS)
+      )
+
+      @cache[key] ||= Controller::Interpreter[:handle!].(api, options)
     end
-  end
 
-  def clear_global_state_cache!(options)
-    @cache[:global_state]&._unsafely_destroy
+    def cache_key_for(prefix, options = {}, relevant_keys = [])
+      values = [prefix]
 
-    %i[global_interpreter_module global_state].each do |key|
-      @cache.delete(key)
-    end
+      relevant_keys.each do |key|
+        value = options[key]
+        value = options[key.to_s] if value.nil?
 
-    return unless options.key?(:shared_objects) || options.key?(:api_reference)
+        values << (value.is_a?(Array) ? value.sort.join(':') : value.inspect)
+      end
 
-    %i[global_api global_api_module].each do |key|
-      @cache.delete(key)
+      values.join('|')
     end
 
-    global_api(options, recreate: true)
-  end
+    private
 
-  def cache_key_for(prefix, options = {}, relevant_keys = [])
-    values = [prefix]
+    def clear_global_api_cache!
+      @cache[:global_state]&._unsafely_destroy
 
-    relevant_keys.each do |key|
-      value = options[key] || options[key.to_s]
-      if value.is_a?(Array)
-        values << value.sort.join(':')
-      elsif value
-        values << value
+      %i[global_api global_api_module
+         global_interpreter_module
+         global_state].each do |key|
+        @cache.delete(key)
       end
     end
 
-    values.join('|')
+    def clear_global_state_cache!(options)
+      @cache[:global_state]&._unsafely_destroy
+
+      %i[global_interpreter_module global_state].each do |key|
+        @cache.delete(key)
+      end
+
+      return unless api_keys?(options)
+
+      %i[global_api global_api_module].each do |key|
+        @cache.delete(key)
+      end
+
+      global_api(options, recreate: true)
+    end
   end
 end

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,8 +11,7 @@ module DSL
         'table.insert(package.loaders or package.searchers, fennel.searcher)'
       )
 
-      # TODO: Makes sense?
-      # debug.traceback = fennel.traceback
+      @state.eval('debug.traceback = fennel.traceback')
 
       @eval = @state.get(:fennel, :eval)
       @dofile = @state.get(:fennel, :dofile)
@@ -21,12 +20,16 @@ module DSL
       build_meta
     end
 
-    def eval(input, outputs = 1)
-      @eval.([input], outputs)
+    def eval(input, first = nil, second = nil)
+      options = _build_options(first, second)
+
+      @eval.([input, options[:options]], options[:outputs])
     end
 
-    def load(path, outputs = 1)
-      @dofile.([path], outputs)
+    def load(path, first = nil, second = nil)
+      options = _build_options(first, second)
+
+      @dofile.([path, options[:options]], options[:outputs])
     end
 
     def build_meta

data/dsl/global.rb

@@ -2,41 +2,40 @@ require_relative '../logic/options'
 
 require_relative 'cache'
 
-module Global
-  def api
-    Cache.instance.global_api
-  end
+module DSL
+  module Global
+    def api
+      Cache.instance.global_api
+    end
 
-  def state
-    Cache.instance.global_state
-  end
+    def state
+      Cache.instance.global_state
+    end
 
-  def config(options = {})
-    options = Logic::Options[:normalize].(options)
+    def config(options = {})
+      options = Logic::Options[:normalize].(options)
 
-    if options.key?(:shared_objects) || options.key?(:api_reference)
-      Cache.instance.global_api(options, recreate: true)
-    end
+      if Cache.instance.api_keys?(options)
+        Cache.instance.global_api(options, recreate: true)
+      end
 
-    return unless
-      options.key?(:interpreter) ||
-      options.key?(:package_path) ||
-      options.key?(:package_cpath)
+      return unless Cache.instance.state_keys?(options)
 
-    Cache.instance.global_state(options, recreate: true)
+      Cache.instance.global_state(options, recreate: true)
 
-    nil
-  end
+      nil
+    end
 
-  def cached(all: false)
-    return Cache.instance.keys if all
+    def cached(all: false)
+      return Cache.instance.keys if all
 
-    Cache.instance.keys.select { |key| key[/^global/] }
-  end
+      Cache.instance.keys.select { |key| key[/^global/] }
+    end
 
-  def clear
-    Cache.instance.clear_global!
-  end
+    def clear
+      Cache.instance.clear_global!
+    end
 
-  module_function :api, :state, :config, :cached, :clear
+    module_function :api, :state, :config, :cached, :clear
+  end
 end