crystalruby 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8a2ddcb45d988973d1ac42910bd9fa0f9f40dbae52e7dc11f512d3a0bd660790
-  data.tar.gz: ef9718a77deb3e68bade0ffbee62bd6678414aa1b39dca92c08fccf547637b4a
+  metadata.gz: fde36eb6893b41f156d747996c94e803227552f4ef12097ead408bb823619d59
+  data.tar.gz: 95e9860ee479571f1f38f8f7507a7f5eb921256116894c01ce358a8c0f22dc70
 SHA512:
-  metadata.gz: 4af4c23074658cb78ab68f330a3cd5bd3439c77d6af481ebac0ac9d5b8ba69b6fe3bbd6e6c5ac771a26ab8beb5db8f224fe85e03e0649f90d4f9f62e60a82fa6
-  data.tar.gz: 7d42ad8ab523ff33612b9e48ef0f222c5f8365811c5de896c1a4b9c29cd4efaeedccd9fff8f2719c8a5ede7e0320a8666ba60154c6860fffad37f318264cfaad
+  metadata.gz: 9b6c00ce61edf03f729bcd4f6605aa0cecb6042d9c046700a351d1ccf39b861fd5c259f7955ea02459984ee497533483adf3affbbae697fe5937ddd6ab01c625
+  data.tar.gz: 383e9f782c49da8751535ea8ba8ac1fd5638f17fe4d5d6b163c7b9df9ea4171794effa51df0bde51ad892ddbb58c545d542455ea973cf60fe2cb530a898e34c4

data/Dockerfile

@@ -1,16 +1,37 @@
+# Stage 1: Use the Crystal official image to build Crystal
+FROM crystallang/crystal:1.14 AS crystal-builder
+
+# Stage 2: Use the Ruby image and copy Crystal from the previous stage
 FROM ruby:3.3
 
 MAINTAINER Wouter Coppieters <wc@pico.net.nz>
 
-RUN apt-get update && apt-get install -y curl gnupg2 software-properties-common lsb-release
-RUN curl -fsSL https://crystal-lang.org/install.sh | bash
+# Install necessary dependencies for Ruby and Crystal
+RUN apt-get update && apt-get install -y \
+  curl \
+  gnupg2 \
+  software-properties-common \
+  build-essential \
+  lsb-release
+
+# Copy Crystal binaries and libraries from the Crystal image
+COPY --from=crystal-builder /usr/share/crystal /usr/share/crystal
+COPY --from=crystal-builder /usr/lib/crystal /usr/lib/crystal
+COPY --from=crystal-builder /usr/bin/crystal /usr/bin/crystal
+COPY --from=crystal-builder /usr/bin/shards /usr/bin/shards
+
+# Set the working directory
 WORKDIR /usr/src/app
 
+# Copy the Ruby dependencies
 COPY Gemfile Gemfile.lock ./
 COPY crystalruby.gemspec ./
 COPY lib/crystalruby/version.rb ./lib/crystalruby/version.rb
 
+# Install Ruby dependencies
 RUN bundle install
+
+# Copy the rest of your application
 COPY . .
 
 # Define the command to run your application

data/README.md

@@ -26,7 +26,7 @@ require 'crystalruby'
 # The below method will be replaced by a compiled Crystal version
 # linked using FFI.
 
-crystalize
+crystallize
 def add(a: Int32, b: Int32, returns: Int32)
   a + b
 end
@@ -42,7 +42,7 @@ E.g.
 require 'crystalruby'
 require 'benchmark'
 
-crystalize :int32
+crystallize :int32
 def count_primes_upto_cr(n: Int32)
   (2..n).each.count do |i|
     is_prime = true
@@ -81,8 +81,8 @@ puts Benchmark.realtime { count_primes_upto_cr(1_000_000) }
 _Note_: The first, unprimed run of the Crystal code will be slower, as it needs to compile the code first. The subsequent runs will be much faster.
 
 You can call embedded crystal code, from within other embedded crystal code.
-The below crystalized method `redis_set_and_return` calls the `redis_get` method, which is also crystalized.
-Note the use of the shard command to define the Redis shard dependency of the crystalized code.
+The below crystallized method `redis_set_and_return` calls the `redis_get` method, which is also crystallized.
+Note the use of the shard command to define the Redis shard dependency of the crystallized code.
 E.g.
 
 ```ruby
@@ -92,13 +92,13 @@ module Cache
 
   shard :redis, github: 'jgaskins/redis'
 
-  crystalize :string
+  crystallize :string
   def redis_get(key: String)
     rds = Redis::Client.new
     value = rds.get(key).to_s
   end
 
-  crystalize :string
+  crystallize :string
   def redis_set_and_return(key: String, value: String)
     redis = Redis::Client.new
     redis.set(key, value)
@@ -115,7 +115,7 @@ $ abc
 
 ## Syntax
 
-To define a method that will be compiled as Crystal, you can use the `crystalize` method.
+To define a method that will be compiled as Crystal, you can use the `crystallize` method.
 You must also provide types, for the parameters and return type.
 
 ### Method Signatures
@@ -125,24 +125,25 @@ E.g.
 def foo(a: Int32, b: Array(Int), c: String)
 ```
 
-Return types are specified using either a lambda, returning the type, as the first argument to the crystalize method, or the special `returns` kwarg.
+Return types are specified using either a lambda, returning the type, as the first argument to the crystallize method, or the special `returns` kwarg.
 
 E.g.
 
 ```ruby
 # Returns an Int32
-crystalize ->{ Int32 }
+crystallize ->{ Int32 }
 def returns_int32
   3
 end
 
 # You can use the symbol shortcode for primitive types
-crystalize :int32
+crystallize :int32
 def returns_int32
   3
+end
 
 # Define the return type directly using the `returns` kwarg
-crystalize
+crystallize
 def returns_int32(returns: Int32)
   3
 end
@@ -155,7 +156,7 @@ It'll be compiled as Crystal automatically.
 E.g.
 
 ```ruby
-crystalize :int
+crystallize :int
 def add(a: :int, b: :int)
   puts "Adding #{a} and #{b}"
   a + b
@@ -167,7 +168,7 @@ Some Crystal syntax is not valid Ruby, for methods of this form, we need to
 define our functions using the `raw: true` option
 
 ```ruby
-crystalize raw: true
+crystallize raw: true
 def add(a: :int, b: :int)
   <<~CRYSTAL
     c = 0_u64
@@ -179,24 +180,24 @@ end
 ### Upgrading from version 0.2.x
 
 #### Change in type signatures
-In version 0.2.x, argument and return types were passed to the `crystalize` method using a different syntax:
+In version 0.2.x, argument and return types were passed to the `crystallize` method using a different syntax:
 
 ```ruby
 # V <= 0.2.x
-crystalize [arg1: :arg1_type , arg2: :arg2_type] => :return_type
+crystallize [arg1: :arg1_type , arg2: :arg2_type] => :return_type
 def foo(arg1, arg2)
 ```
 
 In crystalruby > 0.3.x, argument types are now passed as keyword arguments, and the return type is passed either as a keyword argument
-or as the first argument to crystalize (either using symbol shorthand, or a Lambda returning a Crystal type).
+or as the first argument to crystallize (either using symbol shorthand, or a Lambda returning a Crystal type).
 
 ```ruby
 # V >= 0.3.x
-crystalize :return_type
+crystallize :return_type
 def foo(arg1: :arg1_type, arg2: :arg2_type)
 
 # OR use the `returns` kwarg
-crystalize
+crystallize
 def foo(arg1: :arg1_type, arg2: :arg2_type, returns: :return_type)
 ```
 
@@ -216,7 +217,7 @@ end
 
 require 'crystalruby'
 
-crystalize :int
+crystallize :int
 def add(a: :int, b: :int)
   a + b
 end
@@ -249,13 +250,13 @@ E.g.
 ```ruby
 require 'crystalruby'
 
-crystalize
+crystallize
 def complex_argument_types(a:  Int64 | Float64 | Nil, b: String | Array(Bool))
   puts "Got #{a} and #{b}"
 end
 
 
-crystalize
+crystallize
 def complex_return_type(returns: Int32 | String | Hash(String, Array(NamedTuple(hello: Int32)) | Time))
   return {
     "hello" => [
@@ -303,7 +304,7 @@ E.g.
 
 IntArrOrBoolArr = CRType{ Array(Bool) | Array(Int32) }
 
-crystalize
+crystallize
 def method_with_named_types(a: IntArrOrBoolArr, returns: IntArrOrBoolArr)
   return a
 end
@@ -324,7 +325,7 @@ require 'crystalruby'
 
 IntArray = CRType{ Array(Int32) }
 
-crystalize
+crystallize
 def array_doubler(a: IntArray)
   a.map! { |x| x * 2 }
 end
@@ -354,7 +355,7 @@ class Person < CRType{ NamedTuple(name: String, age: Int32) }
     "Hello from Ruby. My name is #{self.name.value}"
   end
 
-  crystalize :string
+  crystallize :string
   def greet_cr
     "Hello from Crystal, My name is #{self.name.value}"
   end
@@ -379,7 +380,7 @@ module Adder
     a + b
   end
 
-  crystalize :int32
+  crystallize :int32
   def add_crystal(a: Int32, b: Int32)
     return add_rb(a, b)
   end
@@ -398,7 +399,7 @@ require 'crystalruby'
 
 shard :kemal, github: 'kemalcr/kemal'
 
-crystalize async: true
+crystallize async: true
 def start_server
   Kemal.run(3000, [""])
 end
@@ -459,7 +460,7 @@ See notes on how to define a Proc type in Crystal [here](https://crystal-lang.or
 ```ruby
 require 'crystalruby'
 
-crystalize
+crystallize
 def yielder_cr(a: Int32, b: Int32, yield: Proc(Int32, Nil))
   yield a + b
 end
@@ -469,7 +470,7 @@ def yielder_rb(a: Int32, b: Int32, yield: Proc(Int32, Nil))
   yield a + b
 end
 
-crystalize
+crystallize
 def invoke_yielder_rb(a: Int32, b: Int32)
   yielder_rb(a, b) do |sum|
     puts sum
@@ -504,10 +505,10 @@ If your shard file gets out of sync with your Ruby file, you can run `crystalrub
 ## Wrapping Crystal code in Ruby
 
 Sometimes you may want to wrap a Crystal method in Ruby, so that you can use Ruby before the Crystal code to prepare arguments, or after the Crystal code, to apply transformations to the result. A real-life example of this might be an ActionController method, where you might want to use Ruby to parse the request, perform auth etc., and then use Crystal to perform some heavy computation, before returning the result from Ruby.
-To do this, you simply pass a block to the `crystalize` method, which will serve as the Ruby entry point to the function. From within this block, you can invoke `super` to call the Crystal method, and then apply any Ruby transformations to the result.
+To do this, you simply pass a block to the `crystallize` method, which will serve as the Ruby entry point to the function. From within this block, you can invoke `super` to call the Crystal method, and then apply any Ruby transformations to the result.
 
 ```ruby
-crystalize :int32 do |a, b|
+crystallize :int32 do |a, b|
   # In this example, we perform automated conversion to integers inside Ruby.
   # Then add 1 to the result of the Crystal method.
   result = super(a.to_i, b.to_i)
@@ -524,7 +525,7 @@ puts convert_to_i_and_add_and_succ("1", "2")
 
 `crystalruby` also allows you to write top-level Crystal code outside of method definitions. This can be useful for e.g. performing setup operations or initializations.
 
-Follow these steps for a toy example of how we can use crystalized ruby and inline chunks to expose the [crystal-redis](https://github.com/stefanwille/crystal-redis) library to Ruby.
+Follow these steps for a toy example of how we can use crystallized ruby and inline chunks to expose the [crystal-redis](https://github.com/stefanwille/crystal-redis) library to Ruby.
 
 1. Start our toy project
 
@@ -565,12 +566,12 @@ module CrystalRedis
     end
   end
 
-  crystalize
+  crystallize
   def set(key: String, value: String)
     client.set(key, value)
   end
 
-  crystalize :string
+  crystallize :string
   def get(key: String)
     client.get(key).to_s
   end
@@ -604,12 +605,12 @@ module CrystalRedis
     end
   end
 
-  crystalize
+  crystallize
   def set(key: String, value: String)
     client.set(key, value)
   end
 
-  crystalize :string
+  crystallize :string
   def get(key: String)
     client.get(key).to_s
   end
@@ -678,18 +679,18 @@ To safely utilise `crystalruby` in a multithreaded environment, `crystalruby` im
 
 By default `crystalruby` methods are blocking/synchronous, this means that for blocking operations, a single crystalruby call can block the entire reactor across _all_ threads.
 
-To allow you to benefit from Crystal's fiber based concurrency, you can use the `async: true` option on crystalized ruby methods. This allows several Ruby threads to invoke Crystal code simultaneously.
+To allow you to benefit from Crystal's fiber based concurrency, you can use the `async: true` option on crystallized ruby methods. This allows several Ruby threads to invoke Crystal code simultaneously.
 
 E.g.
 
 ```ruby
 module Sleeper
-  crystalize
+  crystallize
   def sleep_sync
     sleep 2.seconds
   end
 
-  crystalize async: true
+  crystallize async: true
   def sleep_async
     sleep 2.seconds
   end
@@ -723,12 +724,12 @@ recompile Crystal code only when it detects changes to the embedded function or
 ## Multi-library support
 
 Large Crystal projects are known to have long compile times. To mitigate this, `crystalruby` supports splitting your Crystal code into multiple libraries. This allows you to only recompile any libraries that have changed, rather than all crystal code within the project.
-To indicate which library a piece of embedded Crystal code belongs to, you can use the `lib` option in the `crystalize` and `crystal` methods.
+To indicate which library a piece of embedded Crystal code belongs to, you can use the `lib` option in the `crystallize` and `crystal` methods.
 If the `lib` option is not provided, the code will be compiled into the default library (simply named `crystalruby`).
 
 ```ruby
 module Foo
-  crystalize lib: "foo"
+  crystallize lib: "foo"
   def bar
     puts "Hello from Foo"
   end

data/crystalruby.gemspec

@@ -35,7 +35,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency "digest"
   spec.add_dependency "ffi"
   spec.add_dependency "fileutils"
-  spec.add_dependency "syntax_tree"
+  spec.add_dependency "prism"
   # For more information and examples about making a new gem, check out our
   # guide at: https://bundler.io/guides/creating_gem.html
 end

data/examples/adder/adder.rb

@@ -1,7 +1,7 @@
 require "crystalruby"
 
 module Adder
-  crystalize [a: :int, b: :int] => :int
+  crystallize [a: :int, b: :int] => :int
   def add(a, b)
     a + b
   end

data/lib/crystalruby/adapter.rb

@@ -1,14 +1,14 @@
 module CrystalRuby
   module Adapter
-    # Use this method to annotate a Ruby method that should be crystalized.
+    # Use this method to annotate a Ruby method that should be crystallized.
     # Compilation and attachment of the method is done lazily.
     # You can force compilation by calling `CrystalRuby.compile!`
-    # It's important that all code using crystalized methods is
+    # It's important that all code using crystallized methods is
     # loaded before any manual calls to compile.
     #
     # E.g.
     #
-    # crystalize :int32
+    # crystallize :int32
     # def add(a: :int32, b: :int32)
     #  a + b
     # end
@@ -16,7 +16,7 @@ module CrystalRuby
     # Pass `raw: true` to pass Raw crystal code to the compiler as a string instead.
     # (Useful for cases where the Crystal method body is not valid Ruby)
     # E.g.
-    # crystalize :int32, raw: true
+    # crystallize :int32, raw: true
     # def add(a: :int32, b: :int32)
     #   <<~CRYSTAL
     #   a + b
@@ -36,9 +36,9 @@ module CrystalRuby
     # @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 crystalize( 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
-        @crystalize_next = {
+        @crystallize_next = {
           raw: raw,
           async: async,
           returns: returns,
@@ -48,8 +48,11 @@ module CrystalRuby
       end
     end
 
+    # Alias for `crystallize`
+    alias :crystalize :crystallize
+
     # Exposes a Ruby method to one or more Crystal libraries.
-    # Type annotations follow the same rules as the `crystalize` method, but are
+    # Type annotations follow the same rules as the `crystallize` method, but are
     # applied in reverse.
     # @param returns The return type of the method. Optional (defaults to :void).
     # @param [Hash] options The options hash.
@@ -73,7 +76,7 @@ module CrystalRuby
 
     # 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 .crystalize to understand the `raw` and `lib` parameters.
+    # 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(
         {
@@ -84,7 +87,7 @@ module CrystalRuby
         }) :
         SourceReader.extract_source_from_proc(block, raw: raw)
 
-      CrystalRuby::Library[lib].crystalize_chunk(
+      CrystalRuby::Library[lib].crystallize_chunk(
         self,
         Digest::MD5.hexdigest(inline_crystal_body),
         inline_crystal_body
@@ -101,29 +104,29 @@ module CrystalRuby
 
     private
 
-    # We trigger attaching of crystalized instance methods here.
-    # If a method is added after a crystalize annotation we assume it's the target of the crystalize annotation.
+    # We trigger attaching of crystallized instance methods here.
+    # If a method is added after a crystallize annotation we assume it's the target of the crystallize annotation.
     # @param [Symbol] method_name The name of the method being added.
     def method_added(method_name)
-      define_crystalized_method(instance_method(method_name)) if should_crystalize_next?
+      define_crystallized_method(instance_method(method_name)) if should_crystallize_next?
       expose_ruby_method_to_crystal(instance_method(method_name)) if should_expose_next?
       super
     end
 
-    # We trigger attaching of crystalized class methods here.
-    # If a method is added after a crystalize annotation we assume it's the target of the crystalize annotation.
+    # We trigger attaching of crystallized class methods here.
+    # If a method is added after a crystallize annotation we assume it's the target of the crystallize annotation.
     # @note This method is called when a method is added to the singleton class of the object.
     # @param [Symbol] method_name The name of the method being added.
     def singleton_method_added(method_name)
-      define_crystalized_method(singleton_method(method_name)) if should_crystalize_next?
+      define_crystallized_method(singleton_method(method_name)) if should_crystallize_next?
       expose_ruby_method_to_crystal(singleton_method(method_name)) if should_expose_next?
       super
     end
 
-    # Helper method to determine if the next method added should be crystalized.
-    # @return [Boolean] True if the next method added should be crystalized.
-    def should_crystalize_next?
-      defined?(@crystalize_next) && @crystalize_next
+    # Helper method to determine if the next method added should be crystallized.
+    # @return [Boolean] True if the next method added should be crystallized.
+    def should_crystallize_next?
+      defined?(@crystallize_next) && @crystallize_next
     end
 
     # Helper method to determine if the next method added should be exposed to Crystal libraries.
@@ -161,7 +164,7 @@ module CrystalRuby
       end
     end
 
-    # We attach crystalized class methods here.
+    # We attach crystallized class methods here.
     # This function is responsible for
     # - Generating the Crystal source code
     # - Overwriting the method and class methods by the same name in the caller.
@@ -169,20 +172,21 @@ module CrystalRuby
     # - We also optionally prepend a block (if given) to the owner, to allow Ruby code to wrap around Crystal code.
     # @param [Symbol] method_name The name of the method being added.
     # @param [UnboundMethod] method The method being added.
-    def define_crystalized_method(method)
-      CrystalRuby.log_debug("Defining crystalized method #{name}.#{method.name}")
+    def define_crystallized_method(method)
+      CrystalRuby.log_debug("Defining crystallized method #{name}.#{method.name}")
 
-      returns, block, async, lib, raw = @crystalize_next.values_at(:returns, :block, :async, :lib, :raw)
-      @crystalize_next = nil
+      returns, block, async, lib, raw = @crystallize_next.values_at(:returns, :block, :async, :lib, :raw)
+      @crystallize_next = nil
 
       args, source = SourceReader.extract_args_and_source_from_method(method, raw: raw)
 
       # We can safely claim the `yield` argument name for typing the yielded block
       # because this is an illegal identifier in Crystal anyway.
       args[:__yield_to] = args.delete(:yield) if args[:yield]
+
       returns = args.delete(:returns) if args[:returns] && returns == :void
 
-      CrystalRuby::Library[lib].crystalize_method(
+      CrystalRuby::Library[lib].crystallize_method(
         method,
         args,
         returns,

data/lib/crystalruby/function.rb

@@ -37,12 +37,12 @@ module CrystalRuby
     end
 
     # This is where we write/overwrite the class and instance methods
-    # with their crystalized equivalents.
+    # with their crystallized equivalents.
     # We also perform JIT compilation and JIT attachment of the FFI functions.
     # Crystalized methods can be redefined without restarting, if running in a live-reloading environment.
     # If they are redefined with a different function body, the new function body
     # will result in a new digest and the FFI function will be recompiled and reattached.
-    def define_crystalized_methods!(lib)
+    def define_crystallized_methods!(lib)
       func = self
       receivers = instance_method ? [owner] : [owner, owner.singleton_class]
       receivers.each do |receiver|
@@ -109,9 +109,9 @@ module CrystalRuby
       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 crystalized FFI functions to their related Ruby modules and classes.
-    # If a wrapper block has been passed to the crystalize function,
-    # then the we also wrap the crystalized function using a prepended Module.
+    # Attaches the crystallized FFI functions to their related Ruby modules and classes.
+    # If a wrapper block has been passed to the crystallize function,
+    # then the we also wrap the crystallized function using a prepended Module.
     def attach_ffi_func!
       argtypes = ffi_types
       rettype = ffi_ret_type

data/lib/crystalruby/library.rb

@@ -61,7 +61,7 @@ module CrystalRuby
 
     # Generates and stores a reference to a new CrystalRuby::Function
     # and triggers the generation of the crystal code. (See write_chunk)
-    def crystalize_method(method, args, returns, function_body, async, &block)
+    def crystallize_method(method, args, returns, function_body, async, &block)
       CR_ATTACH_MUX.synchronize do
         methods.each_value(&:unattach!)
         method_key = "#{method.owner.name}/#{method.name}"
@@ -74,7 +74,7 @@ module CrystalRuby
           lib: self,
           &block
         ).tap do |func|
-          func.define_crystalized_methods!(self)
+          func.define_crystallized_methods!(self)
           func.register_custom_types!(self)
           write_chunk(func.owner_name, method.name, func.chunk)
         end
@@ -110,7 +110,7 @@ module CrystalRuby
       src_dir / "shard.yml"
     end
 
-    def crystalize_chunk(mod, chunk_name, body)
+    def crystallize_chunk(mod, chunk_name, body)
       write_chunk(mod.respond_to?(:name) ? name : "main", chunk_name, body)
     end
 
@@ -271,6 +271,7 @@ module CrystalRuby
     end
 
     def write_chunk(module_name, chunk_name, body)
+      module_name = module_name.gsub("::", "__MOD__")
       chunks.delete_if { |chnk| chnk[:module_name] == module_name && chnk[:chunk_name] == chunk_name }
       chunk = { module_name: module_name, chunk_name: chunk_name, body: body }
       chunks << chunk

data/lib/crystalruby/reactor.rb

@@ -61,15 +61,16 @@ module CrystalRuby
     end
 
     def await_result!
-      mux, cond = thread_conditions.values_at(:mux, :cond)
-      cond.wait(mux)
-      if error = thread_conditions[:error]
-        combined_backtrace = error.backtrace[0..(error.backtrace.index{|m| m.include?('call_blocking_function')} || 2) - 3] + caller[5..-1]
-        error.set_backtrace(combined_backtrace)
-        raise error
+      mux, cond, result, err = thread_conditions.values_at(:mux, :cond, :result, :error)
+      cond.wait(mux) unless (result || err)
+      result, err, thread_conditions[:result], thread_conditions[:error] = thread_conditions.values_at(:result, :error)
+      if err
+        combined_backtrace = err.backtrace[0..(err.backtrace.index{|m| m.include?('call_blocking_function')} || 2) - 3] + caller[5..-1]
+        err.set_backtrace(combined_backtrace)
+        raise err
       end
 
-      thread_conditions[:result]
+      result
     end
 
     def halt_loop!
@@ -90,7 +91,10 @@ module CrystalRuby
         @main_thread_id = Thread.current.object_id
         CrystalRuby.log_debug("Starting reactor")
         CrystalRuby.log_debug("CrystalRuby initialized")
-        REACTOR_QUEUE.pop[] while true
+        while true
+          handler, *args = REACTOR_QUEUE.pop
+          send(handler, *args)
+        end
       rescue StopReactor => e
       rescue StandardError => e
         CrystalRuby.log_error "Error: #{e}"
@@ -107,6 +111,29 @@ module CrystalRuby
       nil
     end
 
+    def invoke_async!(receiver, op_name, *args, thread_id, callback, lib)
+      receiver.send(op_name, *args, thread_id, callback)
+      yield!(lib: lib, time: 0)
+    end
+
+    def invoke_blocking!(receiver, op_name, *args, tvars)
+      tvars[:error] = nil
+      begin
+        tvars[:result] = receiver.send(op_name, *args)
+      rescue StopReactor => e
+        tvars[:cond].signal
+        raise
+      rescue StandardError => e
+        tvars[:error] = e
+      end
+      tvars[:cond].signal
+    end
+
+    def invoke_await!(receiver, op_name, *args, lib)
+      outstanding_jobs = receiver.send(op_name, *args)
+      yield!(lib: lib, time: 0) unless outstanding_jobs == 0
+    end
+
     def schedule_work!(receiver, op_name, *args, return_type, blocking: true, async: true, lib: nil)
       if @single_thread_mode || (Thread.current.object_id == @main_thread_id && op_name != :yield)
         unless Thread.current.object_id == @main_thread_id
@@ -121,34 +148,9 @@ module CrystalRuby
       tvars[:mux].synchronize do
         REACTOR_QUEUE.push(
           case true
-          when async
-            lambda {
-              receiver.send(
-                op_name, *args, tvars[:thread_id],
-                CALLBACKS_MAP[return_type]
-              )
-              yield!(lib: lib, time: 0)
-            }
-          when blocking
-            lambda {
-              tvars[:error] = nil
-              should_halt = false
-              begin
-                result = receiver.send(op_name, *args)
-              rescue StopReactor => e
-                should_halt = true
-              rescue StandardError => e
-                tvars[:error] = e
-              end
-              tvars[:result] = result unless tvars[:error]
-              tvars[:cond].signal
-              raise StopReactor if should_halt
-            }
-          else
-            lambda {
-              outstanding_jobs = receiver.send(op_name, *args)
-              yield!(lib: lib, time: 0) unless outstanding_jobs == 0
-            }
+          when async then [:invoke_async!, receiver, op_name, *args, tvars[:thread_id], CALLBACKS_MAP[return_type], lib]
+          when blocking then [:invoke_blocking!, receiver, op_name, *args, tvars]
+          else [:invoke_await!, receiver, op_name, *args, lib]
           end
         )
         return await_result! if blocking

data/lib/crystalruby/source_reader.rb

@@ -6,46 +6,47 @@ module CrystalRuby
     def extract_expr_from_source_location(source_location)
       lines = source_location.then{|f,l| IO.readlines(f)[l-1..]}
       lines[0] = lines[0][/CRType.*/] if lines[0] =~ /<\s+CRType/ || lines[0] =~ /= CRType/
-      lines.each.with_object("") do |line, expr_source|
-        break expr_source if (SyntaxTree.parse(expr_source << line) rescue nil)
+      lines.each.with_object([]) do |line, expr_source|
+        break expr_source.join("") if (Prism.parse((expr_source << line).join("")).success?)
       end
     rescue
       raise "Failed to extract expression from source location: #{source_location}. Ensure the file exists and the line number is correct. Extraction from a REPL is not supported"
     end
 
+    def search_node(result, node_type)
+      result.breadth_first_search do |node|
+        node_type === node
+      end
+    end
+
     # Given a proc, extracts the source code of the block passed to it
     # If raw is true, the source is expected to be Raw Crystal code captured
     # in a string or Heredoc literal. Otherwise the Ruby code (assumed to be valid Crystal)
     # is extracted.
     def extract_source_from_proc(block, raw: false)
       block_source = extract_expr_from_source_location(block.source_location)
-      body_node =  SyntaxTree.search(block_source, :Statements).to_a[1]
+      parsed_source = Prism.parse(block_source).value
+
+      node = parsed_source.statements.body[0].arguments&.arguments&.find{|x| search_node(x, Prism::StatementsNode) }
+      node ||= parsed_source.statements.body[0]
+      body_node =  search_node(node, Prism::StatementsNode)
+
       return raw ?
-        SyntaxTree.search(node_to_s(body_node), :TStringContent).map(&method(:node_to_s)).join :
+        extract_raw_string_node(body_node) :
         node_to_s(body_node)
     end
 
-    @visitor = SyntaxTree::MutationVisitor.new
-
-    # Specify that it should mutate If nodes with assignments in their predicates
-    @visitor.mutate("ReturnNode") do |node|
-      node
+    def extract_raw_string_node(node)
+      search_node(node, Prism::InterpolatedStringNode)&.parts&.map(&:unescaped)&.join("") ||
+      search_node(node, Prism::StringNode).unescaped
     end
 
+
     # Simple helper function to turn a SyntaxTree node back into a Ruby string
     # The default formatter will turn a break/return of [1,2,3] into a brackless 1,2,3
     # Can't have that in Crystal as it turns it into a Tuple
     def node_to_s(node)
-      @_syxt_transform ||= SyntaxTree::FlowControlFormatter.prepend(Module.new do
-        def format(quer)
-          first_arg = self.node.arguments.child_nodes
-          if first_arg[0].kind_of?(SyntaxTree::ArrayLiteral)
-            return format_arguments(quer, " [", "]")
-          end
-          super(quer)
-        end
-      end)
-      SyntaxTree::Formatter.format("", node.accept(@visitor))
+      node&.slice || ''
     end
 
     # Given a method, extracts the source code of the block passed to it
@@ -67,11 +68,16 @@ module CrystalRuby
     # is extracted.
     def extract_args_and_source_from_method(method, raw: false)
       method_source = extract_expr_from_source_location(method.source_location)
-      params = SyntaxTree.search(method_source, :Params).first
-      args = params ? params.keywords.map{|k,v| [k.value[0...-1].to_sym, node_to_s(v)] }.to_h : {}
-      body_node = SyntaxTree.search(method_source, :BodyStmt).first || SyntaxTree.search(method_source, :Statements).to_a[1]
-      body = node_to_s(body_node)
-      body = SyntaxTree.search(body, :TStringContent).map(&method(:node_to_s)).join if raw
+      parsed_source = Prism.parse(method_source).value
+      params =  search_node(parsed_source, Prism::ParametersNode)
+      args = params ? params.keywords.map{|kw| [kw.name, node_to_s(kw.value)] }.to_h : {}
+      body_node =  parsed_source.statements.body[0].body
+      if body_node.respond_to?(:rescue_clause) && body_node.rescue_clause
+        wrapped = %{begin\n#{body_node.statements.slice}\n#{body_node.rescue_clause.slice}\nend}
+        body_node = Prism.parse(wrapped).value
+      end
+      body = raw ?  extract_raw_string_node(body_node) : node_to_s(body_node)
+
       args.transform_values! do |type_exp|
         if CrystalRuby::Typemaps::CRYSTAL_TYPE_MAP.key?(type_exp[1..-1].to_sym)
           type_exp[1..-1].to_sym

data/lib/crystalruby/types/fixed_width/tagged_union.rb

@@ -93,6 +93,10 @@ module CrystalRuby::Types
         union_types.map(&:native_type_expr).join(" | ")
       end
 
+      define_singleton_method(:named_type_expr) do
+        union_types.map(&:named_type_expr).join(" | ")
+      end
+
       define_singleton_method(:type_expr) do
         anonymous? ? native_type_expr : name
       end

data/lib/crystalruby/types/type.rb

@@ -80,6 +80,16 @@ module CrystalRuby
         end
       end
 
+      def self.named_type_expr
+        if !inner_types
+          "::#{name || typename}"
+        elsif !inner_keys
+          "::#{name || typename}(#{inner_types.map(&:named_type_expr).join(", ")})"
+        else
+          "::#{name || typename}(#{inner_keys.zip(inner_types).map { |k, v| "#{k}: #{v.named_type_expr}" }.join(", ")})"
+        end
+      end
+
       def self.valid_cast?(raw)
         raw.is_a?(self) || convert_if.any? { |type| raw.is_a?(type) }
       end
@@ -94,12 +104,12 @@ module CrystalRuby
       end
 
       def self.crystal_class_name
-        name || native_type_expr.split(",").join("_and_")
-                                .split("|").join("_or_")
-                                .split("(").join("_of_")
-                                .gsub(/[^a-zA-Z0-9_]/, "")
-                                .split("_")
-                                .map(&:capitalize).join << "_#{type_digest[0..6]}"
+        name || named_type_expr.split(",").join("_and_")
+                               .split("|").join("_or_")
+                               .split("(").join("_of_")
+                               .gsub(/[^a-zA-Z0-9_]/, "")
+                               .split("_")
+                               .map(&:capitalize).join << "_#{type_digest[0..6]}"
       end
 
       def self.base_crystal_class_name

data/lib/crystalruby/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CrystalRuby
-  VERSION = "0.3.0"
+  VERSION = "0.3.1"
 end

data/lib/crystalruby.rb

@@ -3,7 +3,7 @@
 require "ffi"
 require "digest"
 require "fileutils"
-require "syntax_tree"
+require "prism"
 require "pathname"
 
 require_relative "crystalruby/config"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: crystalruby
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
+original_platform: ''
 authors:
 - Wouter Coppieters
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-11-06 00:00:00.000000000 Z
+date: 2024-12-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: digest
@@ -53,7 +53,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: syntax_tree
+  name: prism
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -147,7 +147,6 @@ metadata:
   homepage_uri: https://github.com/wouterken/crystalruby
   source_code_uri: https://github.com/wouterken/crystalruby
   changelog_uri: https://github.com/wouterken/crystalruby/CHANGELOG.md
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -162,8 +161,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
-signing_key:
+rubygems_version: 3.6.0.dev
 specification_version: 4
 summary: Embed Crystal code directly in Ruby.
 test_files: []