polycrystal 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9c36c53d38effb8bfff6d117b093f4bfde0a3065aba334b4072443ed1f944699
+  data.tar.gz: db61e2f89922bd9b0361058fccd76674487867a7ec1c5eadd8ead025c74a6d9b
+SHA512:
+  metadata.gz: 4909f54b444dc12fc1ba83a8fe4af344700a63b9dbae268d0ed5b4355752675f1fb48eeeda2a20a2a29541c44193c5123625fc59b73c26c142f1ce48880600ba
+  data.tar.gz: a6adf935b96b4eb5ed09e1cfe7bf3e421144f3e01ff6ce1895ecea45da8de08032be8cc915bbfd05141892df87b025e93018d450a30ce6c6ebcc6d490279781b

data/.gitignore

@@ -0,0 +1,21 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+*_bak
+*.bak
+ext/polycrystal/*.o
+ext/polycrystal/*.bundle
+ext/polycrystal/*.so
+ext/polycrystal/mkmf.log
+ext/polycrystal/Makefile
+.byebug_history
+/.vscode
+Gemfile.lock

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,7 @@
+AllCops:
+  TargetRubyVersion: 3.0
+  NewCops: enable
+  Exclude:
+    - spec/**/*
+    - sample_project/build/**/*
+    - ext/polycrystal/extconf.rb

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.6.8
+before_install: gem install bundler -v 1.17.2

data/Gemfile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in polycrystal.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 Andrii Hrushetskyi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,104 @@
+# Polycrystal
+
+Integrate Crystal code into ruby sing the [Anyolite](https://github.com/Anyolite/anyolite)
+
+Right now it uses a forked with tiny modifications to linking and initialization: https://github.com/ahrushetskyi/anyolite
+
+## Installation
+
+### Now (tested only on MacOS and ruby 3.0.4)
+
+Clone repo with submodules
+
+```bash
+git clone git@github.com:ahrushetskyi/polycrystal.git
+# or
+git clone https://github.com/ahrushetskyi/polycrystal.git
+```
+
+Compile C extension and Anyolite glue objects
+
+```bash
+cd ext/polycrystal
+ruby extconf.rb
+make
+```
+
+Check out sample app:
+
+```bash
+# from repository root
+cd sample_project
+irb -r ./sample
+```
+
+then following should work in the irb console:
+
+```ruby
+CrystalModule::CrystalClass.new.crystal_method
+CrystalModule::CrystalClass.new.return_object
+CrystalModule::CrystalClass.new.return_object.some_method
+CrystalModule::CrystalClass.new.recv_arg(arg: 42)
+```
+
+### Planned
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'polycrystal'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install polycrystal
+
+## Usage
+
+```ruby
+require 'polycrystal'
+
+Polycrystal::Registry.register(
+    # directory with crystal files, added to crystal CRYSTAL_PATH
+    path: File.expand_path("#{__dir__}/crystal"),
+    # file, that should be loaded. Transformed into `require "sample"` in crystal entrypoint, should be accessible from :path
+    file: 'sample.cr', 
+    # This gets wrapped by Anyolite
+    modules: ['CrystalModule'] 
+)
+
+# directory for entrypoint and compiled library. 
+build_path = File.expand_path("#{__dir__}/build") 
+FileUtils.mkdir_p(build_path)
+
+# cpmpile and load 
+# should be called once, after all Polycrystal::Registry#register calls
+Polycrystal::Loader.new(build_path: build_path).load
+```
+
+## TODO
+
+1. Test suite
+2. Code should not be recompiled if it was not changed
+3. Ability to precompile all code on demand, e.g. for Docker images
+4. make shards work. Anyolite may be loaded from shards, if my patches are merged, or better alternatives implemented
+
+## Development
+
+```bash
+git clone git@github.com:ahrushetskyi/polycrystal.git
+# or
+git clone https://github.com/ahrushetskyi/polycrystal.git
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/polycrystal.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/ext/polycrystal/data_helper.c

@@ -0,0 +1,288 @@
+#include <ruby.h>
+
+extern VALUE rb_define_class_under_helper(void* rb, VALUE under, const char* name, VALUE superclass) {
+
+  return rb_define_class_under(under, name, superclass);
+
+}
+
+extern VALUE rb_define_class_helper(void* rb, const char* name, VALUE superclass) {
+
+  return rb_define_class(name, superclass);
+
+}
+
+extern VALUE rb_define_module_under_helper(void* rb, VALUE under, const char* name) {
+
+  return rb_define_module_under(under, name);
+
+}
+
+extern VALUE rb_define_module_helper(void* rb, const char* name) {
+
+  return rb_define_module(name);
+
+}
+
+extern void rb_define_const_helper(void* rb, VALUE under, const char* name, VALUE value) {
+
+  return rb_define_const(under, name, value);
+
+}
+
+extern void set_instance_tt_as_data(VALUE ruby_class) {
+
+  //! TODO: Is this function required?
+  //MRB_SET_INSTANCE_TT(ruby_class, MRB_TT_DATA);
+
+}
+
+extern bool rb_obj_is_kind_of_helper(void* rb, VALUE object, VALUE ruby_class) {
+
+  return rb_obj_is_kind_of(object, ruby_class) == Qtrue ? true : false;
+
+}
+
+extern VALUE rb_obj_class_helper(void* rb, VALUE object) {
+
+  return rb_obj_class(object);
+
+}
+
+extern const char* rb_class_name_helper(void* rb, VALUE ruby_class) {
+
+  VALUE class_name_value = rb_class_name(ruby_class);
+  return rb_string_value_cstr(&class_name_value);
+
+}
+
+extern void* get_data_ptr(VALUE ruby_object) {
+
+  return DATA_PTR(ruby_object);
+
+}
+
+//! About the following method...
+//! It is highly hacky and just modifies a newly creates Ruby object, but that is okay.
+//! It tells the Ruby GC that this object is a pointer and how to free it.
+//! Crystal owns the pointer, so Ruby does not have to do anything else besides calling dfree.
+
+extern void set_data_ptr_and_type(VALUE ruby_object, void* data, struct rb_data_type_struct* data_type) {
+
+  DATA_PTR(ruby_object) = data;
+  RDATA(ruby_object)->basic.flags = T_DATA;
+  RDATA(ruby_object)->dmark = data_type->function.dmark;
+  RDATA(ruby_object)->dfree = data_type->function.dfree;
+
+}
+
+extern VALUE new_empty_object(void* rb, VALUE ruby_class, void* data_ptr, struct rb_data_type_struct* data_type) {
+
+  return rb_data_object_wrap(ruby_class, data_ptr, data_type->function.dmark, data_type->function.dfree);
+
+}
+
+extern void rb_define_method_helper(void* rb, VALUE ruby_class, const char* name, VALUE (*func)(int argc, VALUE* argv, VALUE self), int aspec) {
+
+  return rb_define_method(ruby_class, name, func, -1);
+
+}
+
+extern void rb_define_class_method_helper(void* rb, VALUE ruby_class, const char* name, VALUE (*func)(int argc, VALUE* argv, VALUE self), int aspec) {
+
+  return rb_define_module_function(ruby_class, name, func, -1);
+
+}
+
+extern void rb_define_module_function_helper(void* rb, VALUE ruby_module, const char* name, VALUE (*func)(int argc, VALUE* argv, VALUE self), int aspec) {
+
+  return rb_define_module_function(ruby_module, name, func, -1);
+
+}
+
+extern VALUE rb_inspect_helper(void* rb, VALUE value) {
+
+  return rb_inspect(value);
+
+}
+
+extern VALUE rb_hash_new_helper(void* rb) {
+
+  return rb_hash_new();
+
+}
+
+extern void rb_hash_set_helper(void* rb, VALUE hash, VALUE key, VALUE value) {
+
+  rb_hash_aset(hash, key, value);
+
+}
+
+extern VALUE rb_hash_get_helper(void* rb, VALUE hash, VALUE key) {
+
+  return rb_hash_aref(hash, key);
+
+}
+
+extern VALUE rb_hash_keys_helper(void* rb, VALUE hash) {
+
+  //! NOTE: For some reason rb_hash_keys is not marked as extern, so for now this is a workaround
+  return rb_funcall(hash, rb_intern("keys"), 0);
+
+}
+
+extern int rb_hash_size_helper(void* rb, VALUE hash) {
+
+  return (int) rb_hash_size(hash);
+
+}
+
+extern VALUE convert_to_rb_sym_helper(void* rb, const char* value) {
+
+  return rb_intern(value);
+
+}
+
+extern VALUE rb_ary_ref_helper(void* rb, VALUE ary, int pos) {
+
+  return rb_ary_entry(ary, pos);
+
+}
+
+extern size_t rb_ary_length_helper(VALUE ary) {
+
+  size_t return_value = (size_t) RARRAY_LEN(ary);
+  return return_value;
+}
+
+extern VALUE rb_ary_new_from_values_helper(void* rb, int size, VALUE* values) {
+
+  return rb_ary_new_from_values(size, values);
+
+}
+
+extern void rb_gc_register_helper(void* rb, VALUE value) {
+
+  return rb_gc_register_address(&value);
+
+}
+
+extern void rb_gc_unregister_helper(void* rb, VALUE value) {
+
+  return rb_gc_unregister_address(&value);
+  
+}
+
+extern VALUE rb_yield_helper(void* rb, VALUE value, VALUE arg) {
+
+  return rb_yield(arg);
+
+}
+
+extern VALUE rb_yield_argv_helper(void* rb, VALUE value, int argc, VALUE* argv) {
+
+  return rb_yield_values2(argc, argv);
+
+}
+
+extern VALUE rb_call_block_helper(void* rb, VALUE value, VALUE arg) {
+
+  return rb_proc_call(value, rb_ary_new_from_values(1, &arg));
+
+}
+
+extern VALUE rb_call_block_with_args_helper(void* rb, VALUE value, int argc, VALUE* argv) {
+
+  return rb_proc_call(value, rb_ary_new_from_values(argc, argv));
+
+}
+
+extern bool rb_respond_to_helper(void* rb, VALUE obj, ID name) {
+
+  return rb_respond_to(obj, name);
+
+}
+
+extern VALUE get_rb_obj_value(VALUE obj) {
+
+  return obj;
+
+}
+
+extern VALUE rb_funcall_argv_helper(void *rb, VALUE value, ID name, int argc, VALUE* argv) {
+
+  return rb_funcallv(value, name, argc, argv);
+
+}
+
+extern VALUE rb_funcall_argv_with_block_helper(void *rb, VALUE value, ID name, int argc, VALUE* argv, VALUE block) {
+
+  return rb_funcall_with_block(value, name, argc, argv, block);
+
+}
+
+extern VALUE rb_iv_get_helper(void* rb, VALUE obj, ID sym) {
+
+  return rb_ivar_get(obj, sym);
+
+}
+
+extern void rb_iv_set_helper(void* rb, VALUE obj, ID sym, VALUE value) {
+  
+  rb_ivar_set(obj, sym, value);
+
+}
+
+extern VALUE rb_cv_get_helper(void* rb, VALUE mod, ID sym) {
+
+  return rb_cvar_get(mod, sym);
+  
+}
+
+extern void rb_cv_set_helper(void* rb, VALUE mod, ID sym, VALUE value) {
+
+  return rb_cvar_set(mod, sym, value);
+  
+}
+
+extern VALUE rb_gv_get_helper(void* rb, const char* name) {
+
+  return rb_gv_get(name);
+  
+}
+
+extern void rb_gv_set_helper(void* rb, const char* name, VALUE value) {
+
+  rb_gv_set(name, value);
+  
+}
+
+extern bool does_constant_exist_under(void* rb, VALUE under, const char* name) {
+
+  return rb_const_defined_at(under, rb_intern(name)) == Qtrue ? 1 : 0;
+
+}
+
+extern bool does_constant_exist(void* rb, const char* name) {
+
+  return rb_const_defined(rb_cObject, rb_intern(name)) == Qtrue ? 1 : 0;
+
+}
+
+extern VALUE get_constant_under(void* rb, VALUE under, const char* name) {
+
+  return rb_const_get_at(under, rb_intern(name));
+
+}
+
+extern VALUE get_constant(void* rb, const char* name) {
+
+  return rb_const_get(rb_cObject, rb_intern(name));
+
+}
+
+extern void rb_undef_method_helper(void* rb, VALUE mod, const char* name) {
+
+  return rb_undef_method(mod, name);
+
+}

data/ext/polycrystal/error_helper.c

@@ -0,0 +1,61 @@
+#include <ruby.h>
+
+extern void rb_raise_runtime_error(void* rb, const char* msg) {
+
+  rb_raise(rb_eRuntimeError, msg);
+
+}
+
+extern void rb_raise_type_error(void* rb, const char* msg) {
+
+  rb_raise(rb_eTypeError, msg);
+
+}
+
+extern void rb_raise_argument_error(void* rb, const char* msg) {
+
+  rb_raise(rb_eArgError, msg);
+
+}
+
+extern void rb_raise_index_error(void* rb, const char* msg) {
+
+  rb_raise(rb_eIndexError, msg);
+
+}
+
+extern void rb_raise_range_error(void* rb, const char* msg) {
+
+  rb_raise(rb_eRangeError, msg);
+
+}
+
+extern void rb_raise_name_error(void* rb, const char* msg) {
+
+  rb_raise(rb_eNameError, msg);
+
+}
+
+extern void rb_raise_script_error(void* rb, const char* msg) {
+
+  rb_raise(rb_eScriptError, msg);
+
+}
+
+extern void rb_raise_not_implemented_error(void* rb, const char* msg) {
+
+  rb_raise(rb_eNotImpError, msg);
+
+}
+
+extern void rb_raise_key_error(void* rb, const char* msg) {
+
+  rb_raise(rb_eKeyError, msg);
+
+}
+
+extern void rb_raise_helper(void* rb, VALUE exc, const char* msg) {
+
+  rb_raise(exc, msg);
+
+}

data/ext/polycrystal/extconf.h

@@ -0,0 +1,3 @@
+#ifndef EXTCONF_H
+#define EXTCONF_H
+#endif

data/ext/polycrystal/extconf.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'mkmf'
+
+$LDFLAGS << ' -framework AppKit' if RUBY_PLATFORM =~ /darwin/
+
+MakeMakefile::LINK_SO.sub!('$(OBJS)', 'polycrystal.o')
+
+create_header
+create_makefile 'polycrystal/polycrystal'

data/ext/polycrystal/polycrystal.c

@@ -0,0 +1,38 @@
+#include <ruby.h>
+#include <dlfcn.h>
+#include "extconf.h"
+
+static void (*__polycrystal_init)() = NULL;
+static void (*__polycrystal_module_run)() = NULL;
+
+static VALUE load_library(VALUE _self, VALUE path){
+    char * cpath = StringValueCStr(path);
+    void * handle = dlopen(cpath, RTLD_NOW|RTLD_LOCAL);
+    if(handle != NULL){
+        __polycrystal_init = (void (*)())dlsym(handle, "__polycrystal_init");
+        if(__polycrystal_init != NULL){
+            __polycrystal_init();
+        }else{
+            rb_raise(rb_eRuntimeError, "Load __polycrystal_init failed from %s: %s", cpath, dlerror());
+            return Qnil;
+        }
+        __polycrystal_module_run = (void (*)())dlsym(handle, "__polycrystal_module_run");
+        if(__polycrystal_module_run != NULL){
+            __polycrystal_module_run();
+        }else{
+            rb_raise(rb_eRuntimeError, "Load __polycrystal_module_run failed from %s: %s", cpath, dlerror());
+            return Qnil;
+        }
+    }else{
+        rb_raise(rb_eRuntimeError, "Can't load library at %s: %s", cpath, dlerror());
+        return Qnil;
+    }
+    return Qtrue;
+}
+
+
+void Init_polycrystal() {
+    VALUE mod = rb_define_module("Polycrystal");
+    VALUE class = rb_define_class_under(mod, "Loader", rb_cObject);
+    rb_define_private_method(class, "load_library", load_library, 1);
+}

data/ext/polycrystal/return_functions.c

@@ -0,0 +1,146 @@
+#include <ruby.h>
+
+extern VALUE get_object_class(void* rb) {
+
+    return rb_cObject;
+
+}
+
+extern VALUE get_nil_value() {
+
+    return Qnil;
+
+}
+
+extern VALUE get_false_value() {
+
+    return Qfalse;
+  
+}
+
+extern VALUE get_true_value() {
+
+    return Qtrue;
+  
+}
+
+extern VALUE get_fixnum_value(long value) {
+
+    return INT2FIX(value);
+
+}
+
+extern VALUE get_bool_value(bool value) {
+
+    return (value ? Qtrue : Qfalse);
+
+}
+
+extern VALUE get_float_value(void* mrb, double value) {
+
+    return DBL2NUM(value);
+
+}
+
+extern VALUE get_string_value(void* mrb, char* value) {
+
+    return rb_utf8_str_new(value, strlen(value));
+
+}
+
+extern VALUE get_symbol_value_of_string(void* mrb, char* value) {
+
+    ID sym = rb_intern(value);
+    return ID2SYM(sym);
+
+}
+
+extern int check_rb_fixnum(VALUE value) {
+
+    return FIXNUM_P(value);
+
+}
+
+extern int check_rb_float(VALUE value) {
+
+    return RB_FLOAT_TYPE_P(value);
+
+}
+
+extern int check_rb_true(VALUE value) {
+
+    return (value == Qtrue);
+
+}
+
+extern int check_rb_false(VALUE value) {
+
+    return (value == Qfalse);
+
+}
+
+extern int check_rb_nil(VALUE value) {
+
+    return NIL_P(value);
+
+}
+
+extern int check_rb_undef(VALUE value) {
+
+    return RB_TYPE_P(value, T_UNDEF);
+
+}
+
+extern int check_rb_string(VALUE value) {
+
+    return RB_TYPE_P(value, T_STRING);
+
+}
+
+extern int check_rb_symbol(VALUE value) {
+
+    return RB_TYPE_P(value, T_SYMBOL);
+
+}
+
+extern int check_rb_array(VALUE value) {   
+
+    return RB_TYPE_P(value, T_ARRAY);
+
+}
+
+extern int check_rb_hash(VALUE value) {
+
+    return RB_TYPE_P(value, T_HASH);
+
+}
+
+extern int check_rb_data(VALUE value) {
+
+    return RB_TYPE_P(value, T_DATA);
+
+}
+
+extern long get_rb_fixnum(VALUE value) {
+
+    return FIX2INT(value);
+
+}
+
+extern double get_rb_float(VALUE value) {
+
+    return NUM2DBL(value);
+
+}
+
+extern bool get_rb_bool(VALUE value) {
+
+    return (value != Qfalse);
+
+}
+
+extern const char* get_rb_string(void* mrb, VALUE value) {
+
+    return rb_string_value_cstr(&value);
+
+}

data/ext/polycrystal/script_helper.c

@@ -0,0 +1,38 @@
+#include <ruby.h>
+
+extern void* open_interpreter(void) {
+
+  return (void*) 0;
+
+}
+
+extern void close_interpreter(void* rb) {
+
+
+}
+
+extern void load_script_from_file(void* rb, const char* filename) {
+
+
+
+}
+
+extern VALUE execute_script_line(void* rb, const char* text) {
+
+  int status;
+  VALUE result = rb_eval_string_protect(text, &status);
+
+  if(status) {
+
+    VALUE exception = rb_errinfo();
+    VALUE exception_str = rb_inspect(exception);
+
+    //! TODO: Are there any internal methods to print this prettier?
+
+    printf("%s\n", rb_string_value_cstr(&exception_str));
+
+  }
+
+  return result;
+
+}

data/lib/polycrystal/compiler.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module Polycrystal
+  class Compiler
+    attr_reader :build_path, :registry
+
+    def initialize(build_path:, registry: Polycrystal::Registry.instance)
+      @build_path = build_path
+      @registry = registry
+      # load anyolite
+      add_anyolite
+    end
+
+    def prepare
+      # load anyolite
+      add_anyolite
+      # write crystal entrypoint
+      in_file.write(entrypoint)
+      in_file.close
+    end
+
+    def execute
+      # run compiler
+      puts command
+      raise 'Failed to compile crystal module' unless system(command)
+
+      outfile
+    end
+
+    def add_anyolite
+      registry.register(
+        path: find_anyolite,
+        file: 'anyolite/anyolite',
+        unshift: true
+      )
+    end
+
+    def crystal_paths
+      registry.map(&:path).select { |p| p&.length&.positive? }
+    end
+
+    def crystal_files
+      registry.map(&:file).select { |p| p&.length&.positive? }
+    end
+
+    def crystal_modules
+      registry.select { |m| m.modules&.size&.positive? }.flat_map(&:modules)
+    end
+
+    def entrypoint
+      <<~CRYSTAL
+        #{requires.join("\n")}
+
+        FAKE_ARG = "polycrystal"
+
+        fun __polycrystal_init
+            GC.init
+            ptr = FAKE_ARG.to_unsafe
+            LibCrystalMain.__crystal_main(1, pointerof(ptr))
+            puts "Polycrystal init"
+        end
+
+        fun __polycrystal_module_run
+            puts "Polycrystal module run"
+            rbi = Anyolite::RbInterpreter.new#{' '}
+            Anyolite::HelperClasses.load_all(rbi)
+        #{pad_lines(wraps, 4).join("\n")}
+        end
+      CRYSTAL
+    end
+
+    def wraps
+      crystal_modules.map do |mod|
+        "Anyolite.wrap rbi, #{mod}"
+      end
+    end
+
+    def requires
+      crystal_files.map do |f|
+        "require \"#{f.sub(/\.cr$/, '')}\""
+      end
+    end
+
+    def command
+      "#{include_paths} #{anyolite_glue} #{compiler_cmd} build #{in_file.path} --link-flags \"#{crystal_link_flags}\" -o #{outfile} --release " \
+        '-Danyolite_implementation_ruby_3 -Duse_general_object_format_chars -Dexternal_ruby'
+    end
+
+    def crystal_link_flags
+        case RUBY_PLATFORM
+        when /darwin/
+            "-dynamic -bundle"
+        when /linux/
+            mapfile = File.expand_path("#{build_path}/version.map")
+            File.write(mapfile, "VERS_1.1 {\tglobal:\t\t*;};")
+            "-shared -Wl,--version-script=#{mapfile}"
+        else
+            raise "Unknown platform"
+        end
+    end
+
+    def pad_line(line, n)
+      "#{' ' * n}#{line}"
+    end
+
+    def pad_lines(lines, n)
+      lines.map { |l| pad_line(l, n) }
+    end
+
+    def in_file
+      @in_file ||= File.new(File.expand_path("#{build_path}/polycrystal_module.cr"), 'w')
+    end
+
+    def outfile
+      File.expand_path("#{build_path}/polycrystal_module.#{lib_ext}")
+    end
+
+    def lib_ext
+        case RUBY_PLATFORM
+        when /darwin/
+            "bundle"
+        when /linux/
+            "so"
+        else
+            raise "Unknown platform"
+        end
+    end
+
+    def include_paths
+      existing = `#{compiler_cmd} env`.split("\n").find { |line| line.start_with?('CRYSTAL_PATH') }
+      [existing, *crystal_paths].join(':')
+    end
+
+    def anyolite_glue
+      # "DLDFLAGS"=>"-L/Users/ahrushetskyi/.rbenv/versions/3.0.4/lib  -Wl,-undefined,dynamic_lookup -Wl,-multiply_defined,suppress"
+      env = "-L#{RbConfig::CONFIG['libdir']} #{RbConfig::CONFIG['LIBRUBYARG_SHARED']} " \
+            "#{File.expand_path("#{__dir__}/../../ext/polycrystal/data_helper.o")} " \
+            "#{File.expand_path("#{__dir__}/../../ext/polycrystal/error_helper.o")} " \
+            "#{File.expand_path("#{__dir__}/../../ext/polycrystal/return_functions.o")} " \
+            "#{File.expand_path("#{__dir__}/../../ext/polycrystal/script_helper.o")} "
+
+      "ANYOLITE_LINK_GLUE=\"#{env}\""
+    end
+
+    def compiler_cmd
+      'crystal'
+    end
+
+    def find_anyolite
+      default_path = File.expand_path("#{__dir__}/../../crystal")
+      local_path = File.expand_path("#{build_path}/deps")
+      if File.exist?("#{local_path}/anyolite/anyolite.cr")
+        local_path
+      elsif File.exist?("#{default_path}/anyolite/anyolite.cr")
+        default_path
+      else
+        load_anyolite(local_path)
+      end
+    end
+
+    def load_anyolite(local_path)
+      FileUtils.mkdir_p(local_path)
+
+      system("git clone -b external-ruby https://github.com/ahrushetskyi/anyolite.git #{local_path}/anyolite")
+
+      local_path
+    end
+  end
+end

data/lib/polycrystal/loader.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Polycrystal
+  class Loader
+    attr_reader :build_path, :registry
+
+    def initialize(build_path:, registry: Polycrystal::Registry.instance)
+      @build_path = build_path
+      @registry = registry
+    end
+
+    def load
+      compiler = Polycrystal::Compiler.new(
+        build_path: build_path,
+        registry: registry
+      )
+      compiler.prepare
+      library = compiler.execute
+      load_library(library) # load_library is defined in C file
+    end
+  end
+end

data/lib/polycrystal/registry.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'singleton'
+require 'forwardable'
+
+module Polycrystal
+  class Registry
+    extend Forwardable
+    include Singleton
+    include Enumerable
+
+    CrystalModule = Struct.new(:path, :file, :modules, keyword_init: true)
+
+    attr_reader :modules
+
+    def_delegators :@modules, :each
+
+    def initialize
+      @modules = []
+    end
+
+    def register(path:, file: nil, modules: nil, unshift: false)
+      raise ArgumentError, 'include file is requred to wrap modules' if file.nil? && !modules.nil?
+
+      existing = find_module(file: file, path: path)
+      if existing
+        existing.modules += modules if modules
+      else
+        new_mod = CrystalModule.new(
+          path: path,
+          file: file,
+          modules: modules
+        )
+        unshift ? @modules.unshift(new_mod) : @modules.push(new_mod)
+      end
+    end
+
+    def find_module(path:, file:)
+      modules.find { |mod| mod.path == path && mod.file == file }
+    end
+
+    class << self
+      extend Forwardable
+
+      def_delegators :instance, :register, :modules
+    end
+  end
+end

data/lib/polycrystal/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Polycrystal
+  VERSION = '0.1.1'
+end

data/lib/polycrystal.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'polycrystal/version'
+require 'polycrystal/polycrystal'
+require 'polycrystal/registry'
+require 'polycrystal/compiler'
+require 'polycrystal/loader'
+
+module Polycrystal
+  class Error < StandardError; end
+  # Your code goes here...
+end

data/polycrystal.gemspec

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'polycrystal/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'polycrystal'
+  spec.version       = Polycrystal::VERSION
+  spec.authors       = ['Andrii Hrushetskyi']
+  spec.email         = ['andrii.hrushetskyi@gmail.com']
+
+  spec.summary       = 'Integrate Crystal into ruby'
+  spec.description   = 'Integrate Crystal into ruby using Anyolite https://github.com/Anyolite/anyolite'
+  spec.homepage      = 'https://github.com/ahrushetskyi/polycrystal'
+  spec.license       = 'MIT'
+
+  spec.required_ruby_version = '>= 3.0.4'
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['homepage_uri'] = spec.homepage
+    spec.metadata['source_code_uri'] = 'https://github.com/ahrushetskyi/polycrystal'
+    spec.metadata['changelog_uri'] = 'https://github.com/ahrushetskyi/polycrystal/CHANGELOG.md'
+  else
+    raise 'RubyGems 2.0 or newer is required to protect against ' \
+          'public gem pushes.'
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = %w[lib ext]
+  spec.extensions = ['ext/polycrystal/extconf.rb']
+
+  spec.add_development_dependency 'bundler', '~> 2'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rubocop', '~> 1.36.0'
+  spec.metadata['rubygems_mfa_required'] = 'true'
+end

data/sample_project/.gitignore

@@ -0,0 +1 @@
+/build

data/sample_project/.ruby-version

@@ -0,0 +1 @@
+ruby-3.0.4

data/sample_project/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gem 'polycrystal', path: '../'

data/sample_project/Gemfile.lock

@@ -0,0 +1,18 @@
+PATH
+  remote: ..
+  specs:
+    polycrystal (0.1.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+
+PLATFORMS
+  x86_64-darwin-21
+  x86_64-linux
+
+DEPENDENCIES
+  polycrystal!
+
+BUNDLED WITH
+   2.2.33

data/sample_project/crystal/sample.cr

@@ -0,0 +1,23 @@
+class CrystalModule
+    class SomeThing
+        def some_method
+            69.0
+        end
+    end
+
+    class CrystalClass
+        def crystal_method
+            return 42
+        end
+
+        def return_object
+            SomeThing.new
+        end
+
+        def recv_arg(arg : Int64) : Void
+            puts "Received #{arg}"
+        end
+    end
+end
+
+puts CrystalModule::CrystalClass.new.return_object.some_method

data/sample_project/sample.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'rubygems'
+require 'bundler/setup'
+
+require 'polycrystal'
+
+Polycrystal::Registry.register(
+  path: File.expand_path("#{__dir__}/crystal"),
+  file: 'sample.cr',
+  modules: ['CrystalModule']
+)
+
+build_path = File.expand_path("#{__dir__}/build")
+
+FileUtils.mkdir_p(build_path)
+
+Polycrystal::Loader.new(build_path: build_path).load

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: polycrystal
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Andrii Hrushetskyi
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2022-09-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.36.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.36.0
+description: Integrate Crystal into ruby using Anyolite https://github.com/Anyolite/anyolite
+email:
+- andrii.hrushetskyi@gmail.com
+executables: []
+extensions:
+- ext/polycrystal/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- ext/polycrystal/data_helper.c
+- ext/polycrystal/error_helper.c
+- ext/polycrystal/extconf.h
+- ext/polycrystal/extconf.rb
+- ext/polycrystal/polycrystal.c
+- ext/polycrystal/return_functions.c
+- ext/polycrystal/script_helper.c
+- lib/polycrystal.rb
+- lib/polycrystal/compiler.rb
+- lib/polycrystal/loader.rb
+- lib/polycrystal/registry.rb
+- lib/polycrystal/version.rb
+- polycrystal.gemspec
+- sample_project/.gitignore
+- sample_project/.ruby-version
+- sample_project/Gemfile
+- sample_project/Gemfile.lock
+- sample_project/crystal/sample.cr
+- sample_project/sample.rb
+homepage: https://github.com/ahrushetskyi/polycrystal
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/ahrushetskyi/polycrystal
+  source_code_uri: https://github.com/ahrushetskyi/polycrystal
+  changelog_uri: https://github.com/ahrushetskyi/polycrystal/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.4
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.33
+signing_key:
+specification_version: 4
+summary: Integrate Crystal into ruby
+test_files: []