sweet-moon 0.0.1

data/dsl/concerns/packages.rb

@@ -0,0 +1,37 @@
+require_relative '../errors'
+
+module DSL
+  module Concerns
+    module Packages
+      def add_package_path(path, target = 'package.path')
+        _ensure_min_version!(target, '5.1', '2')
+
+        paths = path
+        paths = [path] unless paths.is_a? Array
+
+        self.eval("#{target} = #{target} .. \";#{paths.join(';')}\"")
+      end
+
+      def package_path(target = 'package.path')
+        _ensure_min_version!(target, '5.1', '2')
+        self.eval("return #{target}").split(';')
+      end
+
+      def add_package_cpath(path)
+        add_package_path(path, 'package.cpath')
+      end
+
+      def package_cpath
+        package_path('package.cpath')
+      end
+
+      def require_module(module_name)
+        require_module_as(module_name, module_name)
+      end
+
+      def require_module_as(module_name, variable)
+        self.eval("#{variable} = require \"#{module_name}\"")
+      end
+    end
+  end
+end

data/dsl/errors.rb

@@ -0,0 +1,28 @@
+module SweetMoon
+  module Errors
+    class SweetMoonError < StandardError; end
+    class LuaError < SweetMoonError; end
+
+    class LuaRuntimeError < LuaError; end
+    class LuaMemoryAllocationError < LuaError; end
+    class LuaMessageHandlerError < LuaError; end
+    class LuaSyntaxError < LuaError; end
+    class LuaFileError < LuaError; end
+
+    module SweetMoonErrorHelper
+      def for(status)
+        case status
+        when :runtime           then LuaRuntimeError
+        when :memory_allocation then LuaMemoryAllocationError
+        when :message_handler   then LuaMessageHandlerError
+        when :syntax            then LuaSyntaxError
+        when :file              then LuaFileError
+        else
+          LuaError
+        end
+      end
+
+      module_function :for
+    end
+  end
+end

data/dsl/fennel.rb

@@ -0,0 +1,47 @@
+module DSL
+  class Fennel
+    attr_reader :meta
+
+    def initialize(state)
+      @state = state
+
+      @state.require_module(:fennel)
+
+      @state.eval(
+        'table.insert(package.loaders or package.searchers, fennel.searcher)'
+      )
+
+      @eval = @state.get(:fennel, :eval)
+      @dofile = @state.get(:fennel, :dofile)
+      @version = @state.get(:fennel, :version)
+
+      build_meta
+    end
+
+    def eval(input, outputs = 1)
+      @eval.([input], outputs)
+    end
+
+    def load(path, outputs = 1)
+      @dofile.([path], outputs)
+    end
+
+    def build_meta
+      meta_data = @state.meta.to_h
+
+      meta_data = meta_data.merge(
+        runtime: "Fennel #{@version} on #{meta_data[:runtime]}"
+      )
+
+      @meta = Struct.new(*meta_data.keys).new(*meta_data.values)
+    end
+
+    def respond_to_missing?(method_name)
+      @state.respond_to? method_name
+    end
+
+    def method_missing(method_name, *arguments, &block)
+      @state.public_send(method_name, *arguments, &block)
+    end
+  end
+end

data/dsl/global.rb

@@ -0,0 +1,42 @@
+require_relative '../logic/options'
+
+require_relative 'cache'
+
+module Global
+  def api
+    Cache.instance.global_api
+  end
+
+  def state
+    Cache.instance.global_state
+  end
+
+  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
+
+    return unless
+      options.key?(:interpreter) ||
+      options.key?(:package_path) ||
+      options.key?(:package_cpath)
+
+    Cache.instance.global_state(options, recreate: true)
+
+    nil
+  end
+
+  def cached(all: false)
+    return Cache.instance.keys if all
+
+    Cache.instance.keys.select { |key| key[/^global/] }
+  end
+
+  def clear
+    Cache.instance.clear_global!
+  end
+
+  module_function :api, :state, :config, :cached, :clear
+end

data/dsl/state.rb

@@ -0,0 +1,104 @@
+require_relative 'errors'
+require_relative 'concerns/packages'
+require_relative 'concerns/fennel'
+
+module DSL
+  class State
+    include DSL::Concerns::Packages
+    include DSL::Concerns::Fennel
+
+    attr_reader :meta
+
+    def initialize(api_component, interpreter_component, controller, options = {})
+      @api = api_component[:api]
+      @interpreter = interpreter_component[:interpreter]
+      @controller = controller
+
+      @state = @controller[:create!].(@api, @interpreter)[:state]
+
+      build_meta(api_component, interpreter_component)
+
+      add_package_path(options[:package_path]) if options[:package_path]
+      add_package_cpath(options[:package_cpath]) if options[:package_cpath]
+    end
+
+    def eval(input, outputs = 1)
+      @controller[:eval!].(@api, @interpreter, state, input, outputs)[:output]
+    end
+
+    def load(path, outputs = 1)
+      @controller[:load!].(@api, @interpreter, state, path, outputs)[:output]
+    end
+
+    def get(variable, key = nil)
+      @controller[:get!].(@api, @interpreter, state, variable, key)[:output]
+    end
+
+    def set(variable, value)
+      @controller[:set!].(@api, @interpreter, state, variable, value)[:output]
+    end
+
+    def destroy
+      @controller[:destroy!].(@api, @interpreter, state) if @state
+      @state = nil
+    end
+
+    def clear
+      @controller[:destroy!].(@api, @interpreter, state) if @state
+      @state = @controller[:create!].(@api, @interpreter)[:state]
+      nil
+    end
+
+    def _ensure_min_version!(purpose, lua, jit = nil)
+      version = lua
+      version = jit if meta.interpreter[/jit/] && jit
+
+      return unless Gem::Version.new(
+        meta.interpreter.gsub(/.+:/, '')
+      ) < Gem::Version.new(version)
+
+      message = "#{purpose} requires Lua >= #{lua}"
+      message = "#{message} or LuaJIT >= #{jit}" if jit
+
+      raise SweetMoon::Errors::SweetMoonError,
+            "#{message}; Current: #{meta.runtime} (#{meta.interpreter})"
+    end
+
+    def _unsafely_destroy
+      @controller[:destroy!].(@api, @interpreter, state)
+      @state = nil
+    end
+
+    def inspect
+      output = "#<#{self.class}:0x#{format('%016x', object_id)}"
+
+      variables = ['@meta'].map do |struct_name|
+        "#{struct_name}=#{instance_variable_get(struct_name).inspect}"
+      end
+
+      "#{output} #{variables.join(' ')}>"
+    end
+
+    private
+
+    def build_meta(api_component, interpreter_component)
+      meta_data = {
+        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]
+      }
+
+      @meta = Struct.new(*meta_data.keys).new(*meta_data.values)
+    end
+
+    def state
+      unless @state
+        raise SweetMoon::Errors::SweetMoonError,
+              'The state no longer exists.'
+      end
+
+      @state
+    end
+  end
+end

data/dsl/sweet_moon.rb

@@ -0,0 +1,53 @@
+require_relative '../logic/options'
+require_relative '../logic/spec'
+
+require_relative 'cache'
+require_relative 'state'
+require_relative 'global'
+
+require_relative '../logic/api'
+require_relative '../logic/interpreter'
+
+module SweetMoon
+  module API
+    def new(options = {})
+      Cache.instance.api(Logic::Options[:normalize].(options))
+    end
+
+    module_function :new
+  end
+
+  module State
+    def new(options = {})
+      options = Logic::Options[:normalize].(options)
+
+      api = Cache.instance.api_module(options)
+
+      interpreter = Cache.instance.interpreter_module(api, options)
+
+      DSL::State.new(api, interpreter, Controller::State, options)
+    end
+
+    module_function :new
+  end
+
+  def meta
+    meta_data = {
+      version: Logic::Spec[:version],
+      api_references: Logic::API[:candidates].values.map do |candidate|
+        candidate[:version]
+      end,
+      interpreters: Logic::Interpreter[:candidates].values.map do |candidate|
+        candidate[:version]
+      end
+    }
+
+    Struct.new(*meta_data.keys).new(*meta_data.values)
+  end
+
+  def global
+    Global
+  end
+
+  module_function :meta, :global
+end

data/logic/api.rb

@@ -0,0 +1,17 @@
+require_relative 'signatures/signatures_322'
+require_relative 'signatures/signatures_401'
+require_relative 'signatures/signatures_503'
+require_relative 'signatures/signatures_514'
+require_relative 'signatures/signatures_542'
+
+module Logic
+  API = {
+    candidates: {
+      '3.2.2' => { version: '3.2.2', signatures: V322::Signatures },
+      '4.0.1' => { version: '4.0.1', signatures: V401::Signatures },
+      '5.0.3' => { version: '5.0.3', signatures: V503::Signatures },
+      '5.1.4' => { version: '5.1.4', signatures: V514::Signatures },
+      '5.4.2' => { version: '5.4.2', signatures: V542::Signatures }
+    }
+  }
+end

data/logic/interpreter.rb

@@ -0,0 +1,84 @@
+require_relative 'interpreters/interpreter_50'
+require_relative 'interpreters/interpreter_51'
+require_relative 'interpreters/interpreter_54'
+
+module Logic
+  Interpreter = {
+    candidates: {
+      '5.0' => { version: '5.0', requires: V50::Interpreter[:requires] },
+      '5.1' => { version: '5.1', requires: V51::Interpreter[:requires] },
+      '5.4' => { version: '5.4', requires: V54::Interpreter[:requires] }
+    },
+
+    elect: ->(signatures, api_version, options = {}) {
+      interpreters = Interpreter[:candidates].values
+
+      if options[:interpreter]
+        interpreters = interpreters.select do |interpreter|
+          interpreter[:version].to_s == options[:interpreter]
+        end
+
+        if interpreters.size.zero?
+          return {
+            compatible: false,
+            error: "Interpreter #{options[:interpreter]} not available."
+          }
+        end
+      end
+
+      results = {}
+
+      interpreters.each do |interpreter|
+        results[interpreter[:version]] = Interpreter[:check_compatibility].(
+          interpreter, signatures
+        )
+      end
+
+      result = Interpreter[:choose_compatible].(results)
+
+      return result if result
+
+      { compatible: false,
+        error: Interpreter[:closest_error_message].(api_version, results) }
+    },
+
+    closest_error_message: ->(api_version, candidates) {
+      closest = candidates.values.sort_by do |candidate|
+        Gem::Version.new(candidate[:version].gsub(/.+:/, '') || '0')
+      end.reverse
+
+      closest = closest.min_by { |candidate| candidate[:missing].size }
+
+      message = "Missing in the closest version (#{closest[:version]}):"
+
+      closest[:missing].sort.each_slice(4).each do |functions|
+        message += "\n  #{functions.join(' ')}"
+      end
+
+      "No compatible interpreter found for Lua C API #{api_version}.\n#{message}"
+    },
+
+    choose_compatible: ->(candidates) {
+      candidates = candidates.values.select do |candidate|
+        candidate[:compatible]
+      end
+
+      candidates.max_by do |candidate|
+        Gem::Version.new(candidate[:version].gsub(/.+:/, '') || '0')
+      end
+    },
+
+    check_compatibility: ->(interpreter, signatures) {
+      result = { version: interpreter[:version], compatible: true, missing: [] }
+
+      interpreter[:requires].each do |required|
+        unless signatures[required]
+          result[:compatible] = false
+          result[:missing] << required
+        end
+      end
+
+      result
+    }
+  }
+end

data/logic/interpreters/interpreter_50.rb

@@ -0,0 +1,34 @@
+module Logic
+  module V50
+    Interpreter = {
+      version: '5.0',
+
+      LUA_REGISTRYINDEX: -10_000,
+      LUA_GLOBALSINDEX: -10_001,
+
+      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
+        lua_pushstring lua_rawgeti lua_settable lua_settop lua_toboolean lua_tonumber
+        lua_topointer lua_tostring lua_type lua_typename luaL_loadbuffer luaL_loadfile
+        luaL_ref luaopen_base luaopen_io luaopen_math luaopen_string luaopen_table
+      ],
+
+      status: {
+        1 => :LUA_ERRRUN,
+        2 => :LUA_ERRFILE,
+        3 => :LUA_ERRSYNTAX,
+        4 => :LUA_ERRMEM,
+        5 => :LUA_ERRERR
+      },
+
+      error: {
+        LUA_ERRRUN: :runtime,
+        LUA_ERRFILE: :file,
+        LUA_ERRSYNTAX: :syntax,
+        LUA_ERRMEM: :memory_allocation,
+        LUA_ERRERR: :message_handler
+      }
+    }
+  end
+end

data/logic/interpreters/interpreter_51.rb

@@ -0,0 +1,37 @@
+module Logic
+  module V51
+    Interpreter = {
+      version: '5.1',
+
+      LUA_REGISTRYINDEX: -10_000,
+      LUA_GLOBALSINDEX: -10_002,
+
+      # lua_isinteger lua_pushinteger lua_tointeger
+      requires: %i[
+        lua_close lua_createtable lua_getfield lua_gettable lua_gettop lua_insert
+        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
+      ],
+
+      status: {
+        0 => :LUA_OK,
+        1 => :LUA_YIELD,
+        2 => :LUA_ERRRUN,
+        3 => :LUA_ERRSYNTAX,
+        4 => :LUA_ERRMEM,
+        5 => :LUA_ERRERR,
+        6 => :LUA_ERRFILE
+      },
+
+      error: {
+        LUA_ERRRUN: :runtime,
+        LUA_ERRSYNTAX: :syntax,
+        LUA_ERRMEM: :memory_allocation,
+        LUA_ERRERR: :message_handler,
+        LUA_ERRFILE: :file
+      }
+    }
+  end
+end

data/logic/interpreters/interpreter_54.rb

@@ -0,0 +1,41 @@
+module Logic
+  module V54
+    Interpreter = {
+      version: '5.4',
+
+      LUA_RIDX_GLOBALS: 2,
+
+      # TODO: It's possible to read C constants?
+      # LUAI_MAXSTACK = 1_000_000
+      # -LUAI_MAXSTACK - 1000
+      LUA_REGISTRYINDEX: -1_000_000 - 1000,
+
+      # 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
+      ],
+
+      status: {
+        0 => :LUA_OK,
+        1 => :LUA_YIELD,
+        2 => :LUA_ERRRUN,
+        3 => :LUA_ERRSYNTAX,
+        4 => :LUA_ERRMEM,
+        5 => :LUA_ERRERR,
+        6 => :LUA_ERRFILE
+      },
+
+      error: {
+        LUA_ERRRUN: :runtime,
+        LUA_ERRSYNTAX: :syntax,
+        LUA_ERRMEM: :memory_allocation,
+        LUA_ERRERR: :message_handler,
+        LUA_ERRFILE: :file
+      }
+    }
+  end
+end

data/logic/io.rb

@@ -0,0 +1,6 @@
+module Logic
+  IO = {
+    extension: ->(path) { File.extname(path) },
+    file_name: ->(path) { File.basename(path) }
+  }
+end

data/logic/options.rb

@@ -0,0 +1,14 @@
+module Logic
+  Options = {
+    normalize: ->(original_options) {
+      options = original_options.clone
+
+      if options[:shared_object]
+        options[:shared_objects] = [options[:shared_object]]
+        options.delete(:shared_object)
+      end
+
+      options
+    }
+  }
+end

data/logic/shared_object.rb

@@ -0,0 +1,52 @@
+require_relative './io'
+
+module Logic
+  SharedObject = {
+    choose: ->(candidate_paths, options = {}) {
+      candidates = candidate_paths.map do |path|
+        SharedObject[:normalize].(path)
+      end
+
+      unless options[:jit].nil?
+        candidates = candidates.select do |candidate|
+          options[:jit] ? candidate[:inferences][:jit] : !candidate[:inferences][:jit]
+        end
+      end
+
+      if options[:version]
+        candidates = candidates.select do |candidate|
+          if candidate[:inferences][:version]
+            !candidate[:inferences][:version][/#{options[:version]}/].nil?
+          else
+            false
+          end
+        end
+      end
+
+      elected = candidates.max_by do |candidate|
+        Gem::Version.new(candidate[:inferences][:version] || '0')
+      end
+
+      return [] if elected.nil?
+
+      [elected]
+    },
+
+    normalize: ->(path) {
+      inferred_versions = IO[:file_name].(
+        path
+      ).scan(/(\d+(\.\d+)*)/).map(&:first)
+
+      inferred_versions = inferred_versions.map do |inferred_version|
+        inferred_version.split('.').map { |part| part.chars.join('.') }.join('.')
+      end
+
+      inferred_version = inferred_versions.max_by do |raw_inferred_version|
+        Gem::Version.new(raw_inferred_version || '0')
+      end
+
+      { path: path,
+        inferences: { jit: !path[/jit/].nil?, version: inferred_version } }
+    }
+  }
+end