sweet-moon 0.0.1

data/controllers/api.rb

@@ -0,0 +1,143 @@
+require_relative '../components/injections'
+require_relative '../components/api'
+require_relative '../components/io'
+require_relative '../dsl/errors'
+
+require_relative '../logic/api'
+require_relative '../logic/shared_object'
+
+module Controller
+  API = {
+    handle!: ->(options) {
+      shared_objects = API[:elect_shared_objects!].(options[:shared_objects])
+
+      api = Component::API[:open!].(shared_objects)
+
+      api_reference = API[:elect_api_reference!].(
+        api.ffi_libraries, options[:api_reference]
+      )
+
+      injections = Component::Injections[api_reference[:version]]
+      injections = if injections
+                     injections[:injections]
+                   else
+                     { macros: {},
+                       callbacks: [] }
+                   end
+
+      component = Component::API[:attach!].(api, api_reference, injections)
+
+      component[:meta] = {
+        options: options,
+        elected: {
+          shared_objects: shared_objects.map { |o| o[:path] },
+          api_reference: api_reference[:version]
+        }
+      }
+
+      component
+    },
+
+    elect_shared_objects!: ->(paths) {
+      candidates = []
+      shared_objects = []
+
+      if paths&.size&.positive?
+        candidates = paths
+
+        shared_objects = Component::IO[:reject_non_existent!].(paths).map do |path|
+          { path: path }
+        end
+      else
+        bases = %w[/usr/lib /usr/lib/* /usr/local/lib /opt/local/lib]
+
+        # XDG
+        if ENV['HOME']
+          bases << "#{ENV['HOME']}/.local/lib"
+          bases << "#{ENV['HOME']}/.local/lib/*"
+        end
+
+        bases.each do |base|
+          candidates.concat Component::IO[:find_by_pattern!].("#{base}/liblua*so*")
+          candidates.concat Component::IO[:find_by_pattern!].("#{base}/liblua*dylib*")
+        end
+
+        candidates = Component::IO[:reject_non_existent!].(candidates)
+
+        shared_objects = Logic::SharedObject[:choose].(candidates)
+      end
+
+      if shared_objects.size.zero?
+        raise SweetMoon::Errors::SweetMoonError,
+              "Lua shared object (liblua.so) not found: #{candidates}"
+      end
+
+      shared_objects
+    },
+
+    elect_api_reference!: ->(ffi_libraries, api_reference) {
+      availabe_candidates = Logic::API[:candidates].values
+
+      if api_reference
+        availabe_candidates = availabe_candidates.select do |candidate|
+          candidate[:version] == api_reference
+        end
+
+        if availabe_candidates.size.zero?
+          raise SweetMoon::Errors::SweetMoonError,
+                "API Reference #{api_reference} not available."
+        end
+      end
+
+      candidates = API[:calculate_compatibility!].(
+        availabe_candidates, ffi_libraries
+      )
+
+      candidates.sort_by do |_, functions|
+        functions[:found]
+      end.reverse
+
+      # TODO: This is the best strategy?
+      # version = candidates.sort_by do |_, functions|
+      #   functions[:proportion]
+      # end.reverse.first.first
+
+      version = candidates.sort_by do |_, functions|
+        functions[:found] * functions[:proportion]
+      end.reverse.first.first
+
+      Logic::API[:candidates][version]
+    },
+
+    calculate_compatibility!: ->(availabe_candidates, ffi_libraries) {
+      candidates = {}
+
+      availabe_candidates.each do |candidate|
+        candidates[candidate[:version]] = {
+          found: 0,
+          expected: (
+            candidate[:signatures][:functions].size +
+            candidate[:signatures][:macros].size
+          )
+        }
+        candidate[:signatures][:functions].each do |signature|
+          function = signature[:ffi].first
+
+          ffi_libraries.each do |ffi_library|
+            if ffi_library.find_function(function.to_s)
+              candidates[candidate[:version]][:found] += 1
+              break
+            end
+          end
+        end
+
+        candidates[candidate[:version]][:proportion] = (
+          candidates[candidate[:version]][:found].to_f /
+          candidates[candidate[:version]][:expected]
+        )
+      end
+
+      candidates
+    }
+  }
+end

data/controllers/cli/cli.rb

@@ -0,0 +1,32 @@
+require 'yaml'
+
+require_relative '../../ports/out/shell'
+
+module Controller
+  module CLI
+    CLI = {
+      handle!: ->(arguments, _fennel = false) {
+        options = {}
+
+        arguments = arguments.select do |argument|
+          if argument[/^-/]
+            options[argument] = true
+            false
+          else
+            true
+          end
+        end
+
+        if options['-i']
+          return Port::Out::Shell[:dispatch!].(YAML.dump({ TODO: true }))
+        end
+
+        input = arguments.first
+
+        output = options['-e'] ? "TODO eval #{input}" : "TODO file #{input}"
+
+        Port::Out::Shell[:dispatch!].(output) if options['-o']
+      }
+    }
+  end
+end

data/controllers/cli/help.rb

@@ -0,0 +1,24 @@
+require_relative '../../ports/out/shell'
+require_relative '../../logic/spec'
+
+module Controller
+  module CLI
+    Help = {
+      handle!: -> {
+        Port::Out::Shell[:dispatch!].(
+          "\n#{Logic::Spec[:command]} #{Logic::Spec[:version]}\n\n" \
+          "usage:\n" \
+          "  #{Logic::Spec[:command]} version\n"\
+          "  #{Logic::Spec[:command]} signatures /lua/source [output.rb]\n"\
+          "  #{Logic::Spec[:command]} lua -i\n"\
+          "  #{Logic::Spec[:command]} lua file.lua [-o]\n"\
+          "  #{Logic::Spec[:command]} lua -e \"print(1 + 2);\" [-o]\n"\
+          "  #{Logic::Spec[:command]} fennel -i\n"\
+          "  #{Logic::Spec[:command]} fennel file.fnl [-o]\n"\
+          "  #{Logic::Spec[:command]} fennel -e \"(+ 1 2)\" [-o]"\
+          "\n\n"
+        )
+      }
+    }
+  end
+end

data/controllers/cli/signatures.rb

@@ -0,0 +1,179 @@
+require 'pp'
+require 'yaml'
+
+require_relative '../../components/io'
+require_relative '../../logic/io'
+require_relative '../../logic/signature'
+require_relative '../../ports/out/shell'
+
+module Controller
+  module CLI
+    Signatures = {
+      handle!: ->(source_path, output_path = nil) {
+        functions = Signatures[:functions_from_shared_objects!].(source_path)
+        signatures, types = Signatures[:signatures_from_headers!].(source_path)
+
+        result = Signatures[:match_functions_and_signatures!].(
+          functions, signatures, types
+        )
+
+        primitives = Signatures[:collect_primitives!].(result[:attachables])
+
+        Signatures[:print_samples!].(result, functions, signatures, primitives)
+
+        return if output_path.nil?
+
+        output = {
+          functions: result[:attachables].values.map do |a|
+                       { source: a[:source], ffi: a[:ffi] }
+                     end,
+          macros: result[:macros].values.map do |a|
+                    { source: a[:source], name: a[:name],
+                      input: a[:input].map { |i| i[:name] } }
+                  end
+        }
+
+        output[:functions] = output[:functions].sort_by { |a| a[:source] }
+        output[:macros] = output[:macros].sort_by { |a| a[:source] }
+
+        Component::IO[:write!].(output_path, output.pretty_inspect)
+
+        Port::Out::Shell[:dispatch!].(
+          "\n > attachables dumped to: \"#{output_path}\""
+        )
+      },
+
+      print_samples!: ->(result, functions, signatures, primitives) {
+        Port::Out::Shell[:dispatch!].("#{functions.size} functions:\n")
+        2.times { Port::Out::Shell[:dispatch!].(" #{functions.sample}") }
+
+        Port::Out::Shell[:dispatch!].("\n#{signatures.size} signatures:\n")
+        2.times { Port::Out::Shell[:dispatch!].(" #{signatures.sample}") }
+
+        Port::Out::Shell[:dispatch!].("\n#{result[:attachables].size} attachables:\n")
+        2.times do
+          Port::Out::Shell[:dispatch!].(
+            " #{result[:attachables].values.sample[:name]}"
+          )
+        end
+
+        Port::Out::Shell[:dispatch!].("\n#{result[:macros].size} macros:\n")
+        2.times do
+          Port::Out::Shell[:dispatch!].(" #{result[:macros].values.sample[:name]}")
+        end
+
+        Port::Out::Shell[:dispatch!].("\n#{result[:missing].size} missing:\n")
+        (result[:missing].size < 3 ? 1 : 3).times do
+          Port::Out::Shell[:dispatch!].(" #{result[:missing].sample}")
+        end
+
+        Port::Out::Shell[:dispatch!].("\n#{primitives.size} primitives:\n")
+        Port::Out::Shell[:dispatch!].(
+          YAML.dump(primitives).lines[1..-1].map { |line| "  #{line}" }
+        )
+      },
+
+      collect_primitives!: ->(attachables) {
+        types = {}
+
+        attachables.each_value do |attachable|
+          unless attachable[:output][:pointer]
+            if types[attachable[:output][:primitive]].nil?
+              types[attachable[:output][:primitive]] = 0
+            end
+            types[attachable[:output][:primitive]] += 1
+          end
+
+          attachable[:input].each do |input|
+            unless input[:pointer]
+              types[input[:primitive]] = 0 if types[input[:primitive]].nil?
+              types[input[:primitive]] += 1
+            end
+          end
+        end
+
+        types
+      },
+
+      match_functions_and_signatures!: ->(functions, signatures, types) {
+        exists = {}
+
+        functions.each { |function| exists[function] = true }
+
+        attachables = {}
+        macros = {}
+        missing = []
+
+        signatures = signatures.map do |signature|
+          Logic::Signature[:extract_from_source].(signature, types)
+        end.compact
+
+        signatures.each do |signature|
+          next unless signature[:name][/^lua/i] # TODO: Is it true for Lua < 5?
+
+          if signature[:macro]
+            macros[signature[:name].to_sym] = signature
+          elsif exists[signature[:name]]
+            attachables[signature[:name].to_sym] = signature
+          end
+        end
+
+        attachables.values.map do |attachable|
+          attachable[:ffi] = Logic::Signature[:to_ffi].(attachable)
+        end
+
+        functions.each do |function|
+          missing << function unless attachables[function.to_sym]
+        end
+
+        { attachables: attachables, macros: macros, missing: missing }
+      },
+
+      functions_from_shared_objects!: ->(path) {
+        shared_objects = Component::IO[:find_recursively!].(
+          path
+        ).select do |candidate|
+          Logic::IO[:extension].(candidate) == '.so'
+        end
+
+        puts shared_objects
+
+        functions = []
+
+        command = 'nm --demangle --dynamic --defined-only --extern-only'
+
+        shared_objects.each do |shared_object_path|
+          functions.concat(
+            Logic::Signature[:extract_from_nm].(`#{command} #{shared_object_path}`)
+          )
+        end
+
+        functions.uniq.sort
+      },
+
+      signatures_from_headers!: ->(path) {
+        headers = Component::IO[:find_recursively!].(path).select do |candidate|
+          Logic::IO[:extension].(candidate) == '.h'
+        end
+
+        sources = headers.map { |header_path| Component::IO[:read!].(header_path) }
+
+        types = {}
+
+        sources.each do |source|
+          types = Logic::Signature[:extract_types_from_header].(source, types)
+        end
+
+        signatures = []
+
+        sources.each do |source|
+          signatures.concat(
+            Logic::Signature[:extract_from_header].(source)
+          )
+        end
+
+        [signatures.uniq.sort, types]
+      }
+    }
+  end
+end

data/controllers/cli/version.rb

@@ -0,0 +1,14 @@
+require_relative '../../ports/out/shell'
+require_relative '../../logic/spec'
+
+module Controller
+  module CLI
+    Version = {
+      handle!: -> {
+        Port::Out::Shell[:dispatch!].(
+          "\n#{Logic::Spec[:command]} #{Logic::Spec[:version]}\n\n"
+        )
+      }
+    }
+  end
+end

data/controllers/interpreter.rb

@@ -0,0 +1,68 @@
+require_relative '../components/interpreters'
+require_relative '../logic/interpreter'
+require_relative 'state'
+require_relative '../dsl/errors'
+
+module Controller
+  Interpreter = {
+    handle!: ->(api, options = {}) {
+      component = {}
+
+      component[:interpreter] = Interpreter[:elect_interpreter!].(
+        api, options
+      )
+
+      component = Interpreter[:build_meta!].(component, options)
+      component = Interpreter[:build_runtime!].(api, component, options)
+
+      component
+    },
+
+    build_meta!: ->(component, options) {
+      component[:meta] = {
+        options: options,
+        elected: {
+          interpreter: component[:interpreter][:version]
+        },
+        runtime: {}
+      }
+
+      component
+    },
+
+    build_runtime!: ->(api, component, _options) {
+      state = State[:create!].(api[:api], component[:interpreter])[:state]
+
+      result = State[:eval!].(
+        api[:api], component[:interpreter], state, 'return _VERSION;'
+      )
+
+      is_jit = State[:get!].(
+        api[:api], component[:interpreter], state, 'jit', 'version'
+      )[:output]
+
+      State[:destroy!].(api[:api], component[:interpreter], state)
+
+      component[:meta][:runtime][:lua] = if is_jit
+                                           "#{is_jit} (#{result[:output]})"
+                                         else
+                                           result[:output]
+                                         end
+
+      component
+    },
+
+    elect_interpreter!: ->(api, options) {
+      result = Logic::Interpreter[:elect].(
+        api[:signatures], api[:meta][:elected][:api_reference], options
+      )
+
+      unless result[:compatible]
+        raise SweetMoon::Errors::SweetMoonError,
+              result[:error]
+      end
+
+      return Component::Interpreters[result[:version]][:interpreter]
+    }
+  }
+end

data/controllers/state.rb

@@ -0,0 +1,74 @@
+require_relative '../dsl/errors'
+
+module Controller
+  State = {
+    create!: ->(api, interpreter) {
+      result = State[:_check!].(interpreter[:create_state!].(api))
+      result = State[:_check!].(
+        interpreter[:open_standard_libraries!].(api, result[:state])
+      )
+
+      { state: result[:state] }
+    },
+
+    eval!: ->(api, interpreter, state, input, outputs = 1) {
+      result = State[:_check!].(interpreter[:push_chunk!].(api, state, input))
+
+      State[:_call_and_read!].(api, interpreter, result[:state], outputs)
+    },
+
+    load!: ->(api, interpreter, state, path, outputs = 1) {
+      result = State[:_check!].(
+        interpreter[:load_file_and_push_chunck!].(api, state, path)
+      )
+
+      State[:_call_and_read!].(api, interpreter, result[:state], outputs)
+    },
+
+    get!: ->(api, interpreter, state, variable, key = nil) {
+      result = State[:_check!].(
+        interpreter[:get_variable_and_push!].(api, state, variable, key)
+      )
+
+      result = State[:_check!].(interpreter[:read_and_pop!].(
+                                  api, result[:state], -1, extra_pop: !key.nil?
+                                ))
+
+      { state: result[:state], output: result[:output] }
+    },
+
+    set!: ->(api, interpreter, state, variable, value) {
+      result = State[:_check!].(interpreter[:push_value!].(api, state, value))
+
+      result = State[:_check!].(
+        interpreter[:pop_and_set_as!].(api, result[:state], variable.to_s)
+      )
+
+      { state: result[:state], output: result[:output] }
+    },
+
+    destroy!: ->(api, interpreter, state) {
+      State[:_check!].(interpreter[:destroy_state!].(api, state))
+
+      { state: nil }
+    },
+
+    _call_and_read!: ->(api, interpreter, state, outputs = 1) {
+      result = State[:_check!].(interpreter[:call!].(api, state, 0, outputs))
+      result = State[:_check!].(interpreter[:read_all!].(api, result[:state]))
+
+      { state: result[:state],
+        output: outputs <= 1 ? result[:output].first : result[:output] }
+    },
+
+    _check!: ->(result) {
+      if result[:error]
+        raise SweetMoon::Errors::SweetMoonErrorHelper.for(
+          result[:error][:status]
+        ), result[:error][:value]
+      end
+
+      result
+    }
+  }
+end

data/dsl/api.rb

@@ -0,0 +1,31 @@
+module DSL
+  class Api
+    attr_reader :functions, :meta
+
+    def initialize(component)
+      @component = component
+
+      @functions = @component[:signatures].keys
+
+      @meta = Struct.new(
+        *@component[:meta][:elected].keys
+      ).new(*@component[:meta][:elected].values)
+
+      extend @component[:api]
+    end
+
+    def signature_for(function)
+      @component[:signatures][function.to_sym]
+    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
+  end
+end

data/dsl/cache.rb

@@ -0,0 +1,118 @@
+require 'singleton'
+
+require_relative '../controllers/api'
+require_relative '../controllers/interpreter'
+require_relative '../controllers/state'
+
+require_relative 'api'
+require_relative 'sweet_moon'
+
+class Cache
+  include Singleton
+
+  def clear_global!
+    @cache[:global_state]&._unsafely_destroy
+
+    @cache.each_key { |key| @cache.delete(key) if key[/^global/] }
+  end
+
+  def keys
+    @cache.keys
+  end
+
+  def initialize
+    @cache = {}
+  end
+
+  def global_state(options = {}, recreate: false)
+    key = :global_state
+
+    clear_global_state_cache!(options) if recreate
+
+    return @cache[key] if @cache[key]
+
+    api = Cache.instance.api_module(options, :global_api_module)
+    interpreter = Cache.instance.interpreter_module(
+      api, options, :global_interpreter_module
+    )
+
+    @cache[key] = DSL::State.new(api, interpreter, Controller::State, options)
+    @cache[key].instance_eval('undef :destroy', __FILE__, __LINE__)
+
+    @cache[key]
+  end
+
+  def global_api(options = {}, recreate: false)
+    key = :global_api
+
+    clear_global_api_cache! if recreate
+
+    @cache[key] ||= api(options, :global_api, :global_api_module)
+  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 api_module(options = {}, key = nil)
+    key ||= cache_key_for(:api_module, options, %i[shared_objects api_reference])
+    @cache[key] ||= Controller::API[:handle!].(options)
+  end
+
+  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
+
+  private
+
+  def clear_global_api_cache!
+    @cache[:global_state]&._unsafely_destroy
+
+    %i[global_api global_api_module
+       global_interpreter_module
+       global_state].each do |key|
+      @cache.delete(key)
+    end
+  end
+
+  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 options.key?(:shared_objects) || options.key?(:api_reference)
+
+    %i[global_api global_api_module].each do |key|
+      @cache.delete(key)
+    end
+
+    global_api(options, recreate: true)
+  end
+
+  def cache_key_for(prefix, options = {}, relevant_keys = [])
+    values = [prefix]
+
+    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
+      end
+    end
+
+    values.join('|')
+  end
+end

data/dsl/concerns/fennel.rb

@@ -0,0 +1,13 @@
+require_relative '../fennel'
+
+module DSL
+  module Concerns
+    module Fennel
+      def fennel
+        _ensure_min_version!('Fennel', '5.1', '2')
+
+        @fennel ||= DSL::Fennel.new(self)
+      end
+    end
+  end
+end