crystalruby 0.1.1 → 0.1.3

data/lib/crystalruby/types/type.rb

@@ -0,0 +1,66 @@
+module CrystalRuby
+  module Types
+    class Type
+      attr_accessor :name, :error, :inner_types, :inner_keys, :accept_if, :convert
+
+      def initialize(name, error: nil, inner_types: nil, inner_keys: nil, accept_if: [], &convert)
+        self.name = name
+        self.error = error
+        self.inner_types = inner_types
+        self.inner_keys = inner_keys
+        self.accept_if = accept_if
+        self.convert = convert
+      end
+
+      def union_types
+        [self]
+      end
+
+      def valid?
+        !error
+      end
+
+      def |(other)
+        raise "Cannot union non-crystal type #{other}" unless other.is_a?(Type) || (
+          other.is_a?(Class) && other.ancestors.include?(Typedef)
+        )
+
+        UnionType.new(*union_types, *other.union_types)
+      end
+
+      def type_expr
+        inspect
+      end
+
+      def inspect
+        if !inner_types
+          name
+        elsif !inner_keys
+          "#{name}(#{inner_types.map(&:inspect).join(", ")})"
+        else
+          "#{name}(#{inner_keys.zip(inner_types).map { |k, v| "#{k}: #{v.inspect}" }.join(", ")})"
+        end
+      end
+
+      def interprets?(raw)
+        accept_if.any? { |type| raw.is_a?(type) }
+      end
+
+      def interpret!(raw)
+        if interprets?(raw)
+          convert ? convert.call(raw) : raw
+        else
+          raise "Invalid deserialized value #{raw} for type #{inspect}"
+        end
+      end
+
+      def self.validate!(type)
+        unless type.is_a?(Types::Type) || (type.is_a?(Class) && type.ancestors.include?(Types::Typedef))
+          raise "Result #{type} is not a valid CrystalRuby type"
+        end
+
+        raise "Invalid type: #{type.error}" unless type.valid?
+      end
+    end
+  end
+end

data/lib/crystalruby/types/type_serializer/json.rb

@@ -0,0 +1,40 @@
+require 'json'
+
+module CrystalRuby::Types
+  class TypeSerializer
+    class JSON < TypeSerializer
+
+      def lib_type
+        "UInt8*"
+      end
+
+      def crystal_type
+        type_expr
+      end
+
+      def error_value
+        '"{}".to_unsafe'
+      end
+
+      def ffi_type
+        :string
+      end
+
+      def prepare_argument(arg)
+        arg.to_json
+      end
+
+      def prepare_retval(retval)
+        @typedef.interpret!(::JSON.parse(retval))
+      end
+
+      def lib_to_crystal_type_expr(expr)
+        "(#{type_expr}).from_json(String.new(%s))" % expr
+      end
+
+      def crystal_to_lib_type_expr(expr)
+        "%s.to_json.to_unsafe" % expr
+      end
+    end
+  end
+end

data/lib/crystalruby/types/type_serializer.rb

@@ -0,0 +1,37 @@
+module CrystalRuby::Types
+  class TypeSerializer
+    include FFI::DataConverter
+    def self.for(format)
+      case format
+      when :json then JSON
+      else raise "Unknown type format: #{format}"
+      end
+    end
+
+    def error_value
+      0
+    end
+
+    def initialize(typedef)
+      @typedef = typedef
+    end
+
+    def type_expr
+      @typedef.type_expr
+    end
+
+    def type_defn
+      @typedef.type_defn
+    end
+
+    def anonymous?
+      @typedef.anonymous?
+    end
+
+    def name
+      @typedef.name
+    end
+  end
+end
+
+require_relative "type_serializer/json"

data/lib/crystalruby/types/typedef.rb

@@ -0,0 +1,55 @@
+require_relative "type_serializer"
+
+module CrystalRuby
+  module Types
+    class Typedef; end
+
+    def self.Typedef(type)
+      return type if type.kind_of?(Class) && type < Typedef
+
+      Class.new(Typedef) do
+        define_singleton_method(:union_types) do
+          [self]
+        end
+
+        define_singleton_method(:anonymous?) do
+          name.nil?
+        end
+
+        define_singleton_method(:valid?) do
+          type.valid?
+        end
+
+        define_singleton_method(:type) do
+          type
+        end
+
+        define_singleton_method(:type_expr) do
+          anonymous? ? type.type_expr : name
+        end
+
+        define_singleton_method(:type_defn) do
+          type.type_expr
+        end
+
+        define_singleton_method(:|) do |other|
+          raise "Cannot union non-crystal type #{other}" unless other.is_a?(Type) || other.is_a?(Typedef)
+
+          UnionType.new(*union_types, *other.union_types)
+        end
+
+        define_singleton_method(:inspect) do
+          "<#{name || "AnonymousType"} #{type.inspect}>"
+        end
+
+        define_singleton_method(:serialize_as) do |format|
+          TypeSerializer.for(format).new(self)
+        end
+
+        define_singleton_method(:interpret!) do |raw|
+          type.interpret!(raw)
+        end
+      end
+    end
+  end
+end

data/lib/crystalruby/types/union_type.rb

@@ -0,0 +1,37 @@
+module CrystalRuby
+  module Types
+    class UnionType < Type
+      attr_accessor :name, :union_types
+
+      def initialize(*union_types)
+        self.name = "UnionType"
+        self.union_types = union_types
+      end
+
+      def valid?
+        union_types.all?(&:valid?)
+      end
+
+      def error
+        union_types.map(&:error).join(", ")
+      end
+
+      def inspect
+        union_types.map(&:inspect).join(" | ")
+      end
+
+      def interprets?(raw)
+        union_types.any? { |type| type.interprets?(raw) }
+      end
+
+      def interpret!(raw)
+        union_types.each do |type|
+          if type.interprets?(raw)
+            return type.interpret!(raw)
+          end
+        end
+        raise "Invalid deserialized value #{raw} for type #{inspect}"
+      end
+    end
+  end
+end

data/lib/crystalruby/types.rb

@@ -0,0 +1,18 @@
+require_relative "types/type"
+require_relative "types/union_type"
+require_relative "types/typedef"
+require_relative "types/string"
+require_relative "types/time"
+require_relative "types/symbol"
+require_relative "types/array"
+require_relative "types/hash"
+require_relative "types/nil"
+require_relative "types/bool"
+require_relative "types/named_tuple"
+require_relative "types/tuple"
+require_relative "types/numbers"
+
+module CrystalRuby
+  module Types
+  end
+end

data/lib/crystalruby/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Crystalruby
-  VERSION = "0.1.1"
+  VERSION = "0.1.3"
 end

data/lib/crystalruby.rb

@@ -1,33 +1,41 @@
-require 'ffi'
-require 'digest'
-require 'fileutils'
-require 'method_source'
+require "ffi"
+require "digest"
+require "fileutils"
+require "method_source"
 require_relative "crystalruby/config"
 require_relative "crystalruby/version"
 require_relative "crystalruby/typemaps"
-# TODO
-# Shards
-# Object methods
-# Fix bigint issues
-# * Initialize Crystal project
-# * Clear build artifacts
-# * Add config file
-# * Set release flag (Changes build target locations)
-# Struct Conversions
-# Classes
-# Test Nesting
-
+require_relative "crystalruby/types"
+require_relative "crystalruby/typebuilder"
+require_relative "crystalruby/template"
 
 module CrystalRuby
-
   # Define a method to set the @crystalize proc if it doesn't already exist
-  def crystalize(type=:src, **options, &block)
+  def crystalize(type = :src, **options, &block)
     (args,), returns = options.first
     args ||= {}
-    raise "Arguments should be of the form name: :type. Got #{args}" unless args.kind_of?(Hash)
-    @crystalize_next = {raw: type.to_sym == :raw, args:, returns:, block: }
+    raise "Arguments should be of the form name: :type. Got #{args}" unless args.is_a?(Hash)
+
+    @crystalize_next = { raw: type.to_sym == :raw, args: args, returns: returns, block: block }
+  end
+
+  def crtype(&block)
+    TypeBuilder.with_injected_type_dsl(self) do
+      TypeBuilder.build(&block)
+    end
   end
 
+  def json(&block)
+    crtype(&block).serialize_as(:json)
+  end
+
+  def with_temporary_constant(constant_name, new_value)
+    old_value = const_get(constant_name)
+    const_set(constant_name, new_value)
+    yield
+  ensure
+    const_set(constant_name, old_value)
+  end
 
   def method_added(method_name)
     if @crystalize_next
@@ -42,7 +50,6 @@ module CrystalRuby
   end
 
   def attach_crystalized_method(method_name)
-
     CrystalRuby.instantiate_crystal_ruby! unless CrystalRuby.instantiated?
 
     function_body = instance_method(method_name).source.lines[
@@ -54,17 +61,18 @@ module CrystalRuby
     args ||= {}
     @crystalize_next = nil
     function = build_function(self, method_name, args, returns, function_body)
-
-    CrystalRuby.write_function(self, **function) do
+    CrystalRuby.write_function(self, name: function[:name], body: function[:body]) do
       extend FFI::Library
       ffi_lib "#{config.crystal_lib_dir}/#{config.crystal_lib_name}"
-      attach_function "#{method_name}", fname, args.map(&:last), returns
-      attach_function 'init!', 'init', [], :void
-      [singleton_class, self].each do |receiver|
-        receiver.prepend(Module.new do
-          define_method(method_name, &block)
-        end)
-      end if block
+      attach_function "#{method_name}", fname, function[:ffi_types], function[:return_ffi_type]
+      attach_function "init!", "init", [], :void
+      if block
+        [singleton_class, self].each do |receiver|
+          receiver.prepend(Module.new do
+            define_method(method_name, &block)
+          end)
+        end
+      end
 
       init!
     end
@@ -74,7 +82,15 @@ module CrystalRuby
         define_method(method_name) do |*args|
           CrystalRuby.compile! unless CrystalRuby.compiled?
           CrystalRuby.attach! unless CrystalRuby.attached?
-          super(*args)
+          args.each_with_index do |arg, i|
+            args[i] = function[:arg_maps][i][arg] if function[:arg_maps][i]
+          end
+          result = super(*args)
+          if function[:retval_map]
+            function[:retval_map][result]
+          else
+            result
+          end
         end
       end)
     end
@@ -82,63 +98,128 @@ module CrystalRuby
 
   module_function
 
-
   def build_function(owner, name, args, returns, body)
-    fnname = "#{owner.name.downcase}_#{name}"
-    args ||= {}
-    string_conversions = args.select { |_k, v| v.eql?(:string) }.keys
-    function_body = <<~CRYSTAL
-      module #{owner.name}
-        def self.#{name}(#{args.map { |k, v| "#{k} : #{native_type(v)}" }.join(',')}) : #{native_type(returns)}
-          #{body}
-        end
-      end
+    arg_types = args.transform_values(&method(:build_type_map))
+    return_type = build_type_map(returns)
+    function_body = Template.render(
+      Template::Function,
+      {
+        module_name: owner.name,
+        lib_fn_name: "#{owner.name.downcase}_#{name}",
+        fn_name: name,
+        fn_body: body,
+        fn_args: arg_types.map { |k, arg_type| "#{k} : #{arg_type[:crystal_type]}" }.join(","),
+        fn_ret_type: return_type[:crystal_type],
+        lib_fn_args: arg_types.map { |k, arg_type| "_#{k}: #{arg_type[:lib_type]}" }.join(","),
+        lib_fn_ret_type: return_type[:lib_type],
+        convert_lib_args:  arg_types.map{|k, arg_type| "#{k} = #{arg_type[:convert_lib_to_crystal_type]["_#{k}"]}" }.join("\n    "),
+        arg_names: args.keys.join(","),
+        convert_return_type: return_type[:convert_crystal_to_lib_type]["return_value"],
+        error_value: return_type[:error_value]
+      }
+    )
+    {
+      name: name,
+      body: function_body,
+      retval_map: returns.is_a?(Types::TypeSerializer) ? ->(rv) { returns.prepare_retval(rv) } : nil,
+      ffi_types: arg_types.map { |_k, arg_type| arg_type[:ffi_type] },
+      arg_maps: arg_types.map { |_k, arg_type| arg_type[:mapper] },
+      return_ffi_type: return_type[:return_ffi_type]
+    }
+  end
 
-      fun #{fnname}(#{args.map { |k, v| "_#{k}: #{lib_type(v)}" }.join(',')}): #{lib_type(returns)}
-        #{args.map { |k, v| "#{k} = #{convert_to_native_type("_#{k}", v)}" }.join("\n\t")}
-        #{convert_to_return_type("#{owner.name}.#{name}(#{args.keys.map { |k| "#{k}" }.join(',')})", returns)}
-      end
-    CRYSTAL
+  def build_type_map(crystalruby_type)
+    if crystalruby_type.is_a?(Types::TypeSerializer) && !crystalruby_type.anonymous?
+      CrystalRuby.register_type!(crystalruby_type)
+    end
 
     {
-      name: fnname,
-      body: function_body
+      ffi_type: ffi_type(crystalruby_type),
+      return_ffi_type: ffi_type(crystalruby_type),
+      crystal_type: crystal_type(crystalruby_type),
+      lib_type: lib_type(crystalruby_type),
+      error_value: error_value(crystalruby_type),
+      mapper: crystalruby_type.is_a?(Types::TypeSerializer) ? ->(arg) { crystalruby_type.prepare_argument(arg) } : nil,
+      convert_crystal_to_lib_type: ->(expr) { convert_crystal_to_lib_type(expr, crystalruby_type) },
+      convert_lib_to_crystal_type: ->(expr) { convert_lib_to_crystal_type(expr, crystalruby_type) }
     }
   end
 
+  def ffi_type(type)
+    case type
+    when Symbol then type
+    when Types::TypeSerializer then type.ffi_type
+    end
+  end
+
   def lib_type(type)
-    Typemaps::C_TYPE_MAP[type]
+    if type.is_a?(Types::TypeSerializer)
+      type.lib_type
+    else
+      Typemaps::C_TYPE_MAP.fetch(type)
+    end
+  rescue StandardError => e
+    raise "Unsupported type #{type}"
   end
 
-  def native_type(type)
-    Typemaps::CRYSTAL_TYPE_MAP[type]
+  def error_value(type)
+    if type.is_a?(Types::TypeSerializer)
+      type.error_value
+    else
+      Typemaps::ERROR_VALUE.fetch(type)
+    end
+  rescue StandardError => e
+    raise "Unsupported type #{type}"
   end
 
-  def convert_to_native_type(expr, outtype)
-    Typemaps::C_TYPE_CONVERSIONS[outtype] ? Typemaps::C_TYPE_CONVERSIONS[outtype][:from] % expr : expr
+  def crystal_type(type)
+    if type.is_a?(Types::TypeSerializer)
+      type.crystal_type
+    else
+      Typemaps::CRYSTAL_TYPE_MAP.fetch(type)
+    end
+  rescue StandardError => e
+    raise "Unsupported type #{type}"
   end
 
-  def convert_to_return_type(expr, outtype)
-    Typemaps::C_TYPE_CONVERSIONS[outtype] ? Typemaps::C_TYPE_CONVERSIONS[outtype][:to] % expr : expr
+  def convert_lib_to_crystal_type(expr, type)
+    if type.is_a?(Types::TypeSerializer)
+      type.lib_to_crystal_type_expr(expr)
+    else
+      Typemaps::C_TYPE_CONVERSIONS[type] ? Typemaps::C_TYPE_CONVERSIONS[type][:from] % expr : expr
+    end
+  end
+
+  def convert_crystal_to_lib_type(expr, type)
+    if type.is_a?(Types::TypeSerializer)
+      type.crystal_to_lib_type_expr(expr)
+    else
+      Typemaps::C_TYPE_CONVERSIONS[type] ? Typemaps::C_TYPE_CONVERSIONS[type][:to] % expr : expr
+    end
   end
 
   def self.instantiate_crystal_ruby!
-    raise "Crystal executable not found. Please ensure Crystal is installed and in your PATH." unless system("which crystal > /dev/null 2>&1")
+    unless system("which crystal > /dev/null 2>&1")
+      raise "Crystal executable not found. Please ensure Crystal is installed and in your PATH."
+    end
+
     @instantiated = true
     %w[crystal_lib_dir crystal_main_file crystal_src_dir crystal_lib_name].each do |config_key|
-      raise "Missing config option `#{config_key}`. \nProvide this inside crystalruby.yaml (run `bundle exec crystalruby init` to generate this file with detaults)" unless config.send(config_key)
+      unless config.send(config_key)
+        raise "Missing config option `#{config_key}`. \nProvide this inside crystalruby.yaml (run `bundle exec crystalruby init` to generate this file with detaults)"
+      end
     end
-    FileUtils.mkdir_p "#{config.crystal_src_dir}/generated"
+    FileUtils.mkdir_p "#{config.crystal_src_dir}/#{config.crystal_codegen_dir}"
     FileUtils.mkdir_p "#{config.crystal_lib_dir}"
     unless File.exist?("#{config.crystal_src_dir}/#{config.crystal_main_file}")
-      IO.write("#{config.crystal_src_dir}/#{config.crystal_main_file}", "require \"./generated/index\"\n")
+      IO.write("#{config.crystal_src_dir}/#{config.crystal_main_file}", "require \"./#{config.crystal_codegen_dir}/index\"\n")
     end
-    unless File.exist?("#{config.crystal_src_dir}/shard.yml")
-      IO.write("#{config.crystal_src_dir}/shard.yml", <<~CRYSTAL)
+    return if File.exist?("#{config.crystal_src_dir}/shard.yml")
+
+    IO.write("#{config.crystal_src_dir}/shard.yml", <<~CRYSTAL)
       name: src
       version: 0.1.0
-      CRYSTAL
-    end
+    CRYSTAL
   end
 
   def self.instantiated?
@@ -153,39 +234,75 @@ module CrystalRuby
     !!@attached
   end
 
-  def self.compile!
-    return unless @block_store
-    index_content = <<~CRYSTAL
-    FAKE_ARG = "crystal"
-    fun init(): Void
-      GC.init
-      ptr = FAKE_ARG.to_unsafe
-      LibCrystalMain.__crystal_main(1, pointerof(ptr))
-    end
-    CRYSTAL
+  def self.register_type!(type)
+    @types_cache ||= {}
+    @types_cache[type.name] = type.type_defn
+  end
 
-    index_content += @block_store.map do |function|
+  def type_modules
+    (@types_cache || {}).map do |type_name, expr|
+      typedef = ""
+      parts = type_name.split("::")
+      indent = ""
+      parts[0...-1].each do |part|
+        typedef << "#{indent} module #{part}\n"
+        indent += "  "
+      end
+      typedef << "#{indent}alias #{parts[-1]} = #{expr}\n"
+      parts[0...-1].each do |_part|
+        indent = indent[0...-2]
+        typedef << "#{indent} end\n"
+      end
+      typedef
+    end.join("\n")
+  end
+
+  def self.requires
+    @block_store.map do |function|
       function_data = function[:body]
       file_digest = Digest::MD5.hexdigest function_data
       fname = function[:name]
       "require \"./#{function[:owner].name}/#{fname}_#{file_digest}.cr\"\n"
     end.join("\n")
+  end
 
-    File.write("#{config.crystal_src_dir}/generated/index.cr", index_content)
-    begin
-      lib_target = "#{Dir.pwd}/#{config.crystal_lib_dir}/#{config.crystal_lib_name}"
-      Dir.chdir(config.crystal_src_dir) do
-        config.debug ?
-          `crystal build -o #{lib_target} #{config.crystal_main_file}` :
-          `crystal build --release --no-debug -o #{lib_target} #{config.crystal_main_file}`
-      end
+  def self.compile!
+    return unless @block_store
+
+    index_content = Template.render(
+      Template::Index,
+      {
+        type_modules: type_modules,
+        requires: requires
+      }
+    )
+
+    File.write("#{config.crystal_src_dir}/#{config.crystal_codegen_dir}/index.cr", index_content)
+    lib_target = "#{Dir.pwd}/#{config.crystal_lib_dir}/#{config.crystal_lib_name}"
+
+    Dir.chdir(config.crystal_src_dir) do
+      cmd = if config.debug
+              "crystal build -o #{lib_target} #{config.crystal_main_file}"
+            else
+              "crystal build --release --no-debug -o #{lib_target} #{config.crystal_main_file}"
+            end
+
+      raise "Error compiling crystal code" unless result = system(cmd)
 
       @compiled = true
-    rescue StandardError => e
-      puts 'Error compiling crystal code'
-      puts e
-      File.delete("#{config.crystal_src_dir}/generated/index.cr")
+      File.delete("#{config.crystal_codegen_dir}/index.cr") if File.exist?("#{config.crystal_codegen_dir}/index.cr")
     end
+    extend FFI::Library
+    ffi_lib "#{config.crystal_lib_dir}/#{config.crystal_lib_name}"
+    attach_function :attach_rb_error_handler, [:pointer], :int
+    const_set(:ErrorCallback, FFI::Function.new(:void, [:string, :string]) do |error_type, message|
+      error_type = error_type.to_sym
+      error_type = Object.const_defined?(error_type) && Object.const_get(error_type).ancestors.include?(Exception) ?
+        Object.const_get(error_type) :
+        RuntimeError
+        raise error_type.new(message)
+    end)
+    attach_rb_error_handler(ErrorCallback)
   end
 
   def self.attach!
@@ -196,25 +313,25 @@ module CrystalRuby
   end
 
   def self.write_function(owner, name:, body:, &compile_callback)
-    @compiled = File.exist?("#{config.crystal_src_dir}/generated/index.cr") unless defined?(@compiled)
+    @compiled = File.exist?("#{config.crystal_src_dir}/#{config.crystal_codegen_dir}/index.cr") unless defined?(@compiled)
     @block_store ||= []
-    @block_store << {owner: owner, name: name, body: body, compile_callback: compile_callback}
-    FileUtils.mkdir_p("#{config.crystal_src_dir}/generated")
-    existing = Dir.glob("#{config.crystal_src_dir}/generated/**/*.cr")
+    @block_store << { owner: owner, name: name, body: body, compile_callback: compile_callback }
+    FileUtils.mkdir_p("#{config.crystal_src_dir}/#{config.crystal_codegen_dir}")
+    existing = Dir.glob("#{config.crystal_src_dir}/#{config.crystal_codegen_dir}/**/*.cr")
     @block_store.each do |function|
       owner_name = function[:owner].name
-      FileUtils.mkdir_p("#{config.crystal_src_dir}/generated/#{owner_name}")
+      FileUtils.mkdir_p("#{config.crystal_src_dir}/#{config.crystal_codegen_dir}/#{owner_name}")
       function_data = function[:body]
       fname = function[:name]
       file_digest = Digest::MD5.hexdigest function_data
-      filename = "#{config.crystal_src_dir}/generated/#{owner_name}/#{fname}_#{file_digest}.cr"
+      filename = "#{config.crystal_src_dir}/#{config.crystal_codegen_dir}/#{owner_name}/#{fname}_#{file_digest}.cr"
       unless existing.delete(filename)
         @compiled = false
         @attached = false
         File.write(filename, function_data)
       end
       existing.select do |f|
-        f =~ %r{#{config.crystal_src_dir}/generated/#{owner_name}/#{fname}_[a-f0-9]{32}\.cr}
+        f =~ %r{#{config.crystal_src_dir}/#{config.crystal_codegen_dir}/#{owner_name}/#{fname}_[a-f0-9]{32}\.cr}
       end.each do |fl|
         File.delete(fl) unless fl.eql?(filename)
       end