crystalruby 0.1.8 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 95d9eecc4d47a8d9f83417779c6174eea95ebeea593e5127a89b6cfbc7884664
-  data.tar.gz: b4f241f826e4f2b6c704bda0fd01c201e79a9bc26027bd4702717fd371687650
+  metadata.gz: ca096d0563b6201c3ef4f084fff3304cfa212fda88e81085580b2de5ff10536f
+  data.tar.gz: ccc68dc96c30f973c9bafcbaec75a2461bbaa275e32913a0781c4cc5488f034f
 SHA512:
-  metadata.gz: d98f1e4a671679cfb8d9da45298954e01def202802bd5a64db9d0d9cba08de0776971d031648642f402fe0310d741dc6b2d163253884ad25082298226c1be1a0
-  data.tar.gz: 141658885f763ca3088a7058131e7227434920d6213e755e21f85d6bb4d68a062a2a3163127f4e9f0db03a8c9a27a0549837714b38789647028075cc3b77660c
+  metadata.gz: 134e9888d563673d78dc0b9075a239ee3bab6c4a07eb63ff903c748b97684ec87e9bb33011e9f276504f855edd2a25c29860ebc626aa181f74350f68ace8b9e8
+  data.tar.gz: f3f7a25d12459178e5c8d3cb6a46cfa0e375f65099cdcde15c834a1ba0872198b8475919ec7e5472fa10529bfb71ede67e0edfb88105be5eb220226f2d0ba4ad

data/README.md

@@ -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

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.9"
 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]
@@ -226,6 +239,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 +328,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 +349,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.9
 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