sweet-moon 0.0.3 → 0.0.6

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,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/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

data/dsl/state.rb

@@ -1,13 +1,14 @@
 require_relative 'errors'
 require_relative 'concerns/packages'
 require_relative 'concerns/fennel'
+require_relative '../components/default'
 
 module DSL
   class State
     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 +23,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 +39,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
@@ -81,13 +88,25 @@ module DSL
 
     private
 
-    def build_meta(api_component, interpreter_component)
-      meta_data = {
+    def build_api_meta(api_component)
+      global_ffi = Component::Default.instance.options[:global_ffi]
+
+      unless api_component[:meta][:options][:global_ffi].nil?
+        global_ffi = api_component[:meta][:options][:global_ffi]
+      end
+
+      {
         api_reference: api_component[:meta][:elected][:api_reference],
         shared_objects: api_component[:meta][:elected][:shared_objects],
-        interpreter: interpreter_component[:meta][:elected][:interpreter],
-        runtime: interpreter_component[:meta][:runtime][:lua]
+        global_ffi: global_ffi
       }
+    end
+
+    def build_meta(api_component, interpreter_component)
+      meta_data = build_api_meta(api_component)
+
+      meta_data[:interpreter] = interpreter_component[:meta][:elected][:interpreter]
+      meta_data[:runtime] = interpreter_component[:meta][:runtime][:lua]
 
       @meta = Struct.new(*meta_data.keys).new(*meta_data.values)
     end

data/dsl/sweet_moon.rb

@@ -11,7 +11,7 @@ require_relative '../logic/interpreter'
 module SweetMoon
   module API
     def new(options = {})
-      Cache.instance.api(Logic::Options[:normalize].(options))
+      DSL::Cache.instance.api(Logic::Options[:normalize].(options))
     end
 
     module_function :new
@@ -21,9 +21,9 @@ module SweetMoon
     def new(options = {})
       options = Logic::Options[:normalize].(options)
 
-      api = Cache.instance.api_module(options)
+      api = DSL::Cache.instance.api_module(options)
 
-      interpreter = Cache.instance.interpreter_module(api, options)
+      interpreter = DSL::Cache.instance.interpreter_module(api, options)
 
       DSL::State.new(api, interpreter, Controller::State, options)
     end
@@ -46,7 +46,7 @@ module SweetMoon
   end
 
   def global
-    Global
+    DSL::Global
   end
 
   module_function :meta, :global

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.3',
+    version: '0.0.6',
     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.3
+  version: 0.0.6
 platform: ruby
 authors:
 - gbaptista
 autorequire:
 bindir: ports/in/shell
 cert_chain: []
-date: 2022-03-23 00:00:00.000000000 Z
+date: 2022-03-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -48,6 +48,7 @@ files:
 - LICENSE
 - README.md
 - components/api.rb
+- components/default.rb
 - components/injections.rb
 - components/injections/injections_503.rb
 - components/injections/injections_514.rb