crystalruby 0.1.11 → 0.1.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3cf95b936e86d15e4cbfc45d38ee8ec4bf81a2db762fde8bcfc848d5c73dc3d6
-  data.tar.gz: 05d21217238b8a82b809005de6bed2af202b1d1f4fbd5f4da67588cd83f45428
+  metadata.gz: 41e8370627d23725b55bb1916254b88690e93b384c94692d59d73b0cf5ceda03
+  data.tar.gz: 7d7192ea627331a30f6cd9ff9dcc7482ed2b1e373f115cc0e3cfa19edd5db506
 SHA512:
-  metadata.gz: 88306803e6fe56de62ceb826128767879f0cf46d1656e852deb3e98519d8dd304f151ca03ba8c505915ecc164c8663a19bdb5ea28d751e47e32cc4e8fc555902
-  data.tar.gz: 6b0621a641bf771a9313b652e1d503bfb734942ee1135188ad7baf68d08850577b581cb76a941861c5e2270744e289c32ce720ea4500729483ca50bd365d927f
+  metadata.gz: 56d644c482b04bb8f5b39b6626dda93079578f3f95809294a441e0fd1707aeb71eb253da7a549c351fe448750f6dd2acfdbda3782b37e5aaebb4019332c64d0c
+  data.tar.gz: c529c61b9564f6d23dc551209ac7ce426d56a02424a970b57825f5e993953c376fa57afb3880db0647d581391e7d88881775cd0e2284408997fbaf4e8b37a690

data/Dockerfile

@@ -0,0 +1,17 @@
+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
+WORKDIR /usr/src/app
+
+COPY Gemfile Gemfile.lock ./
+COPY crystalruby.gemspec ./
+COPY lib/crystalruby/version.rb ./lib/crystalruby/version.rb
+
+RUN bundle install
+COPY . .
+
+# Define the command to run your application
+CMD ["bundle", "exec", "irb"]

data/examples/adder/adder.rb

@@ -0,0 +1,10 @@
+require "crystalruby"
+
+module Adder
+  crystalize [a: :int, b: :int] => :int
+  def add(a, b)
+    a + b
+  end
+end
+
+puts Adder.add(1, 2)

data/lib/crystalruby/compilation.rb

@@ -0,0 +1,75 @@
+require "open3"
+require "tmpdir"
+
+module CrystalRuby
+  module Compilation
+    def self.compile!(
+      src: config.crystal_src_dir_abs / config.crystal_main_file,
+      lib: config.crystal_lib_dir_abs / config.crystal_lib_name,
+      verbose: config.verbose,
+      debug: config.debug
+    )
+      Dir.chdir(config.crystal_src_dir_abs) do
+        compile_command = compile_command!(verbose: verbose, debug: debug, lib: lib, src: src)
+        link_command = link_cmd!(verbose: verbose, lib: lib, src: src)
+
+        puts "[crystalruby] Compiling Crystal code: #{compile_command}" if verbose
+        unless system(compile_command)
+          puts "Failed to build Crystal object file."
+          return false
+        end
+
+        puts "[crystalruby] Linking Crystal code: #{link_command}" if verbose
+        unless system(link_command)
+          puts "Failed to link Crystal library."
+          return false
+        end
+      end
+
+      true
+    end
+
+    def self.compile_command!(verbose:, debug:, lib:, src:)
+      @compile_command ||= begin
+        verbose_flag = verbose ? "--verbose" : ""
+        debug_flag = debug ? "" : "--release --no-debug"
+        redirect_output = " > /dev/null " unless verbose
+
+        %(crystal build #{verbose_flag} #{debug_flag} --cross-compile -o #{lib} #{src}#{redirect_output})
+      end
+    end
+
+    # Here we misuse the crystal compiler to build a valid linking command
+    # with all of the platform specific flags that we need.
+    # We then use this command to link the object file that we compiled in the previous step.
+    # This is not robust and is likely to need revision in the future.
+    def self.link_cmd!(verbose:, lib:, src:)
+      @link_cmd ||= begin
+        result = nil
+
+        Dir.mktmpdir do |tmp|
+          output, status = Open3.capture2("crystal build --verbose #{src} -o #{Pathname.new(tmp) / "main"}")
+          unless status.success?
+            puts "Failed to compile the Crystal code."
+            exit 1
+          end
+
+          # Parse the output to find the last invocation of the C compiler, which is likely the linking stage
+          # and strip off the targets that the crystal compiler added.
+          link_command_suffix = output.lines.select { |line| line.strip.start_with?("cc") }.last.strip[/.*(-o.*)/, 1]
+
+          # Replace the output file with the path to the object file we compiled
+          link_command_suffix.gsub!(
+            /-o.*main/,
+            "-o #{lib}"
+          )
+          result = %(cc #{lib}.o -shared #{link_command_suffix})
+          result << " > /dev/null 2>&1" unless verbose
+          result
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/crystalruby/config.rb

@@ -9,26 +9,57 @@ module CrystalRuby
   # Define a nested Config class
   class Config
     include Singleton
-    attr_accessor :debug, :crystal_src_dir, :crystal_lib_dir, :crystal_main_file,
-                  :crystal_lib_name, :crystal_codegen_dir
+    attr_accessor :debug, :verbose
 
     def initialize
       @debug = true
+      @paths_cache = {}
       config = File.exist?("crystalruby.yaml") && begin
         YAML.safe_load(IO.read("crystalruby.yaml"))
       rescue StandardError
         nil
       end || {}
-      @crystal_src_dir     = config.fetch("crystal_src_dir", "./crystalruby/src")
-      @crystal_lib_dir     = config.fetch("crystal_lib_dir", "./crystalruby/lib")
-      @crystal_main_file   = config.fetch("crystal_main_file", "main.cr")
-      @crystal_lib_name    = config.fetch("crystal_lib_name", "crlib")
-      @crystal_codegen_dir = config.fetch("crystal_codegen_dir", "generated")
-      @debug               = config.fetch("debug", "true")
+      @crystal_src_dir      = config.fetch("crystal_src_dir", "./crystalruby/src")
+      @crystal_lib_dir      = config.fetch("crystal_lib_dir", "./crystalruby/lib")
+      @crystal_main_file    = config.fetch("crystal_main_file", "main.cr")
+      @crystal_lib_name     = config.fetch("crystal_lib_name", "crlib")
+      @crystal_codegen_dir  = config.fetch("crystal_codegen_dir", "generated")
+      @crystal_project_root = config.fetch("crystal_project_root", Pathname.pwd)
+      @debug                = config.fetch("debug", true)
+      @verbose              = config.fetch("verbose", false)
+    end
+
+    %w[crystal_main_file crystal_lib_name crystal_project_root].each do |method_name|
+      define_method(method_name) do
+        @paths_cache[method_name] ||= Pathname.new(instance_variable_get(:"@#{method_name}"))
+      end
+    end
+
+    %w[crystal_codegen_dir].each do |method_name|
+      abs_method_name = "#{method_name}_abs"
+      define_method(abs_method_name) do
+        @paths_cache[abs_method_name] ||= crystal_src_dir_abs / instance_variable_get(:"@#{method_name}")
+      end
+
+      define_method(method_name) do
+        @paths_cache[method_name] ||= Pathname.new instance_variable_get(:"@#{method_name}")
+      end
+    end
+
+    %w[crystal_src_dir crystal_lib_dir].each do |method_name|
+      abs_method_name = "#{method_name}_abs"
+      define_method(abs_method_name) do
+        @paths_cache[abs_method_name] ||= crystal_project_root / instance_variable_get(:"@#{method_name}")
+      end
+
+      define_method(method_name) do
+        @paths_cache[method_name] ||= Pathname.new instance_variable_get(:"@#{method_name}")
+      end
     end
   end
 
   def self.configure
     yield(config)
+    @paths_cache = {}
   end
 end

data/lib/crystalruby/templates/index.cr

@@ -43,4 +43,5 @@ end
 %{type_modules}
 
 # Require all generated crystal files
+require "json"
 %{requires}

data/lib/crystalruby/version.rb

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

data/lib/crystalruby.rb

@@ -4,12 +4,15 @@ require "ffi"
 require "digest"
 require "fileutils"
 require "method_source"
+require "pathname"
+
 require_relative "crystalruby/config"
 require_relative "crystalruby/version"
 require_relative "crystalruby/typemaps"
 require_relative "crystalruby/types"
 require_relative "crystalruby/typebuilder"
 require_relative "crystalruby/template"
+require_relative "crystalruby/compilation"
 
 module CrystalRuby
   CR_SRC_FILES_PATTERN = "./**/*.cr"
@@ -71,7 +74,7 @@ module CrystalRuby
     function = build_function(self, method_name, args, returns, function_body)
     CrystalRuby.write_chunk(self, name: function[:name], body: function[:body]) do
       extend FFI::Library
-      ffi_lib "#{config.crystal_lib_dir}/#{config.crystal_lib_name}"
+      ffi_lib config.crystal_lib_dir / config.crystal_lib_name
       attach_function method_name, fname, function[:ffi_types], function[:return_ffi_type]
       if block
         [singleton_class, self].each do |receiver|
@@ -85,7 +88,7 @@ module CrystalRuby
     [singleton_class, self].each do |receiver|
       receiver.prepend(Module.new do
         define_method(method_name) do |*args|
-          CrystalRuby.compile! unless CrystalRuby.compiled?
+          CrystalRuby.build! unless CrystalRuby.compiled?
           unless CrystalRuby.attached?
             CrystalRuby.attach!
             return send(method_name, *args) if block
@@ -219,28 +222,29 @@ module CrystalRuby
         raise "Missing config option `#{config_key}`. \nProvide this inside crystalruby.yaml (run `bundle exec crystalruby init` to generate this file with detaults)"
       end
     end
-    FileUtils.mkdir_p "#{config.crystal_src_dir}/#{config.crystal_codegen_dir}"
-    FileUtils.mkdir_p "#{config.crystal_lib_dir}"
-    unless File.exist?("#{config.crystal_src_dir}/#{config.crystal_main_file}")
+    FileUtils.mkdir_p config.crystal_codegen_dir_abs
+    FileUtils.mkdir_p config.crystal_lib_dir_abs
+    FileUtils.mkdir_p config.crystal_src_dir_abs
+    unless File.exist?(config.crystal_src_dir_abs / config.crystal_main_file)
       IO.write(
-        "#{config.crystal_src_dir}/#{config.crystal_main_file}",
+        config.crystal_src_dir_abs / config.crystal_main_file,
         "require \"./#{config.crystal_codegen_dir}/index\"\n"
       )
     end
 
     attach_crystal_ruby_lib! if compiled?
 
-    return if File.exist?("#{config.crystal_src_dir}/shard.yml")
+    return if File.exist?(config.crystal_src_dir / "shard.yml")
 
-    IO.write("#{config.crystal_src_dir}/shard.yml", <<~CRYSTAL)
+    IO.write("#{config.crystal_src_dir}/shard.yml", <<~YAML)
       name: src
       version: 0.1.0
-    CRYSTAL
+    YAML
   end
 
   def attach_crystal_ruby_lib!
     extend FFI::Library
-    ffi_lib "#{config.crystal_lib_dir}/#{config.crystal_lib_name}"
+    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|
@@ -272,24 +276,19 @@ module CrystalRuby
 
   def type_modules
     (@types_cache || {}).map do |type_name, expr|
-      typedef = ""
       parts = type_name.split("::")
-      indent = ""
-      parts[0...-1].each do |part|
-        typedef << "#{indent} module #{part}\n"
-        indent += "  "
+      typedef = parts[0...-1].each_with_index.reduce("") do |acc, (part, index)|
+        acc + "#{"  " * index}module #{part}\n"
       end
-      typedef << "#{indent}alias #{parts[-1]} = #{expr}\n"
-      parts[0...-1].each do |_part|
-        indent = indent[0...-2]
-        typedef << "#{indent} end\n"
+      typedef += "#{"  " * (parts.size - 1)}alias #{parts.last} = #{expr}\n"
+      typedef + parts[0...-1].reverse.each_with_index.reduce("") do |acc, (_part, index)|
+        acc + "#{"  " * (parts.size - 2 - index)}end\n"
       end
-      typedef
     end.join("\n")
   end
 
   def self.requires
-    @block_store.map do |function|
+    chunk_store.map do |function|
       function_data = function[:body]
       file_digest = Digest::MD5.hexdigest function_data
       fname = function[:name]
@@ -297,40 +296,26 @@ module CrystalRuby
     end.join("\n")
   end
 
-  def self.compile!
-    return unless @block_store
-
-    index_content = Template.render(
+  def self.build!
+    File.write config.crystal_codegen_dir_abs / "index.cr", Template.render(
       Template::Index,
-      {
-        type_modules: type_modules,
-        requires: requires
-      }
+      type_modules: type_modules,
+      requires: requires
     )
-
-    File.write("#{config.crystal_src_dir}/#{config.crystal_codegen_dir}/index.cr", index_content)
-    lib_target = "#{Dir.pwd}/#{config.crystal_lib_dir}/#{config.crystal_lib_name}"
-
-    Dir.chdir(config.crystal_src_dir) do
-      cmd = if config.debug
-              "crystal build -o #{lib_target} #{config.crystal_main_file}"
-            else
-              "crystal build --release --no-debug -o #{lib_target} #{config.crystal_main_file}"
-            end
-
-      unless result = system(cmd)
-        File.delete(digest_file_name) if File.exist?(digest_file_name)
-        raise "Error compiling crystal code"
-      end
+    if @compiled = CrystalRuby::Compilation.compile!(
+      verbose: config.verbose,
+      debug: config.debug
+    )
+      IO.write(digest_file_name, get_cr_src_files_digest)
+      attach_crystal_ruby_lib!
+    else
+      File.delete(digest_file_name) if File.exist?(digest_file_name)
+      raise "Error compiling crystal code"
     end
-
-    IO.write(digest_file_name, get_cr_src_files_digest)
-    @compiled = true
-    attach_crystal_ruby_lib!
   end
 
   def self.attach!
-    @block_store.each do |function|
+    @chunk_store.each do |function|
       function[:compile_callback]&.call
     end
     @attached = true
@@ -345,7 +330,11 @@ module CrystalRuby
   end
 
   def self.digest_file_name
-    @digest_file_name ||= "#{config.crystal_lib_dir}/#{config.crystal_lib_name}.digest"
+    @digest_file_name ||= config.crystal_lib_dir_abs / "#{config.crystal_lib_name}.digest"
+  end
+
+  def self.chunk_store
+    @chunk_store ||= []
   end
 
   def self.get_current_crystal_lib_digest
@@ -353,26 +342,25 @@ module CrystalRuby
   end
 
   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}")
-    existing = Dir.glob("#{config.crystal_src_dir}/#{config.crystal_codegen_dir}/**/*.cr")
-    @block_store.each do |function|
+    chunk_store << { owner: owner, name: name, body: body, compile_callback: compile_callback }
+    FileUtils.mkdir_p(config.crystal_codegen_dir_abs)
+    existing = Dir.glob("#{config.crystal_codegen_dir_abs}/**/*.cr")
+    chunk_store.each do |function|
       owner_name = function[:owner].name
-      FileUtils.mkdir_p("#{config.crystal_src_dir}/#{config.crystal_codegen_dir}/#{owner_name}")
+      FileUtils.mkdir_p(config.crystal_codegen_dir_abs / owner_name)
       function_data = function[:body]
       fname = function[:name]
       file_digest = Digest::MD5.hexdigest function_data
-      filename = "#{config.crystal_src_dir}/#{config.crystal_codegen_dir}/#{owner_name}/#{fname}_#{file_digest}.cr"
-      unless existing.delete(filename)
+      filename = config.crystal_codegen_dir_abs / owner_name / "#{fname}_#{file_digest}.cr"
+      unless existing.delete(filename.to_s)
         @compiled = false
         @attached = false
         File.write(filename, function_data)
       end
       existing.select do |f|
-        f =~ %r{#{config.crystal_src_dir}/#{config.crystal_codegen_dir}/#{owner_name}/#{fname}_[a-f0-9]{32}\.cr}
+        f =~ /#{config.crystal_codegen_dir / owner_name / "#{fname}_[a-f0-9]{32}\.cr"}/
       end.each do |fl|
-        File.delete(fl) unless fl.eql?(filename)
+        File.delete(fl) unless fl.eql?(filename.to_s)
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: crystalruby
 version: !ruby/object:Gem::Version
-  version: 0.1.11
+  version: 0.1.12
 platform: ruby
 authors:
 - Wouter Coppieters
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-04-11 00:00:00.000000000 Z
+date: 2024-04-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: digest
@@ -77,12 +77,15 @@ files:
 - ".rubocop.yml"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
+- Dockerfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - crystalruby.gemspec
+- examples/adder/adder.rb
 - exe/crystalruby
 - lib/crystalruby.rb
+- lib/crystalruby/compilation.rb
 - lib/crystalruby/config.rb
 - lib/crystalruby/template.rb
 - lib/crystalruby/templates/function.cr