v 0.3.3

Added dynamic scheduled GC based on memory hints
Pinned prism version
Auto-convert to ffi-primitive types where possible for increased performance

Author: wouterken

Gemfile.lock

@@ -1,11 +1,11 @@
 PATH
   remote: .
   specs:
-    crystalruby (0.3.2)
+    crystalruby (0.3.3)
       digest
       ffi
-      fileutils
-      prism
+      fileutils (~> 1.7)
+      prism (~> 1.3.0)
 
 GEM
   remote: https://rubygems.org/
@@ -18,6 +18,7 @@ GEM
       reline (>= 0.3.8)
     digest (3.1.1)
     ffi (1.17.0)
+    ffi (1.17.0-arm64-darwin)
     fileutils (1.7.2)
     io-console (0.7.2)
     irb (1.12.0)
@@ -35,7 +36,7 @@ GEM
     parser (3.3.0.5)
       ast (~> 2.4.1)
       racc
-    prism (1.2.0)
+    prism (1.3.0)
     psych (5.1.2)
       stringio
     racc (1.7.3)

crystalruby.gemspec

@@ -34,8 +34,8 @@ Gem::Specification.new do |spec|
   # spec.add_dependency "example-gem", "~> 1.0"
   spec.add_dependency "digest"
   spec.add_dependency "ffi"
-  spec.add_dependency "fileutils"
-  spec.add_dependency "prism"
+  spec.add_dependency "fileutils", "~> 1.7"
+  spec.add_dependency "prism", "~> 1.3.0"
   # For more information and examples about making a new gem, check out our
   # guide at: https://bundler.io/guides/creating_gem.html
 end

lib/crystalruby/adapter.rb

@@ -36,7 +36,7 @@ module Adapter
     # @option options [Boolean] :async (false) Mark the method as async (allows multiplexing).
     # @option options [String] :lib ("crystalruby") The name of the library to compile the Crystal code into.
     # @option options [Proc] :block An optional wrapper Ruby block that wraps around any invocations of the crystal code
-    def crystallize( returns=:void, raw: false, async: false, lib: "crystalruby", &block)
+    def crystallize(returns = :void, raw: false, async: false, lib: "crystalruby", &block)
       (self == TOPLEVEL_BINDING.receiver ? Object : self).instance_eval do
         @crystallize_next = {
           raw: raw,
@@ -49,7 +49,7 @@ def crystallize( returns=:void, raw: false, async: false, lib: "crystalruby", &b
     end
 
     # Alias for `crystallize`
-    alias :crystalize :crystallize
+    alias crystalize crystallize
 
     # Exposes a Ruby method to one or more Crystal libraries.
     # Type annotations follow the same rules as the `crystallize` method, but are
@@ -58,7 +58,7 @@ def crystallize( returns=:void, raw: false, async: false, lib: "crystalruby", &b
     # @param [Hash] options The options hash.
     # @option options [Boolean] :raw (false) Pass raw Crystal code to the compiler as a string.
     # @option options [String] :libs (["crystalruby"]) The name of the Crystal librarie(s) to expose the Ruby code to.
-    def expose_to_crystal( returns=:void, libs: ["crystalruby"])
+    def expose_to_crystal(returns = :void, libs: ["crystalruby"])
       (self == TOPLEVEL_BINDING.receiver ? Object : self).instance_eval do
         @expose_next_to_crystal = {
           returns: returns,
@@ -70,22 +70,26 @@ def expose_to_crystal( returns=:void, libs: ["crystalruby"])
     # Define a shard dependency
     # This dependency will be automatically injected into the shard.yml file for
     # the given library and installed upon compile if it is not already installed.
-    def shard(shard_name, lib: 'crystalruby', **opts)
+    def shard(shard_name, lib: "crystalruby", **opts)
       CrystalRuby::Library[lib].require_shard(shard_name, **opts)
     end
 
     # Use this method to define inline Crystal code that does not need to be bound to a Ruby method.
     # This is useful for defining classes, modules, performing set-up tasks etc.
     # See: docs for .crystallize to understand the `raw` and `lib` parameters.
     def crystal(raw: false, lib: "crystalruby", &block)
-      inline_crystal_body = respond_to?(:name) ? Template::InlineChunk.render(
-        {
-          module_name: name,
-          body: SourceReader.extract_source_from_proc(block, raw: raw),
-          mod_or_class: self.kind_of?(Class) && self < Types::Type ? "class" : "module",
-          superclass: self.kind_of?(Class) && self < Types::Type ? "< #{self.crystal_supertype}" : ""
-        }) :
-        SourceReader.extract_source_from_proc(block, raw: raw)
+      inline_crystal_body = if respond_to?(:name)
+                              Template::InlineChunk.render(
+                                {
+                                  module_name: name,
+                                  body: SourceReader.extract_source_from_proc(block, raw: raw),
+                                  mod_or_class: is_a?(Class) && self < Types::Type ? "class" : "module",
+                                  superclass: is_a?(Class) && self < Types::Type ? "< #{crystal_supertype}" : ""
+                                }
+                              )
+                            else
+                              SourceReader.extract_source_from_proc(block, raw: raw)
+                            end
 
       CrystalRuby::Library[lib].crystallize_chunk(
         self,
@@ -94,7 +98,6 @@ def crystal(raw: false, lib: "crystalruby", &block)
       )
     end
 
-
     # This method provides a useful DSL for defining Crystal types in pure Ruby
     # MyType = CRType{ Int32 | Hash(String, Array(Bool) | Float65 | Nil) }
     # @param [Proc] block The block within which we build the type definition.
@@ -152,14 +155,16 @@ def #{method.name} (#{(args.keys - [:__yield_to]).join(", ")})
 
       owner = method.owner.singleton_class? ? method.owner.attached_object : method.owner
       owner.class_eval(src)
-      owner.instance_eval(src) unless method.kind_of?(UnboundMethod) && method.owner.ancestors.include?(CrystalRuby::Types::Type)
-      method = owner.send(method.kind_of?(UnboundMethod) ? :instance_method : :method, method.name)
+      unless method.is_a?(UnboundMethod) && method.owner.ancestors.include?(CrystalRuby::Types::Type)
+        owner.instance_eval(src)
+      end
+      method = owner.send(method.is_a?(UnboundMethod) ? :instance_method : :method, method.name)
 
       libs.each do |lib|
         CrystalRuby::Library[lib].expose_method(
           method,
           args,
-          returns,
+          returns
         )
       end
     end

lib/crystalruby/function.rb

@@ -66,6 +66,7 @@ def define_crystallized_methods!(lib)
           raise ArgumentError, "no block given but function expects block" if !blk && func.takes_block?
 
           args << blk if blk
+
           func.map_args!(args)
           args.unshift(memory) if func.instance_method
 
@@ -86,27 +87,35 @@ def define_crystallized_methods!(lib)
     def register_callback!
       return unless ruby
 
-      @callback_func = FFI::Function.new(ffi_ret_type, ffi_types) do |*args|
+      ret_type = ffi_ret_type == :string ? :pointer : ffi_ret_type
+      @callback_func = FFI::Function.new(ret_type, ffi_types) do |*args|
         receiver = instance_method ? owner.new(args.shift) : owner
-        ret_val = if takes_block?
-                    block_arg = arg_type_map[:__yield_to][:crystalruby_type].new(args.pop)
-                    receiver.send(name, *unmap_args(args)) do |*args|
-                      args = args.map.with_index do |arg, i|
-                        arg = block_arg.inner_types[i].new(arg) unless arg.is_a?(block_arg.inner_types[i])
-                        arg.memory
-                      end
-                      return_val = block_arg.invoke(*args)
-                      unless return_val.is_a?(block_arg.inner_types[-1])
-                        return_val = block_arg.inner_types[-1].new(return_val)
-                      end
-                      block_arg.inner_types[-1].anonymous? ? return_val.value : return_val
-                    end
-                  else
-                    receiver.send(name, *unmap_args(args))
-                  end
+        ret_val = \
+          if takes_block?
+            block_arg = arg_type_map[:__yield_to][:crystalruby_type].new(args.pop)
+            receiver.send(name, *unmap_args(args)) do |*args|
+              args = args.map.with_index do |arg, i|
+                arg = block_arg.inner_types[i].new(arg) unless arg.is_a?(block_arg.inner_types[i])
+                arg.memory
+              end
+              return_val = block_arg.invoke(*args)
+              return_val = block_arg.inner_types[-1].new(return_val) unless return_val.is_a?(block_arg.inner_types[-1])
+              block_arg.inner_types[-1].anonymous? ? return_val.value : return_val
+            end
+          else
+            receiver.send(name, *unmap_args(args))
+          end
         unmap_retval(ret_val)
       end
-      Reactor.schedule_work!(lib, :"register_#{name.to_s.gsub("?", "q").gsub("=", "eq").gsub("!", "bang")}_callback", @callback_func, :void, blocking: true, async: false)
+
+      Reactor.schedule_work!(
+        lib,
+        :"register_#{name.to_s.gsub("?", "q").gsub("=", "eq").gsub("!", "bang")}_callback",
+        @callback_func,
+        :void,
+        blocking: true,
+        async: false
+      )
     end
 
     # Attaches the crystallized FFI functions to their related Ruby modules and classes.
@@ -245,7 +254,7 @@ def custom_types
 
     def register_custom_types!(lib)
       custom_types.each do |crystalruby_type|
-        next unless crystalruby_type.is_a?(Class) && crystalruby_type < Types::Type
+        next unless Types::Type.subclass?(crystalruby_type)
 
         [*crystalruby_type.nested_types].uniq.each do |type|
           lib.register_type!(type)
@@ -263,7 +272,7 @@ def map_args!(args)
 
         mapped = argmap[args[index]]
         case mapped
-        when CrystalRuby::Types::Type then
+        when CrystalRuby::Types::Type
           args[index] = mapped.memory
           (refs ||= []) << mapped
         else
@@ -291,10 +300,12 @@ def map_retval(retval)
     end
 
     def unmap_retval(retval)
+      return FFI::MemoryPointer.from_string(retval) if return_type_map[:ffi_ret_type] == :string
       return retval unless return_type_map[:arg_mapper]
 
       retval = return_type_map[:arg_mapper][retval]
-      retval = retval.memory if retval.kind_of?(CrystalRuby::Types::Type)
+
+      retval = retval.memory if retval.is_a?(CrystalRuby::Types::Type)
       retval
     end
 

lib/crystalruby/library.rb

@@ -214,9 +214,7 @@ def build!
         unless compiled?
           FileUtils.rm_f(lib_file)
 
-          if shard_dependencies.any? && shards.empty?
-            rewrite_shards_file!
-          end
+          rewrite_shards_file! if shard_dependencies.any? && shards.empty?
 
           CrystalRuby::Compilation.install_shards!(src_dir)
           CrystalRuby::Compilation.compile!(
@@ -239,14 +237,16 @@ def attach!
         singleton_class.class_eval do
           extend FFI::Library
           ffi_lib lib_file
-          %i[yield init].each do |method_name|
+          %i[yield init gc].each do |method_name|
             singleton_class.undef_method(method_name) if singleton_class.method_defined?(method_name)
             undef_method(method_name) if method_defined?(method_name)
           end
           attach_function :init, %i[string pointer pointer], :void
           attach_function :yield, %i[], :int
+          attach_function :gc, %i[], :void
           lib_methods.each_value.select(&:ruby).each do |method|
-            attach_function :"register_#{method.name.to_s.gsub("?", "q").gsub("=", "eq").gsub("!", "bang")}_callback", %i[pointer], :void
+            attach_function :"register_#{method.name.to_s.gsub("?", "q").gsub("=", "eq").gsub("!", "bang")}_callback",
+                            %i[pointer], :void
           end
         end