crystalruby 0.1.8 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 95d9eecc4d47a8d9f83417779c6174eea95ebeea593e5127a89b6cfbc7884664
-  data.tar.gz: b4f241f826e4f2b6c704bda0fd01c201e79a9bc26027bd4702717fd371687650
+  metadata.gz: '0499023eb26e35e6db77566876a96357202c0e6cdfafbb49d2aaa67e070c38cd'
+  data.tar.gz: 4e5f185097b4ad5091b079fc87b43d8d950119c7fbe659a7d76fe473d8cc7cd9
 SHA512:
-  metadata.gz: d98f1e4a671679cfb8d9da45298954e01def202802bd5a64db9d0d9cba08de0776971d031648642f402fe0310d741dc6b2d163253884ad25082298226c1be1a0
-  data.tar.gz: 141658885f763ca3088a7058131e7227434920d6213e755e21f85d6bb4d68a062a2a3163127f4e9f0db03a8c9a27a0549837714b38789647028075cc3b77660c
+  metadata.gz: 0d27665a59a9ecc7345bcca13c5e057d71166684350d54bc158bcefe82655025fc6a8c7fd08069f92c17abe849ad465ee995f223b32391e3f49f2ff7f30c8b92
+  data.tar.gz: ee56f2aead72e533e989b3e80c9550a65fcf78b2677dc070f697d656b1293eefecf0782fa43ac45255fced794a6a54040c32e21571723a1208b3d27babe71851

data/README.md

@@ -87,7 +87,7 @@ module Cache
   end
 
   crystalize [key: :string, value: :string] => :string
-  def redis_set_and_return(key)
+  def redis_set_and_return(key, value)
     redis = Redis::Client.new
     redis.set(key, value)
     Cache.redis_get(key)
@@ -295,6 +295,131 @@ end
 MyModule.add("1", "2")
 ```
 
+## Inline Chunks
+
+`crystalruby` also allows you to write inline Crystal code that does not require binding to Ruby. This can be useful for e.g. performing setup or teardown operations.
+
+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.
+
+1. Start our toy project
+
+```bash
+mkdir crystalredis
+cd crystalredis
+bundle init
+```
+
+2. Add dependencies to our Gemfile and run `bundle install`
+
+```ruby
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gem 'crystalruby'
+
+# Let's see if performance is comparable to that of the redis gem.
+gem 'benchmark-ips'
+gem 'redis'
+```
+
+3. Write our Redis client
+
+```ruby
+# Filename: crystalredis.rb
+require 'crystalruby'
+
+module CrystalRedis
+
+  crystal do
+    CLIENT = Redis.new
+    def self.client
+      CLIENT
+    end
+  end
+
+  crystalize [key: :string, value: :string] => :void
+  def set(key, value)
+    client.set(key, value)
+  end
+
+  crystalize [key: :string] => :string
+  def get(key)
+    client.get(key).to_s
+  end
+end
+```
+
+4. Load the modules (without running them) to generate our Crystal project skeleton.
+
+```bash
+bundle exec ruby crystalredis.rb
+```
+
+5. Add the missing Redis dependency to our shard.yml
+
+```yaml
+# filename:  crystalruby/src/shard.yml
+dependencies:
+  redis:
+    github: stefanwille/crystal-redis
+```
+
+```ruby
+# filename: main.cr
+require "redis"
+require "./generated/index"
+```
+
+```bash
+bundle exec crystalruby install
+```
+
+6. Compile and benchmark our new module in Ruby
+
+```ruby
+# Filename: benchmark.rb
+# Let's compare the performance of our CrystalRedis module to the Ruby Redis gem
+require_relative "crystalredis"
+require 'redis'
+require 'benchmark/ips'
+
+Benchmark.ips do |x|
+  rbredis = Redis.new
+
+  x.report(:crredis) do
+    CrystalRedis.set("hello", "world")
+    CrystalRedis.get("hello")
+  end
+
+  x.report(:rbredis) do
+    rbredis.set("hello", "world")
+    rbredis.get("hello")
+  end
+end
+```
+
+7. Run the benchmark
+
+```bash
+$ bundle exec ruby benchmark.rb
+```
+
+### Output
+
+```bash
+
+#crystalredis wins! (Warm up during first run will be slow for crredis, due to first compilation)
+
+ruby 3.3.0 (2023-12-25 revision 5124f9ac75) [arm64-darwin22]
+Warming up --------------------------------------
+             crredis     1.946k i/100ms
+             rbredis     1.749k i/100ms
+Calculating -------------------------------------
+             crredis     22.319k (± 1.7%) i/s -    112.868k in   5.058448s
+             rbredis     16.861k (± 9.1%) i/s -     83.952k in   5.024941s
+```
+
 ## Release Builds
 
 You can control whether CrystalRuby builds in debug or release mode by setting following config option
@@ -340,7 +465,7 @@ bundle exec crystalruby clean
 
 ## Design Goals
 
-`crystalruby`'s primary purpose is provide ergonomic access to Crystal from Ruby, over FFI.
+`crystalruby`'s primary purpose is to provide ergonomic access to Crystal from Ruby, over FFI.
 For simple usage, advanced knowledge of Crystal should not be required.
 
 However, the abstraction it provides should remain simple, transparent, and easy to hack on and it should not preclude users from supplementing its capabilities with a more direct integration using ffi primtives.

data/lib/crystalruby/template.rb

@@ -1,7 +1,7 @@
 module CrystalRuby
   module Template
     Dir[File.join(File.dirname(__FILE__), "templates", "*.cr")].each do |file|
-      template_name = File.basename(file, File.extname(file)).capitalize
+      template_name = File.basename(file, File.extname(file)).split("_").map(&:capitalize).join
       const_set(template_name, File.read(file))
     end
 

data/lib/crystalruby/templates/inline_chunk.cr

@@ -0,0 +1,6 @@
+# This is the template used for writing inline chunks of Crystal code without direct
+# Ruby integration
+
+module %{module_name}
+  %{body}
+end

data/lib/crystalruby/version.rb

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

data/lib/crystalruby.rb

@@ -22,6 +22,19 @@ module CrystalRuby
     @crystalize_next = { raw: type.to_sym == :raw, args: args, returns: returns, block: block }
   end
 
+  def crystal(type = :src, &block)
+    inline_crystal_body = Template.render(
+      Template::InlineChunk,
+      {
+        module_name: name,
+        body: block.source.lines[
+          type == :raw ? 2...-2 : 1...-1
+        ].join("\n")
+      }
+    )
+    CrystalRuby.write_chunk(self, body: inline_crystal_body)
+  end
+
   def crtype(&block)
     TypeBuilder.with_injected_type_dsl(self) do
       TypeBuilder.build(&block)
@@ -56,7 +69,7 @@ module CrystalRuby
     args ||= {}
     @crystalize_next = nil
     function = build_function(self, method_name, args, returns, function_body)
-    CrystalRuby.write_function(self, name: function[:name], body: function[:body]) do
+    CrystalRuby.write_chunk(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]
@@ -73,7 +86,10 @@ module CrystalRuby
       receiver.prepend(Module.new do
         define_method(method_name) do |*args|
           CrystalRuby.compile! unless CrystalRuby.compiled?
-          CrystalRuby.attach! unless CrystalRuby.attached?
+          unless CrystalRuby.attached?
+            CrystalRuby.attach!
+            return send(method_name, *args) if block
+          end
           args.each_with_index do |arg, i|
             args[i] = function[:arg_maps][i][arg] if function[:arg_maps][i]
           end
@@ -226,6 +242,7 @@ module CrystalRuby
     extend FFI::Library
     ffi_lib "#{config.crystal_lib_dir}/#{config.crystal_lib_name}"
     attach_function "init!", :init, [:pointer], :void
+    send(:remove_const, :ErrorCallback) if defined?(ErrorCallback)
     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)
@@ -314,7 +331,7 @@ module CrystalRuby
 
   def self.attach!
     @block_store.each do |function|
-      function[:compile_callback].call
+      function[:compile_callback]&.call
     end
     @attached = true
   end
@@ -335,7 +352,7 @@ module CrystalRuby
     File.read(digest_file_name) if File.exist?(digest_file_name)
   end
 
-  def self.write_function(owner, name:, body:, &compile_callback)
+  def self.write_chunk(owner, body:, name: Digest::MD5.hexdigest(body), &compile_callback)
     @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,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: crystalruby
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.10
 platform: ruby
 authors:
 - Wouter Coppieters
@@ -87,6 +87,7 @@ files:
 - lib/crystalruby/template.rb
 - lib/crystalruby/templates/function.cr
 - lib/crystalruby/templates/index.cr
+- lib/crystalruby/templates/inline_chunk.cr
 - lib/crystalruby/typebuilder.rb
 - lib/crystalruby/typemaps.rb
 - lib/crystalruby/types.rb