crystalruby 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 46edf2cddbf8fc124cca7cab14a4c3d745fcf88b9a841468cdbc7f2fc517187a
-  data.tar.gz: c350e0049aff5d88f8326314e0a70fbe57ea3866dcdf247010a0c1c64f656899
+  metadata.gz: 157d03e574c1ef5e06073e71c29e259741c26373113f2ae51c692b4aaef429f9
+  data.tar.gz: 94c1f670b52a39b78c961a3050c2587c540a1cb1593c30e87d6bd05d90a4d736
 SHA512:
-  metadata.gz: 54ca6d542370d360f1f48959e4edf5a4308985d8e952317e2780b980c068674cb56c257c9d8241d0fc929bb152ca9960a8c7397f90c08725acf9bd268f794842
-  data.tar.gz: 303d6c379501dcf8966dd3941f2e667f35efeec67b24eb68bf2965abee06e5afa4b631c7b23e7493e4a3e088f650bd5a85271ae2bedb18b7a0120ca4c4bc605c
+  metadata.gz: 1b7972639977a290fd9a42b737edd1f3eec28a240a6e0e773619190bf646ec0707520d317ddf6e6152f507753b16fa66db0d2903c18fd23e58ebce4422e02555
+  data.tar.gz: bc3d03de05c21a14a6d6d9b6de76ff04efcd660999c0dd2c166cc306707d0f93be01053e34ba8a531c9e0a9154e887bb1c6796b141564e290e25d537eeab88b4

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 ## [Unreleased]
 
+## [0.1.3] - 2024-04-10
+
+- Support exceptions thrown in Crystal being caught in Ruby
+- Support complex Ruby type passing (while preserving type checking), using `JSON` as serialization format.
+
 ## [0.1.0] - 2024-04-07
 
 - Initial release

data/README.md

@@ -120,8 +120,10 @@ end
 
 ## Types
 
-Currently only primitive types are supported. Structures are a WIP.
-To see the list of currently supported type mappings of FFI types to crystal types, you can check: `CrystalRuby::Typemaps::CRYSTAL_TYPE_MAP`
+Currently primitive types are supported.
+Composite types are supported using JSON serialization.
+C-Structures are a WIP.
+To see the list of currently supported primitive type mappings of FFI types to crystal types, you can check: `CrystalRuby::Typemaps::CRYSTAL_TYPE_MAP`
 E.g.
 
 ```ruby
@@ -151,7 +153,54 @@ CrystalRuby::Typemaps::CRYSTAL_TYPE_MAP
  :string=>"String"}
 ```
 
-### Installing shards and writing non-embedded Crystal code
+## Composite Types (using JSON serialization)
+
+The library allows you to pass complex nested structures using JSON as a serialization format.
+The type signatures for composite types can use ordinary Crystal Type syntax.
+Type conversion is applied automatically.
+
+E.g.
+
+```ruby
+crystalize [a: json{ Int64 | Float64 | Nil }, b: json{ String | Array(Bool)  } ] => :void
+def complex_argument_types
+  puts "Got #{a} and #{b}"
+end
+
+crystalize [] => json{ Int32 | String | Hash(String, Array(NamedTuple(hello: Int32)) | Time)}
+def complex_return_type
+  return {
+    "hello" => [
+      {
+        hello: 1,
+      },
+    ],
+    "world" => Time.utc
+  }
+end
+```
+
+Type signatures validations are applied to both arguments and return types.
+
+```ruby
+[1] pry(main)> Foo.complex_argument_types(nil, "test")
+Got  and test
+=> nil
+
+[2] pry(main)> Foo.complex_argument_types(88, [true, false, true])
+Got 88 and [true, false, true]
+=> nil
+
+[3] pry(main)> Foo.complex_argument_types(88, [true, false, 88])
+ArgumentError: Expected Bool but was Int at line 1, column 15
+from crystalruby.rb:303:in `block in compile!'
+```
+
+## Exceptions
+
+Exceptions thrown in Crystal code can be caught in Ruby.
+
+## Installing shards and writing non-embedded Crystal code
 
 You can use any Crystal shards and write ordinary, stand-alone Crystal code.
 

data/exe/crystalruby

@@ -13,6 +13,7 @@ def init
     crystal_lib_dir: "./crystalruby/lib"
     crystal_main_file: "main.cr"
     crystal_lib_name: "crlib"
+    crystal_codegen_dir: "generated"
   YAML
 
   # Create the file at the root of the current directory

data/lib/crystalruby/config.rb

@@ -9,16 +9,20 @@ module CrystalRuby
   # Define a nested Config class
   class Config
     include Singleton
-    attr_accessor :debug, :crystal_src_dir, :crystal_lib_dir, :crystal_main_file, :crystal_lib_name
+    attr_accessor :debug, :crystal_src_dir, :crystal_lib_dir, :crystal_main_file, :crystal_lib_name, :crystal_codegen_dir
 
     def initialize
-      # Set default configuration options
       @debug = true
-      return unless File.exist?("crystalruby.yaml")
-
-      @crystal_src_dir, @crystal_lib_dir, @crystal_main_file, @crystal_lib_name =
-        YAML.safe_load(IO.read("crystalruby.yaml")).values_at("crystal_src_dir", "crystal_lib_dir", "crystal_main_file",
-                                                              "crystal_lib_name")
+      config = if File.exist?("crystalruby.yaml")
+        YAML.safe_load(IO.read("crystalruby.yaml")) rescue {}
+      else
+        {}
+      end
+      @crystal_src_dir     = config.fetch("crystal_src_dir", "./crystalruby/src")
+      @crystal_lib_dir     = config.fetch("crystal_lib_dir", "./crystalruby/lib")
+      @crystal_main_file   = config.fetch("crystal_main_file", "main.cr")
+      @crystal_lib_name    = config.fetch("crystal_lib_name", "crlib")
+      @crystal_codegen_dir = config.fetch("crystal_codegen_dir", "generated")
     end
   end
 

data/lib/crystalruby/template.rb

@@ -0,0 +1,13 @@
+require 'pry-byebug'
+module CrystalRuby
+  module Template
+    Dir[File.join(File.dirname(__FILE__), "templates", "*.cr")].each do |file|
+      template_name = File.basename(file, File.extname(file)).capitalize
+      const_set(template_name, File.read(file))
+    end
+
+    def self.render(template, context)
+      template % context
+    end
+  end
+end

data/lib/crystalruby/templates/function.cr

@@ -0,0 +1,20 @@
+module %{module_name}
+  def self.%{fn_name}(%{fn_args}) : %{fn_ret_type}
+    %{fn_body}
+  end
+end
+
+fun %{lib_fn_name}(%{lib_fn_args}): %{lib_fn_ret_type}
+  begin
+    %{convert_lib_args}
+    begin
+      return_value = %{module_name}.%{fn_name}(%{arg_names})
+      return %{convert_return_type}
+    rescue ex
+      CrystalRuby.report_error("RuntimeError", ex.message.to_s)
+    end
+  rescue ex
+    CrystalRuby.report_error("ArgumentError", ex.message.to_s)
+  end
+  return %{error_value}
+end

data/lib/crystalruby/templates/index.cr

@@ -0,0 +1,38 @@
+FAKE_ARG = "crystal"
+alias Callback = (Pointer(UInt8), Pointer(UInt8) -> Void)
+
+module CrystalRuby
+  @@initialized = false
+  def self.init
+    if @@initialized
+      return
+    end
+    @@initialized = true
+    GC.init
+    ptr = FAKE_ARG.to_unsafe
+    LibCrystalMain.__crystal_main(1, pointerof(ptr))
+  end
+
+  def self.attach_rb_error_handler(cb : Callback)
+    @@rb_error_handler = cb
+  end
+
+  def self.report_error(error_type : String, str : String)
+    handler = @@rb_error_handler
+    if handler
+      handler.call(error_type.to_unsafe, str.to_unsafe)
+    end
+  end
+end
+
+
+fun init(): Void
+  CrystalRuby.init
+end
+
+fun attach_rb_error_handler(cb : Callback) : Void
+  CrystalRuby.attach_rb_error_handler(cb)
+end
+
+%{type_modules}
+%{requires}

data/lib/crystalruby/typebuilder.rb

@@ -0,0 +1,179 @@
+require_relative "types"
+
+module CrystalRuby
+  module TypeBuilder
+    module_function
+
+    def with_injected_type_dsl(context, &block)
+      with_constants(context) do
+        with_methods(context, &block)
+      end
+    end
+
+    def with_methods(context)
+      restores = []
+      %i[Array Hash NamedTuple Tuple].each do |method_name|
+        old_method = begin
+          context.instance_method(method_name)
+        rescue StandardError
+          nil
+        end
+        restores << [context, method_name, old_method]
+        context.define_singleton_method(method_name) do |*args|
+          Types.send(method_name, *args)
+        end
+      end
+      yield
+    ensure
+      restores.each do |context, method_name, old_method|
+        context.define_singleton_method(method_name, old_method) if old_method
+      end
+    end
+
+    def with_constants(context)
+      previous_const_pairs = CrystalRuby::Types.constants.map do |type|
+        [type, begin
+          context.const_get(type)
+        rescue StandardError
+          nil
+        end]
+      end
+      CrystalRuby::Types.constants.each do |type|
+        begin
+          context.send(:remove_const, type)
+        rescue StandardError
+          nil
+        end
+        context.const_set(type, CrystalRuby::Types.const_get(type))
+      end
+      yield
+    ensure
+      previous_const_pairs.each do |const_name, const_value|
+        begin
+          context.send(:remove_const, const_name)
+        rescue StandardError
+          nil
+        end
+        context.const_set(const_name, const_value)
+      end
+    end
+
+    def build
+      result = yield
+      Types::Type.validate!(result)
+      Types::Typedef(result)
+    end
+  end
+end
+
+# class UnionType
+#   attr_reader :inner
+
+#   def initialize(*inner)
+#     @inner = inner
+#   end
+
+#   def |(other)
+#     UnionType.new(*inner, *other.inner)
+#   end
+
+#   def inspect
+#     elements = inner.map(&:inspect).join(" | ")
+#   end
+# end
+
+# class Type
+#   attr_reader :inner, :contains
+
+#   def initialize(name)
+#     @name = name
+#     @contains = contains
+#     @inner = [self]
+#   end
+
+#   def |(other)
+#     UnionType.new(*inner, *other.inner)
+#   end
+
+#   def inspect
+#     if @contains
+#       "#{@name}(#{@contains.inspect})"
+#     else
+#       @name
+#     end
+#   end
+# end
+
+# module_function
+
+# %w[
+#   Bool Uint8 Uint16 Uint32 Uint64 Int8 Int16 Int32 Int64 Float32 Float64 String Time Symbol
+#   Null
+# ].map do |t|
+#   cls = Class.new(Type)
+#   const_set(t, cls)
+#   define_method(t.downcase) do
+#     cls.new(t)
+#   end
+# end
+
+# def build(&blk)
+#   instance_exec(&blk)
+# end
+
+# def hash(key_type, value_type)
+#   Hash.new(key_type, value_type)
+# end
+
+# def array(type)
+#   Array.new(type)
+# end
+
+# def tuple(*types)
+#   Tuple.new(*types)
+# end
+
+# def named_tuple(type_hash)
+#   NamedTuple.new(type_hash)
+# end
+
+# def NamedTuple(type_hash)
+#   NamedTuple.new(type_hash)
+# end
+
+# class Hash < Type
+#   HASH_KEY_TYPES = %w[String Symbol].freeze
+#   def initialize(key_type, value_type)
+#     super("Hash")
+#     @key_type = key_type
+#     @value_type = value_type
+#     raise "Invalid key type" unless [Uint8, Uint16, Uint32, Uint64, Int8, Int16, Int32, Int64,
+#                                      String].include?(key_type)
+#     raise "Invalid value type" unless value_type.is_a?(Type)
+#   end
+# end
+
+# class Array < Type
+#   def initialize(value_type)
+#     super("Array")
+#     @value_type = value_type
+#     raise "Invalid value type" unless value_type.is_a?(Type)
+#   end
+# end
+
+# class NamedTuple < Type
+#   def initialize(types_hash)
+#     raise "keys must be symbols" unless types_hash.keys.all? { |k| k.is_a?(Symbol) }
+#     raise "Invalid value type" unless types_hash.values.all? { |v| v.is_a?(Type) }
+
+#     super("NamedTuple")
+#     @types_hash = types_hash
+#   end
+# end
+
+# class Tuple < Type
+#   def initialize(*value_types)
+#     super("Tuple")
+#     raise "Invalid value type" unless value_types.all? { |v| v.is_a?(Type) }
+#   end
+# end

data/lib/crystalruby/typemaps.rb

@@ -26,6 +26,32 @@ module CrystalRuby
       :string => "String"     # String type
     }
 
+    ERROR_VALUE = {
+      :char => "0",        # In Crystal, :char is typically represented as Int8
+      :uchar => "0",      # Unsigned char
+      :int8 => "0",        # Same as :char
+      :uint8 => "0",      # Same as :uchar
+      :short => "0",      # Short integer
+      :ushort => "0",    # Unsigned short integer
+      :int16 => "0",      # Same as :short
+      :uint16 => "0",    # Same as :ushort
+      :int => "0",        # Integer, Crystal defaults to 32 bits
+      :uint => "0",      # Unsigned integer
+      :int32 => "0",      # 32-bit integer
+      :uint32 => "0",    # 32-bit unsigned integer
+      :long => "0", # Long integer, size depends on the platform (32 or 64 bits)
+      :ulong => "0", # Unsigned long integer, size depends on the platform
+      :int64 => "0",      # 64-bit integer
+      :uint64 => "0",    # 64-bit unsigned integer
+      :long_long => "0",  # Same as :int64
+      :ulong_long => "0", # Same as :uint64
+      :float => "0.0",    # Floating point number (single precision)
+      :double => "0.0",   # Double precision floating point number
+      :bool => "false",        # Boolean type
+      :void => "Void",        # Void type
+      :string => '""'     # String type
+    }
+
     C_TYPE_MAP = CRYSTAL_TYPE_MAP.merge({
       :string => "UInt8*"
     })

data/lib/crystalruby/types/array.rb

@@ -0,0 +1,14 @@
+module CrystalRuby::Types
+  Array = Type.new(
+    :Array,
+    error: "Array type must have a type parameter. E.g. Array(Float64)"
+  )
+
+  def self.Array(type)
+    Type.validate!(type)
+    Type.new("Array", inner_types: [type], accept_if: [::Array]
+    ) do |a|
+      a.map!{|v| type.interpret!(v) }
+    end
+  end
+end

data/lib/crystalruby/types/bool.rb

@@ -0,0 +1,3 @@
+module CrystalRuby::Types
+  Bool = Type.new(:Bool, accept_if: [::TrueClass, ::FalseClass])
+end

data/lib/crystalruby/types/hash.rb

@@ -0,0 +1,15 @@
+module CrystalRuby::Types
+  Hash = Type.new(
+    :Hash,
+    error: "Hash type must have 2 type parameters. E.g. Hash(Float64, String)",
+  )
+
+  def self.Hash(key_type, value_type)
+    Type.validate!(key_type)
+    Type.validate!(value_type)
+    Type.new("Hash", inner_types: [key_type, value_type], accept_if: [::Hash]) do |h|
+      h.transform_keys!{|k| key_type.interpret!(k) }
+      h.transform_values!{|v| value_type.interpret!(v) }
+    end
+  end
+end

data/lib/crystalruby/types/named_tuple.rb

@@ -0,0 +1,25 @@
+module CrystalRuby::Types
+  NamedTuple = Type.new(
+    :NamedTuple,
+    error: "NamedTuple type must contain one or more symbol -> type pairs. E.g. NamedTuple(hello: Int32, world: String)"
+  )
+
+  def self.NamedTuple(types_hash)
+    types_hash.keys.each do |key|
+      raise "NamedTuple keys must be symbols" unless key.kind_of?(::Symbol) || key.respond_to?(:to_sym)
+    end
+    types_hash.values.each do |value_type|
+      Type.validate!(value_type)
+    end
+    keys = types_hash.keys.map(&:to_sym)
+    values = types_hash.values
+    Type.new("NamedTuple", inner_types: values, inner_keys: keys, accept_if: [::Hash]) do |h|
+      h.transform_keys!{|k| k.to_sym }
+      raise "Invalid keys for named tuple" unless h.keys.length == keys.length
+      raise "Invalid keys for named tuple" unless h.keys.all?{|k| keys.include?(k)}
+      h.each do |key, value|
+        h[key] = values[keys.index(key)].interpret!(value)
+      end
+    end
+  end
+end

data/lib/crystalruby/types/nil.rb

@@ -0,0 +1,3 @@
+module CrystalRuby::Types
+  Nil = Type.new(:Nil, accept_if: [::NilClass])
+end

data/lib/crystalruby/types/numbers.rb

@@ -0,0 +1,5 @@
+module CrystalRuby::Types
+  %i[Uint8 Uint16 Uint32 Uint64 Int8 Int16 Int32 Int64 Float32 Float64].each do |type_name|
+    const_set type_name, Type.new(type_name, accept_if: [::Numeric])
+  end
+end

data/lib/crystalruby/types/string.rb

@@ -0,0 +1,3 @@
+module CrystalRuby::Types
+  String = Type.new(:String, accept_if: [::String])
+end

data/lib/crystalruby/types/symbol.rb

@@ -0,0 +1,3 @@
+module CrystalRuby::Types
+  Symbol = Type.new(:Symbol, accept_if: [::String, ::Symbol])
+end

data/lib/crystalruby/types/time.rb

@@ -0,0 +1,6 @@
+module CrystalRuby::Types
+  require 'date'
+  Time = Type.new(:Time, accept_if: [::Time, ::String]) do |v|
+    DateTime.parse(v)
+  end
+end

data/lib/crystalruby/types/tuple.rb

@@ -0,0 +1,15 @@
+module CrystalRuby::Types
+  Tuple = Type.new(
+    :Tuple,
+    error: "Tuple type must contain one or more types E.g. Tuple(Int32, String)"
+  )
+
+  def self.Tuple(*types)
+    types.each do |value_type|
+      Type.validate!(value_type)
+    end
+    Type.new("Tuple", inner_types: types, accept_if: [::Array]) do |a|
+      a.map!.with_index{|v, i| self.inner_types[i].interpret!(v) }
+    end
+  end
+end

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.2"
+  VERSION = "0.1.3"
 end

data/lib/crystalruby.rb

@@ -5,6 +5,9 @@ require "method_source"
 require_relative "crystalruby/config"
 require_relative "crystalruby/version"
 require_relative "crystalruby/typemaps"
+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
@@ -16,6 +19,24 @@ module CrystalRuby
     @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
       attach_crystalized_method(method_name)
@@ -40,11 +61,10 @@ 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 "#{method_name}", fname, function[:ffi_types], function[:return_ffi_type]
       attach_function "init!", "init", [], :void
       if block
         [singleton_class, self].each do |receiver|
@@ -62,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
@@ -71,42 +99,103 @@ 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_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_to_return_type(expr, outtype)
-    Typemaps::C_TYPE_CONVERSIONS[outtype] ? Typemaps::C_TYPE_CONVERSIONS[outtype][:to] % expr : expr
+  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!
@@ -120,10 +209,10 @@ module CrystalRuby
         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
     return if File.exist?("#{config.crystal_src_dir}/shard.yml")
 
@@ -145,42 +234,75 @@ module CrystalRuby
     !!@attached
   end
 
-  def self.compile!
-    return unless @block_store
+  def self.register_type!(type)
+    @types_cache ||= {}
+    @types_cache[type.name] = type.type_defn
+  end
 
-    index_content = <<~CRYSTAL
-      FAKE_ARG = "crystal"
-      fun init(): Void
-        GC.init
-        ptr = FAKE_ARG.to_unsafe
-        LibCrystalMain.__crystal_main(1, pointerof(ptr))
+  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
-    CRYSTAL
+      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
 
-    index_content += @block_store.map do |function|
+  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
-        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
-      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!
@@ -191,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")
+    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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: crystalruby
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Wouter Coppieters
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-04-08 00:00:00.000000000 Z
+date: 2024-04-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: digest
@@ -84,7 +84,27 @@ files:
 - exe/crystalruby
 - lib/crystalruby.rb
 - lib/crystalruby/config.rb
+- lib/crystalruby/template.rb
+- lib/crystalruby/templates/function.cr
+- lib/crystalruby/templates/index.cr
+- lib/crystalruby/typebuilder.rb
 - lib/crystalruby/typemaps.rb
+- lib/crystalruby/types.rb
+- lib/crystalruby/types/array.rb
+- lib/crystalruby/types/bool.rb
+- lib/crystalruby/types/hash.rb
+- lib/crystalruby/types/named_tuple.rb
+- lib/crystalruby/types/nil.rb
+- lib/crystalruby/types/numbers.rb
+- lib/crystalruby/types/string.rb
+- lib/crystalruby/types/symbol.rb
+- lib/crystalruby/types/time.rb
+- lib/crystalruby/types/tuple.rb
+- lib/crystalruby/types/type.rb
+- lib/crystalruby/types/type_serializer.rb
+- lib/crystalruby/types/type_serializer/json.rb
+- lib/crystalruby/types/typedef.rb
+- lib/crystalruby/types/union_type.rb
 - lib/crystalruby/version.rb
 - lib/module.rb
 - sig/crystalruby.rbs