crystalruby 0.1.6 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7c552102391f468b4974cb4ac36c4876001743fdec5fa8f2a69577255de4c52d
-  data.tar.gz: f7c104b10cf70eb03ab064117be946d4268c97063ba9302a99613e9c473ded97
+  metadata.gz: 95d9eecc4d47a8d9f83417779c6174eea95ebeea593e5127a89b6cfbc7884664
+  data.tar.gz: b4f241f826e4f2b6c704bda0fd01c201e79a9bc26027bd4702717fd371687650
 SHA512:
-  metadata.gz: 0c01cefa9a6f820cd59aed62e02846bd90cd53a742c203b8de0023908c53e77ef2a558adf26023008dcd921e9c9cbc0466a63598361c18ec7cc6bee29a57ce2c
-  data.tar.gz: a9fe76d0b8a93dab4afd94d696d9955a81e75384fd1d4af8a0af5249c30fd51920d46de4728caab630862c889e799f1207f9915176fe861c6624e7a13d994e5a
+  metadata.gz: d98f1e4a671679cfb8d9da45298954e01def202802bd5a64db9d0d9cba08de0776971d031648642f402fe0310d741dc6b2d163253884ad25082298226c1be1a0
+  data.tar.gz: 141658885f763ca3088a7058131e7227434920d6213e755e21f85d6bb4d68a062a2a3163127f4e9f0db03a8c9a27a0549837714b38789647028075cc3b77660c

data/README.md

@@ -25,7 +25,7 @@ require 'crystalruby'
 module MyTestModule
   # The below method will be replaced by a compiled Crystal version
   # linked using FFI.
-  crystalize [:int, :int] => :int
+  crystalize [a: :int, b: :int] => :int
   def add(a, b)
     a + b
   end
@@ -143,7 +143,7 @@ require 'bundler/inline'
 
 gemfile do
   source 'https://rubygems.org'
-  gem 'crystalruby', path: '../crystalruby'
+  gem 'crystalruby'
 end
 
 require 'crystalruby'
@@ -151,7 +151,7 @@ require 'crystalruby'
 module Adder
   crystalize [a: :int, b: :int] => :int
   def add(a, b)
-    a + b * 3
+    a + b
   end
 end
 
@@ -349,7 +349,6 @@ It should support escape hatches to allow it to coexist with code that performs
 
 The library is currently in its infancy. Planned additions are:
 
-- Replace existing checksum process, with one that combines results of inline and external crystal to more accurately detect when recompilation is necessary.
 - Simple mixin/concern that utilises `FFI::Struct` for bi-directional passing of Ruby objects and Crystal objects (by value).
 - Install command to generate a sample build script, and supports build command (which simply verifies then invokes this script)
 - Call Ruby from Crystal using FFI callbacks (implement `.expose_to_crystal`)

data/lib/crystalruby/templates/function.cr

@@ -1,9 +1,18 @@
+# This is the template used for all CrystalRuby functions
+# Calls to this method *from ruby* are first transformed through the lib function.
+# Crystal code can simply call this method directly, enabling generated crystal code
+# to call other generated crystal code without overhead.
+
 module %{module_name}
   def self.%{fn_name}(%{fn_args}) : %{fn_ret_type}
     %{fn_body}
   end
 end
 
+# This function is the entry point for the CrystalRuby code, exposed through FFI.
+# We apply some basic error handling here, and convert the arguments and return values
+# to ensure that we are using Crystal native types.
+
 fun %{lib_fn_name}(%{lib_fn_args}): %{lib_fn_ret_type}
   begin
     %{convert_lib_args}

data/lib/crystalruby/templates/index.cr

@@ -1,38 +1,46 @@
 FAKE_ARG = "crystal"
-alias Callback = (Pointer(UInt8), Pointer(UInt8) -> Void)
+
+alias ErrorCallback = (Pointer(UInt8), Pointer(UInt8) -> Void)
 
 module CrystalRuby
+  # Initializing Crystal Ruby invokes init on the Crystal garbage collector.
+  # We need to be sure to only do this once.
   @@initialized = false
-  def self.init
-    if @@initialized
-      return
-    end
-    @@initialized = true
+
+  # We won't natively handle Crystal Exceptions in Ruby
+  # Instead, we'll catch them in Crystal, and explicitly expose them to Ruby via
+  # the error_callback.
+  @@error_callback
+
+  # This is the entry point for instantiating CrystalRuby
+  # We:
+  # 1. Initialize the Crystal garbage collector
+  # 2. Set the error callback
+  # 3. Call the Crystal main function
+  def self.init(error_callback : ErrorCallback)
+    return if @@initialized
     GC.init
+    @@initialized    = true
+    @@error_callback = error_callback
     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
-
+  # Explicit error handling (triggers exception within Ruby on the same thread)
   def self.report_error(error_type : String, str : String)
-    handler = @@rb_error_handler
-    if handler
+    if handler = @@error_callback
       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)
+fun init(cb : ErrorCallback): Void
+  CrystalRuby.init(cb)
 end
 
+# This is where we define all our Crystal modules and types
+# derived from their Ruby counterparts.
 %{type_modules}
+
+# Require all generated crystal files
 %{requires}

data/lib/crystalruby/typemaps.rb

@@ -1,63 +1,63 @@
 module CrystalRuby
   module Typemaps
     CRYSTAL_TYPE_MAP = {
-      :char => "Int8",        # In Crystal, :char is typically represented as Int8
-      :uchar => "UInt8",      # Unsigned char
-      :int8 => "Int8",        # Same as :char
-      :uint8 => "UInt8",      # Same as :uchar
-      :short => "Int16",      # Short integer
-      :ushort => "UInt16",    # Unsigned short integer
-      :int16 => "Int16",      # Same as :short
-      :uint16 => "UInt16",    # Same as :ushort
-      :int => "Int32",        # Integer, Crystal defaults to 32 bits
-      :uint => "UInt32",      # Unsigned integer
-      :int32 => "Int32",      # 32-bit integer
-      :uint32 => "UInt32",    # 32-bit unsigned integer
-      :long => "Int32 | Int64", # Long integer, size depends on the platform (32 or 64 bits)
-      :ulong => "UInt32 | UInt64", # Unsigned long integer, size depends on the platform
-      :int64 => "Int64",      # 64-bit integer
-      :uint64 => "UInt64",    # 64-bit unsigned integer
-      :long_long => "Int64",  # Same as :int64
-      :ulong_long => "UInt64", # Same as :uint64
-      :float => "Float32",    # Floating point number (single precision)
-      :double => "Float64",   # Double precision floating point number
-      :bool => "Bool",        # Boolean type
-      :void => "Void",        # Void type
-      :string => "String"     # String type
+      char: "Int8",        # In Crystal, :char is typically represented as Int8
+      uchar: "UInt8",      # Unsigned char
+      int8: "Int8",        # Same as :char
+      uint8: "UInt8",      # Same as :uchar
+      short: "Int16",      # Short integer
+      ushort: "UInt16",    # Unsigned short integer
+      int16: "Int16",      # Same as :short
+      uint16: "UInt16",    # Same as :ushort
+      int: "Int32",        # Integer, Crystal defaults to 32 bits
+      uint: "UInt32",      # Unsigned integer
+      int32: "Int32",      # 32-bit integer
+      uint32: "UInt32",    # 32-bit unsigned integer
+      long: "Int32 | Int64", # Long integer, size depends on the platform (32 or 64 bits)
+      ulong: "UInt32 | UInt64", # Unsigned long integer, size depends on the platform
+      int64: "Int64",      # 64-bit integer
+      uint64: "UInt64",    # 64-bit unsigned integer
+      long_long: "Int64",  # Same as :int64
+      ulong_long: "UInt64", # Same as :uint64
+      float: "Float32",    # Floating point number (single precision)
+      double: "Float64",   # Double precision floating point number
+      bool: "Bool",        # Boolean type
+      void: "Void",        # Void type
+      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
+      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: '"".to_unsafe' # String type
     }
 
     C_TYPE_MAP = CRYSTAL_TYPE_MAP.merge({
-      :string => "UInt8*"
-    })
+                                          string: "UInt8*"
+                                        })
 
     C_TYPE_CONVERSIONS = {
-      :string => {
+      string: {
         from: "String.new(%s)",
         to: "%s.to_unsafe"
       }

data/lib/crystalruby/version.rb

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

data/lib/crystalruby.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "ffi"
 require "digest"
 require "fileutils"
@@ -10,6 +12,7 @@ require_relative "crystalruby/typebuilder"
 require_relative "crystalruby/template"
 
 module CrystalRuby
+  CR_SRC_FILES_PATTERN = "./**/*.cr"
   # Define a method to set the @crystalize proc if it doesn't already exist
   def crystalize(type = :src, **options, &block)
     (args,), returns = options.first
@@ -29,14 +32,6 @@ module CrystalRuby
     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)
@@ -64,8 +59,7 @@ module CrystalRuby
     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, function[:ffi_types], function[:return_ffi_type]
-      attach_function "init!", "init", [], :void
+      attach_function method_name, fname, function[:ffi_types], function[:return_ffi_type]
       if block
         [singleton_class, self].each do |receiver|
           receiver.prepend(Module.new do
@@ -73,8 +67,6 @@ module CrystalRuby
           end)
         end
       end
-
-      init!
     end
 
     [singleton_class, self].each do |receiver|
@@ -219,6 +211,9 @@ module CrystalRuby
         "require \"./#{config.crystal_codegen_dir}/index\"\n"
       )
     end
+
+    attach_crystal_ruby_lib! if compiled?
+
     return if File.exist?("#{config.crystal_src_dir}/shard.yml")
 
     IO.write("#{config.crystal_src_dir}/shard.yml", <<~CRYSTAL)
@@ -227,11 +222,25 @@ module CrystalRuby
     CRYSTAL
   end
 
+  def attach_crystal_ruby_lib!
+    extend FFI::Library
+    ffi_lib "#{config.crystal_lib_dir}/#{config.crystal_lib_name}"
+    attach_function "init!", :init, [:pointer], :void
+    const_set(:ErrorCallback, FFI::Function.new(:void, %i[string string]) do |error_type, message|
+      error_type = error_type.to_sym
+      is_exception_type = Object.const_defined?(error_type) && Object.const_get(error_type).ancestors.include?(Exception)
+      error_type = is_exception_type ? Object.const_get(error_type) : RuntimeError
+      raise error_type.new(message)
+    end)
+    init!(ErrorCallback)
+  end
+
   def self.instantiated?
     @instantiated
   end
 
   def self.compiled?
+    @compiled = get_current_crystal_lib_digest == get_cr_src_files_digest unless defined?(@compiled)
     @compiled
   end
 
@@ -293,21 +302,14 @@ module CrystalRuby
             end
 
       unless result = system(cmd)
-        File.delete("#{config.crystal_codegen_dir}/index.cr") if File.exist?("#{config.crystal_codegen_dir}/index.cr")
+        File.delete(digest_file_name) if File.exist?(digest_file_name)
         raise "Error compiling crystal code"
       end
-      @compiled = true
     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, %i[string string]) do |error_type, message|
-      error_type = error_type.to_sym
-      is_exception_type = Object.const_defined?(error_type) && Object.const_get(error_type).ancestors.include?(Exception)
-      error_type = is_exception_type ? Object.const_get(error_type) : RuntimeError
-      raise error_type.new(message)
-    end)
-    attach_rb_error_handler(ErrorCallback)
+
+    IO.write(digest_file_name, get_cr_src_files_digest)
+    @compiled = true
+    attach_crystal_ruby_lib!
   end
 
   def self.attach!
@@ -317,10 +319,23 @@ module CrystalRuby
     @attached = true
   end
 
+  def self.get_cr_src_files_digest
+    file_digests = Dir.glob(CR_SRC_FILES_PATTERN).sort.map do |file_path|
+      content = File.read(file_path)
+      Digest::MD5.hexdigest(content)
+    end.join
+    Digest::MD5.hexdigest(file_digests)
+  end
+
+  def self.digest_file_name
+    @digest_file_name ||= "#{config.crystal_lib_dir}/#{config.crystal_lib_name}.digest"
+  end
+
+  def self.get_current_crystal_lib_digest
+    File.read(digest_file_name) if File.exist?(digest_file_name)
+  end
+
   def self.write_function(owner, name:, body:, &compile_callback)
-    unless defined?(@compiled)
-      @compiled = File.exist?("#{config.crystal_src_dir}/#{config.crystal_codegen_dir}/index.cr")
-    end
     @block_store ||= []
     @block_store << { owner: owner, name: name, body: body, compile_callback: compile_callback }
     FileUtils.mkdir_p("#{config.crystal_src_dir}/#{config.crystal_codegen_dir}")

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: crystalruby
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.8
 platform: ruby
 authors:
 - Wouter Coppieters
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-04-10 00:00:00.000000000 Z
+date: 2024-04-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: digest