crystalruby 0.1.7 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fe68e58781b8314afb53b268ba9314472ee93c611565f7398d0ff29b445f8ece
-  data.tar.gz: acd5e80d5709cc6f831daa39f58f74fe95642e16a4c44d25c8fab24106b47bcd
+  metadata.gz: ca096d0563b6201c3ef4f084fff3304cfa212fda88e81085580b2de5ff10536f
+  data.tar.gz: ccc68dc96c30f973c9bafcbaec75a2461bbaa275e32913a0781c4cc5488f034f
 SHA512:
-  metadata.gz: 85516d1372b2467147cb5c61e6d33dc27e6e2c0d11876b32dbee1007152096fd54551926177b56e066fa9bc8e4329b8ef13d133280305018428775267eb4a24e
-  data.tar.gz: 207284740bef726d1a8c5df35b21ebe33b8611725363acac451bbadc3b7c714585513027be2398dd4cdd6ff94761c00585c94546fb198a4b90047d91edbef2ce
+  metadata.gz: 134e9888d563673d78dc0b9075a239ee3bab6c4a07eb63ff903c748b97684ec87e9bb33011e9f276504f855edd2a25c29860ebc626aa181f74350f68ace8b9e8
+  data.tar.gz: f3f7a25d12459178e5c8d3cb6a46cfa0e375f65099cdcde15c834a1ba0872198b8475919ec7e5472fa10529bfb71ede67e0edfb88105be5eb220226f2d0ba4ad

data/README.md

@@ -143,7 +143,7 @@ require 'bundler/inline'
 
 gemfile do
   source 'https://rubygems.org'
-  gem 'crystalruby', path: '../crystalruby'
+  gem 'crystalruby'
 end
 
 require 'crystalruby'
@@ -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/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.7"
+  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,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: crystalruby
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.1.9
 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
@@ -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