julia 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: ffe6273a8591b918cc6e38e68d6f3301e2b14bee
-  data.tar.gz: 790bd12e87a137f6b57e7926517da57bde91c552
+SHA256:
+  metadata.gz: 761658bd92a75b136265135887ffe7ca82a3c42d7e5d15ea5f6f9d8212d23ec1
+  data.tar.gz: 0052f5ad9249ff2063eceae0919573fea27039611824cad251b5aa63bdef57e1
 SHA512:
-  metadata.gz: e3f48e6edcb0d0ee8d15d4775fd61dcc046824af9d8b6df0f81ed035f84785d70c33371d0ead89ae63f96ce0088602002a287b03dc8e040839304e4103195651
-  data.tar.gz: 4d0a8208bda0274b58610bc40cf11d937561e471679fbe4bcb7f991e917c51670d772fff62fb889ff5951482e1989a19f70c091311e69fc5b7cbc584a6e2d3a7
+  metadata.gz: d6cf4724a9648c91ec03ed60fc1e9f3a337adc11ba1320ac74fedb7a0b6d12bde7fe1f050e9ca4e1d594caf45991977ee8f68ed6620d5beeb9fae79f6ca04c5b
+  data.tar.gz: 01d84c23f8c58efa7bd41a241389195e50a6842a6bd0ba0ae7fae77abb5b04bcb135d022b8cfe6a6372b5d4bcfbf18c8a3dd0b4f13f385057e898667c014b120

data/README.md

@@ -2,6 +2,20 @@
 
 Julia on Ruby.
 
+## Supported versions
+
+### Ruby
+
+- 2.5
+- 2.4
+- 2.3
+
+### Julia
+
+- 1.0
+- 0.7
+- 0.6
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -23,14 +37,17 @@ Or install it yourself as:
 ```ruby
 require 'julia'
 
-Julia.init(ENV['JULIA_HOME'])
-Julia.eval_string('print(pi)')
+Julia.eval('print(pi)')
 ```
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/julia.
+Bug reports and pull requests are welcome on GitHub at https://github.com/mrkn/julia.
+
+## Authors
 
+- Kenta Murata
+- Kenta Tanoue
 
 ## License
 

data/Rakefile

@@ -1,6 +1,11 @@
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+require "bundler"
+Bundler::GemHelper.install_tasks
+
+require "rake"
 require "rake/extensiontask"
+require "rspec/core/rake_task"
+
+Dir[File.expand_path('../tasks/**/*.rake', __FILE__)].each {|f| load f }
 
 Rake::ExtensionTask.new('julia')
 

data/bin/console

@@ -6,9 +6,5 @@ require "julia"
 # You can add fixtures and/or initialization code here to make experimenting
 # with your gem easier. You can also use a different console, if you like.
 
-# (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
-# Pry.start
-
-require "irb"
-IRB.start
+require "pry"
+Pry.start

data/ext/julia/extconf.rb

@@ -1,8 +1,3 @@
 require 'mkmf'
 
-dir_config('julia')
-have_header('julia.h')
-have_library('julia')
-have_func('jl_init')
-
-create_makefile('julia')
+create_makefile('julia')

data/ext/julia/julia.c

@@ -1,30 +1,19 @@
-#include <julia.h>
-#include <ruby.h>
+#include "julia_internal.h"
 
-VALUE rbjl_mJulia;
+VALUE julia_mJulia;
 
-static VALUE
-rbjl_julia_s_init(VALUE mod, VALUE home)
+static void
+init_julia(void)
 {
-    SafeStringValue(home);
-    jl_init(NIL_P(home) ? NULL : StringValueCStr(home));
-    return mod;
-}
-
-static VALUE
-rbjl_julia_s_eval_string(VALUE mod, VALUE str)
-{
-    SafeStringValue(str);
-    jl_eval_string(StringValueCStr(str));
-
-    return mod;
+  JULIA_API(jl_init)();
 }
 
 void
 Init_julia(void)
 {
-    rbjl_mJulia = rb_define_module("Julia");
+  julia_mJulia = rb_define_module("Julia");
+
+  julia_init_libjulia();
 
-    rb_define_module_function(rbjl_mJulia, "init", rbjl_julia_s_init, 1);
-    rb_define_module_function(rbjl_mJulia, "eval_string", rbjl_julia_s_eval_string, 1);
+  init_julia();
 }

data/ext/julia/julia_internal.h

@@ -0,0 +1,125 @@
+#ifndef JULIA_INTERNAL_H
+#define JULIA_INTERNAL_H 1
+#define JL_DATA_TYPE
+
+#ifdef __cplusplus
+extern "C" {
+#if 0
+} /* satisfy cc-mode */
+#endif
+#endif
+
+#include <ruby.h>
+
+#if SIZEOF_LONG == SIZEOF_VOIDP
+# define PTR2NUM(x)   (LONG2NUM((long)(x)))
+# define NUM2PTR(x)   ((void*)(NUM2ULONG(x)))
+#elif SIZEOF_LONG_LONG == SIZEOF_VOIDP
+# define PTR2NUM(x)   (LL2NUM((LONG_LONG)(x)))
+# define NUM2PTR(x)   ((void*)(NUM2ULL(x)))
+#else
+# error ---->> ruby requires sizeof(void*) == sizeof(long) or sizeof(LONG_LONG) to be compiled. <<----
+#endif
+
+typedef struct _jl_value_t jl_value_t;
+typedef struct _jl_taggedvalue_t jl_taggedvalue_t;
+
+typedef struct _jl_sym_t {
+    JL_DATA_TYPE
+    struct _jl_sym_t *left;
+    struct _jl_sym_t *right;
+    uintptr_t hash;
+} jl_sym_t;
+
+typedef struct {
+    JL_DATA_TYPE
+    size_t length;
+} jl_svec_t;
+
+typedef struct {
+    uint32_t nfields;
+    uint32_t alignment : 9;
+    uint32_t haspadding : 1;
+    uint32_t npointers : 20;
+    uint32_t fielddesc_type : 2;
+} jl_datatype_layout_t;
+
+typedef struct {
+    JL_DATA_TYPE
+    jl_sym_t *name;
+    struct _jl_module_t *module;
+    jl_svec_t *names;
+    jl_value_t *wrapper;
+    jl_svec_t *cache;
+    jl_svec_t *linearcache;
+    intptr_t hash;
+    struct _jl_methtable_t *mt;
+} jl_typename_t;
+
+typedef struct _jl_datatype_t {
+    JL_DATA_TYPE
+    jl_typename_t *name;
+    struct _jl_datatype_t *super;
+    jl_svec_t *parameters;
+    jl_svec_t *types;
+    jl_svec_t *names;
+    jl_value_t *instance;
+    const jl_datatype_layout_t *layout;
+    int32_t size;
+    int32_t ninitialized;
+    uint32_t uid;
+    uint8_t abstract;
+    uint8_t mutabl;
+    uint8_t hasfreetypevars;
+    uint8_t isconcretetype;
+    uint8_t isdispatchtuple;
+    uint8_t isbitstype;
+    uint8_t zeroinit;
+    uint8_t isinlinealloc;
+    void *struct_decl;
+    void *ditype;
+} jl_datatype_t;
+
+struct julia_api_table {
+  int (* jl_is_initialized)(void);
+  void (* jl_init)(void);
+  char const * (* jl_ver_string)(void);
+  jl_datatype_t *jl_bool_type;
+  jl_datatype_t *jl_char_type;
+  jl_datatype_t *jl_string_type;
+  jl_datatype_t *jl_int8_type;
+  jl_datatype_t *jl_uint8_type;
+  jl_datatype_t *jl_int16_type;
+  jl_datatype_t *jl_uint16_type;
+  jl_datatype_t *jl_int32_type;
+  jl_datatype_t *jl_uint32_type;
+  jl_datatype_t *jl_int64_type;
+  jl_datatype_t *jl_uint64_type;
+  jl_datatype_t *jl_float16_type;
+  jl_datatype_t *jl_float32_type;
+  jl_datatype_t *jl_float64_type;
+  jl_value_t * (* jl_eval_string)(const char *str);
+  jl_value_t * (* jl_typeof)(jl_value_t *v);
+  const char * (* jl_typeof_str)(jl_value_t *v);
+  const char * (* jl_string_ptr)(jl_value_t *s);
+  int8_t (* jl_unbox_bool)(jl_value_t *v);
+  int8_t (* jl_unbox_int8)(jl_value_t *v);
+  uint8_t (* jl_unbox_uint8)(jl_value_t *v);
+  int16_t (* jl_unbox_int16)(jl_value_t *v);
+  uint16_t (* jl_unbox_uint16)(jl_value_t *v);
+  int32_t (* jl_unbox_int32)(jl_value_t *v);
+  uint32_t (* jl_unbox_uint32)(jl_value_t *v);
+  int64_t (* jl_unbox_int64)(jl_value_t *v);
+  uint64_t (* jl_unbox_uint64)(jl_value_t *v);
+  float (* jl_unbox_float32)(jl_value_t *v);
+  double (* jl_unbox_float64)(jl_value_t *v);
+};
+
+struct julia_api_table *julia_get_api_table(void);
+#define JULIA_API(name) (julia_get_api_table()->name)
+
+void julia_init_libjulia(void);
+
+extern VALUE julia_mJulia;
+extern VALUE julia_mLibJulia;
+#endif /* JULIA_INTERNAL_H */

data/ext/julia/libjulia.c

@@ -0,0 +1,253 @@
+#include "julia_internal.h"
+
+VALUE julia_mLibJulia;
+VALUE julia_eAPINotFound;
+struct julia_api_table api_table;
+jl_value_t *ans;
+int8_t ans_bool;
+
+struct julia_api_table *
+julia_get_api_table(void)
+{
+  return &api_table;
+}
+
+struct lookup_api_args {
+  VALUE handle;
+  char const *name;
+};
+
+static VALUE
+lookup_libjulia_api_0(struct lookup_api_args *args)
+{
+  return rb_funcall(args->handle, rb_intern("sym"), 1, rb_str_new2(args->name));
+}
+
+static void *
+lookup_libjulia_api(VALUE handle, char const *name)
+{
+  struct lookup_api_args arg;
+  VALUE addr;
+  int state;
+
+  arg.handle = handle;
+  arg.name = name;
+  addr = rb_protect((VALUE (*)(VALUE))lookup_libjulia_api_0, (VALUE)&arg, &state);
+  return (state || NIL_P(addr)) ? NULL : NUM2PTR(addr);
+}
+
+static void
+init_api_table(VALUE handle)
+{
+#define LOOKUP_API_ENTRY(api_name) lookup_libjulia_api(handle, #api_name)
+#define CHECK_API_ENTRY(api_name) (LOOKUP_API_ENTRY(api_name) != NULL)
+#define INIT_API_TABLE_ENTRY2(member_name, api_name) do { \
+    void *fptr = LOOKUP_API_ENTRY(api_name); \
+    if (!fptr) { \
+      rb_raise(julia_eAPINotFound, "Unable to find the required symbol in libjulia: %s", #api_name); \
+    } \
+    ((api_table).member_name) = fptr; \
+  } while (0)
+#define INIT_API_TABLE_ENTRY(api_name) INIT_API_TABLE_ENTRY2(api_name, api_name)
+
+  if (CHECK_API_ENTRY(jl_init)) {
+    INIT_API_TABLE_ENTRY(jl_init);
+  }
+  else {
+    INIT_API_TABLE_ENTRY2(jl_init, jl_init__threading);
+  }
+
+  INIT_API_TABLE_ENTRY(jl_is_initialized);
+  INIT_API_TABLE_ENTRY(jl_ver_string);
+
+  INIT_API_TABLE_ENTRY(jl_bool_type);
+  INIT_API_TABLE_ENTRY(jl_char_type);
+  INIT_API_TABLE_ENTRY(jl_string_type);
+  INIT_API_TABLE_ENTRY(jl_int8_type);
+  INIT_API_TABLE_ENTRY(jl_uint8_type);
+  INIT_API_TABLE_ENTRY(jl_int16_type);
+  INIT_API_TABLE_ENTRY(jl_uint16_type);
+  INIT_API_TABLE_ENTRY(jl_int32_type);
+  INIT_API_TABLE_ENTRY(jl_uint32_type);
+  INIT_API_TABLE_ENTRY(jl_int64_type);
+  INIT_API_TABLE_ENTRY(jl_uint64_type);
+  INIT_API_TABLE_ENTRY(jl_float16_type);
+  INIT_API_TABLE_ENTRY(jl_float32_type);
+  INIT_API_TABLE_ENTRY(jl_float64_type);
+  INIT_API_TABLE_ENTRY(jl_eval_string);
+  INIT_API_TABLE_ENTRY(jl_typeof);
+  INIT_API_TABLE_ENTRY(jl_typeof_str);
+  INIT_API_TABLE_ENTRY(jl_string_ptr);
+  INIT_API_TABLE_ENTRY(jl_unbox_bool);
+  INIT_API_TABLE_ENTRY(jl_unbox_int8);
+  INIT_API_TABLE_ENTRY(jl_unbox_uint8);
+  INIT_API_TABLE_ENTRY(jl_unbox_int16);
+  INIT_API_TABLE_ENTRY(jl_unbox_uint16);
+  INIT_API_TABLE_ENTRY(jl_unbox_int32);
+  INIT_API_TABLE_ENTRY(jl_unbox_uint32);
+  INIT_API_TABLE_ENTRY(jl_unbox_int64);
+  INIT_API_TABLE_ENTRY(jl_unbox_uint64);
+  INIT_API_TABLE_ENTRY(jl_unbox_float32);
+  INIT_API_TABLE_ENTRY(jl_unbox_float64);
+}
+
+int
+jl_typeis(jl_value_t *v, jl_datatype_t *t){
+  return ((jl_typename_t *)JULIA_API(jl_typeof)(v) == t->name);
+}
+
+int
+jl_is_bool(jl_value_t *v)
+{
+  return jl_typeis(v, JULIA_API(jl_bool_type));
+}
+
+int
+jl_is_char(jl_value_t *v)
+{
+  return jl_typeis(v, JULIA_API(jl_char_type));
+}
+
+int
+jl_is_string(jl_value_t *v)
+{
+  return jl_typeis(v, JULIA_API(jl_string_type));
+}
+
+int
+jl_is_int8(jl_value_t *v)
+{
+  return jl_typeis(v, JULIA_API(jl_int8_type));
+}
+
+int
+jl_is_uint8(jl_value_t *v)
+{
+  return jl_typeis(v, JULIA_API(jl_uint8_type));
+}
+
+int
+jl_is_int16(jl_value_t *v)
+{
+  return jl_typeis(v, JULIA_API(jl_int16_type));
+}
+
+int
+jl_is_uint16(jl_value_t *v)
+{
+  return jl_typeis(v, JULIA_API(jl_uint16_type));
+}
+
+int
+jl_is_int32(jl_value_t *v)
+{
+  return jl_typeis(v, JULIA_API(jl_int32_type));
+}
+
+int
+jl_is_uint32(jl_value_t *v)
+{
+  return jl_typeis(v, JULIA_API(jl_uint32_type));
+}
+
+int
+jl_is_int64(jl_value_t *v)
+{
+  return jl_typeis(v, JULIA_API(jl_int64_type));
+}
+
+int
+jl_is_uint64(jl_value_t *v)
+{
+  return jl_typeis(v, JULIA_API(jl_uint64_type));
+}
+
+int
+jl_is_float16(jl_value_t *v)
+{
+  return jl_typeis(v, JULIA_API(jl_float16_type));
+}
+
+int
+jl_is_float32(jl_value_t *v)
+{
+  return jl_typeis(v, JULIA_API(jl_float32_type));
+}
+
+int
+jl_is_float64(jl_value_t *v)
+{
+  return jl_typeis(v, JULIA_API(jl_float64_type));
+}
+
+static VALUE
+jl_eval_string(VALUE handle, VALUE arg)
+{
+  Check_Type(arg, T_STRING);
+  ans = JULIA_API(jl_eval_string)(StringValuePtr(arg));
+  if (jl_is_string(ans)) {
+    return rb_str_new2(JULIA_API(jl_string_ptr)(ans));
+  }
+  if (jl_is_bool(ans)) {
+    ans_bool = JULIA_API(jl_unbox_bool)(ans);
+    if (ans_bool == 1){
+      return Qtrue;
+    }else{
+      return Qfalse;
+    }
+  }
+  if (jl_is_int8(ans)) {
+    return INT2NUM(JULIA_API(jl_unbox_int8)(ans));
+ }
+  if (jl_is_uint8(ans)) {
+    return INT2NUM(JULIA_API(jl_unbox_uint8)(ans));
+  }
+  if (jl_is_int16(ans)) {
+    return INT2NUM(JULIA_API(jl_unbox_int16)(ans));
+  }
+  if (jl_is_uint16(ans)) {
+    return INT2NUM(JULIA_API(jl_unbox_uint16)(ans));
+  }
+  if (jl_is_int32(ans)) {
+    return INT2NUM(JULIA_API(jl_unbox_int32)(ans));
+  }
+  if (jl_is_uint32(ans)) {
+    return INT2NUM(JULIA_API(jl_unbox_uint32)(ans));
+  }
+  if (jl_is_int64(ans)) {
+    return INT2NUM(JULIA_API(jl_unbox_int64)(ans));
+  }
+  if (jl_is_uint64(ans)) {
+    return INT2NUM(JULIA_API(jl_unbox_uint64)(ans));
+  }
+  if (jl_is_float32(ans)) {
+    return DBL2NUM(JULIA_API(jl_unbox_float32)(ans));
+  }
+  if (jl_is_float64(ans)) {
+    return DBL2NUM(JULIA_API(jl_unbox_float64)(ans));
+  }
+  return rb_str_new2(JULIA_API(jl_typeof_str)(ans));
+}
+
+static void
+define_JULIA_VERSION(void)
+{
+  char const *version = JULIA_API(jl_ver_string)();
+  rb_define_const(julia_mLibJulia, "JULIA_VERSION", rb_usascii_str_new_static(version, strlen(version)));
+}
+
+void
+julia_init_libjulia(void)
+{
+  VALUE handle;
+  julia_mLibJulia = rb_const_get_at(julia_mJulia, rb_intern("LibJulia"));
+  handle = rb_funcall(julia_mLibJulia, rb_intern("handle"), 0);
+  rb_define_module_function(julia_mLibJulia, "jl_eval_string", jl_eval_string, 1);
+  init_api_table(handle);
+
+  if (JULIA_API(jl_is_initialized)() == 0) {
+    JULIA_API(jl_init)();
+  }
+
+  define_JULIA_VERSION();
+}

data/julia.gemspec

@@ -1,5 +1,5 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'julia/version'
 
@@ -9,8 +9,8 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Kenta Murata"]
   spec.email         = ["mrkn@cookpad.com"]
 
-  spec.summary       = %q{Julia on Ruby}
-  spec.description   = %q{Julia on Ruby}
+  spec.summary       = 'Julia on Ruby'
+  spec.description   = 'Julia on Ruby'
   spec.homepage      = "https://github.com/mrkn/ruby-julia"
   spec.license       = "MIT"
 
@@ -21,9 +21,11 @@ Gem::Specification.new do |spec|
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
-  spec.extensions    << 'ext/julia/extconf.rb'
 
   spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "pry-byebug"
   spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rake-compiler"
   spec.add_development_dependency "rspec"
 end

data/lib/julia.rb

@@ -0,0 +1,12 @@
+module Julia
+  require 'julia/version'
+  require 'julia/libjulia'
+  require 'julia/init'
+
+  module_function
+
+  def eval(str)
+    Julia.init unless LibJulia.respond_to? :jl_eval_string
+    LibJulia.jl_eval_string(str)
+  end
+end

data/lib/julia/error.rb

@@ -0,0 +1,7 @@
+module Julia
+  class Error < StandardError
+  end
+
+  class JuliaNotFound < Error
+  end
+end

data/lib/julia/init.rb

@@ -0,0 +1,49 @@
+module Julia
+  def self.const_missing(name)
+    case name
+    when :JULIA_VERSION
+      Julia.init
+      const_get(name)
+    else
+      super
+    end
+  end
+
+  module LibJulia
+    def self.const_missing(name)
+      case name
+      when :JULIA_VERSION
+        Julia.init
+        const_get(name)
+      else
+        super
+      end
+    end
+  end
+
+  def self.init(julia = ENV['JULIA'])
+    return false if LibJulia.instance_variable_defined? :@handle
+    class << Julia
+      remove_method :const_missing
+    end
+    class << Julia::LibJulia
+      remove_method :const_missing
+    end
+
+    LibJulia.instance_variable_set :@handle, LibJulia::Finder.find_libjulia(julia)
+    class << LibJulia
+      undef_method :handle
+      attr_reader :handle
+    end
+
+    begin
+      major, minor, _ = RUBY_VERSION.split('.')
+      require "#{major}.#{minor}/julia.so"
+    rescue LoadError
+      require 'julia.so'
+    end
+
+    const_set(:JULIA_VERSION, LibJulia::JULIA_VERSION)
+    true
+  end
+end

data/lib/julia/libjulia.rb

@@ -0,0 +1,18 @@
+module Julia
+  module LibJulia
+    require 'julia/libjulia/finder'
+
+    def self.load_lib
+      require 'julia/libjulia/finder'
+      lib_path = Finder.find_libjulia
+      Fiddle::Handle.new(lib_path[0], Fiddle::Handle::RTLD_LAZY | Fiddle::Handle::RTLD_GLOBAL)
+    end
+
+    def self.handle
+      # NOTE: Julia.init redefine this method.
+      #       See julia/init.rb for the detail.
+      Julia.init
+      handle
+    end
+  end
+end

data/lib/julia/libjulia/finder.rb

@@ -0,0 +1,102 @@
+require 'julia/error'
+require 'fiddle'
+
+module Julia
+  module LibJulia
+    module Finder
+      case RUBY_PLATFORM
+      when /cygwin/
+        libprefix = 'cyg'
+        libsuffix = 'dll'
+      when /mingw/, /mswin/
+        libprefix = ''
+        libsuffix = 'dll'
+      when /darwin/
+        libsuffix = 'dylib'
+      end
+
+      LIBPREFIX = libprefix || 'lib'
+      LIBSUFFIX = libsuffix || 'so'
+
+      class << self
+        DEFAULT_JULIA = -'julia'
+
+        def find_libjulia(julia = nil)
+          debug_report "find_libjulia(#{julia.inspect})"
+          julia_cmd, julia_config = investigate_julia(julia)
+
+          libpath = File.join(julia_config[:libdir], "libjulia.#{LIBSUFFIX}")
+          if File.file? libpath
+            begin
+              return dlopen(libpath)
+            rescue Fiddle::DLError
+              debug_report "#{$!.class}: #{$!.message}"
+            else
+              debug_report "Success to dlopen #{fullname}"
+            end
+          else
+            debug_report "Unable to find #{fullname}"
+          end
+
+          raise Julia::JuliaNotFound
+        end
+
+        def investigate_julia(julia = nil)
+          julia ||= DEFAULT_JULIA
+          Array(julia).each do |julia_cmd|
+            julia_config = run_julia_investigator(julia_cmd)
+            return [julia_cmd, julia_config] unless julia_config.empty?
+          end
+        rescue
+          debug_report "investigate_julia: (#{$!.class}) #{$!.message}"
+          raise Julia::JuliaNotFound
+        else
+          raise Julia::JuliaNotFound
+        end
+
+        def run_julia_investigator(julia_cmd)
+          debug_report "run_julia_investigator(#{julia_cmd})"
+          IO.popen({}, [julia_cmd, julia_investigator_jl], 'r') do |io|
+            {}.tap do |config|
+              io.each_line do |line|
+                next unless line =~ /: /
+                key, value = line.chomp.split(': ', 2)
+                case value
+                when 'true', 'false'
+                  value = (value == 'true')
+                end
+                config[key.to_sym] = value if value != 'nothing'
+              end
+            end
+          end
+        rescue Errno::ENOENT
+          raise Julia::JuliaNotFound
+        end
+
+        def julia_investigator_jl
+          File.expand_path('../investigator.jl', __FILE__)
+        end
+
+        private
+
+        def dlopen(path)
+          # NOTE: libjulia needs to be dlopened with RTLD_GLOBAL.
+          # Fiddle.dlopen(path) is same as Fiddle::Handle.new(path),
+          # and Fiddle::Handle.new defaultly specifies RTLD_GLOBAL.
+          Fiddle.dlopen(path).tap do |handle|
+            debug_report "dlopen(#{path.inspect}) = #{handle.inspect}" if handle
+          end
+        end
+
+        def debug_report(message)
+          return unless debug?
+          $stderr.puts "DEBUG(find_libjulia) #{message}"
+        end
+
+        def debug?
+          @debug_p ||= (ENV['RUBY_JULIA_DEBUG_FIND_LIBJULIA'] == '1')
+        end
+      end
+    end
+  end
+end

data/lib/julia/libjulia/investigator.jl

@@ -0,0 +1,18 @@
+# See https://github.com/JuliaLang/julia/pull/25102
+if VERSION < v"0.7.0-DEV.3073"
+  bindir = JULIA_HOME
+else
+  bindir = Sys.BINDIR
+end
+
+if VERSION >= v"0.7.0-DEV.3382"
+  using Libdl
+end
+
+println("VERSION: $(VERSION)")
+
+jl_share = abspath(joinpath(bindir, Base.DATAROOTDIR, "julia"))
+println("JL_HOME: $(jl_share)")
+
+libdir = abspath(dirname(Libdl.dlpath("libjulia")))
+println("libdir: $(libdir)")

data/lib/julia/load_libruby.jl

@@ -0,0 +1,59 @@
+function find_library(ruby::AbstractString)
+  v = rbexpr(ruby, "RUBY_VERSION", "")
+  libs = [ dlprefix*"ruby"*v, dlprefix*"ruby" ]
+  lib = rbconfig_expand(ruby, "\$(LIBRUBY_SO)")
+  lib != nothing && unshift!(libs, splitext(lib)[1])
+  libs = unique(libs)
+
+  libpaths = [ rbconfig_expand(ruby, "\$(libdir)") ]
+  ruby_path = rbexpr(ruby, "RbConfig.ruby")
+  if ruby_path != nothing
+    if is_windows()
+      push!(libpaths, dirname(ruby_path))
+    else
+      push!(libpaths, joinpath(dirname(dirname(ruby_path)), "lib"))
+    end
+  end
+  if is_apple()
+    # TODO: The framework directory of the system ruby should be added in libpaths
+  end
+
+  exec_prefix = rbconfig(ruby, "exec_prefix")
+  push!(libpaths, exec_prefix)
+  push!(libpaths, joinpath(exec_prefix, "lib"))
+
+  error_strings = Compat.String[]
+
+  # find libruby
+  for lib in libs
+    for libpath in libpaths
+      libpath_lib = joinpath(libpath, lib)
+      if isfile(libpath_lib*"."*Libdl.dlext)
+        try
+          return (Libdl.dlopen(libpath_lib,
+                               Libdl.RTLD_LAZY | Libdl.RTLD_DEEPBIND | Libdl.RTLD_GLOBAL),
+                  libpath_lib)
+        catch e
+          push!(error_strings, string("dlopen($libpath_lib) ==> ", e))
+        end
+      end
+    end
+  end
+
+  # find libruby from the system library path
+  for lib in libs
+    lib = splitext(lib)[1]
+    try
+      return (Libdl.dlopen(lib, Libdl.RTLD_LAZY | Libdl.RTLD_DEEPBIND | Libdl.RTLD_GLOBAL),
+              lib)
+    catch e
+      push!(error_strings, string("dlopen($lib) ==> ", e))
+    end
+  end
+end
+
+const ruby = "ruby"
+
+const (libruby_handle, libruby) = find_library(ruby)
+const programname = rbexpr(ruby, "RbConfig.ruby")
+const ruby_version = convert(VersionNumber, rbexpr(ruby, "RUBY_VERSION"))

data/lib/julia/ruby.jl

@@ -0,0 +1,168 @@
+module Ruby
+
+using Compat
+
+# startup
+# =======
+
+hassym(lib, sym) = Libdl.dlsym_e(lib, sym) != C_NULL
+
+function rbexpr(ruby::AbstractString, var::AbstractString)
+  val = chomp(readstring(`$ruby -rrbconfig -e "puts $var"`))
+  if val == ""
+    return nothing
+  end
+  return val
+end
+
+function rbexpr(ruby, var, default)
+  val = rbexpr(ruby, var)
+  return val == nothing ? default : val
+end
+
+function rbconfig(ruby::AbstractString, key::AbstractString)
+  return rbexpr(ruby, "RbConfig::CONFIG['$key']")
+end
+
+function rbconfig_expand(ruby::AbstractString, make_expr::AbstractString)
+  return rbexpr(ruby, "RbConfig.expand('$make_expr')")
+end
+
+const dlprefix = is_windows() ? "" : "lib"
+
+immutable Dl_info
+    dli_fname::Ptr{UInt8}
+    dli_fbase::Ptr{Void}
+    dli_sname::Ptr{UInt8}
+    dli_saddr::Ptr{Void}
+end
+
+proc_handle = unsafe_load(@static is_windows() ?
+                          cglobal(:jl_exe_handle, Ptr{Void}) :
+                          cglobal(:jl_dl_handle, Ptr{Void}))
+
+symbols_present = false
+@static if is_windows()
+    EnumProcessModules(hProcess, lphModule, cb, lpcbNeeded) =
+        ccall(:K32EnumProcessModules, stdcall, Bool,
+              (Ptr{Void}, Ptr{Ptr{Void}}, UInt32, Ptr{UInt32}),
+              hProcess, lphModule, cb, lpcbNeeded)
+
+    lpcbNeeded = Ref{UInt32}()
+    handles = Vector{Ptr{Void}}(20)
+    if EnumProcessModules(proc_handle, handles, sizeof(handles), lpcbNeeded) == 0
+        resize!(handles, div(lpcbNeeded[], sizeof(Ptr{Void})))
+        EnumProcessModules(proc_handle, handles, sizeof(handles), lpcbNeeded)
+    end
+    # Try to find ruby if it's in the current process
+    for handle in handles
+        sym = ccall(:GetProcAddress, stdcall, Ptr{Void},
+                    (Ptr{Void}, Ptr{UInt8}), handle, "rb_sysinit")
+        sym != C_NULL || continue
+        symbols_present = true
+        global libruby_handle = handle
+        break
+    end
+else
+    symbols_present = hassym(proc_handle, :rb_sysinit)
+end
+
+if !symbols_present
+    # Ruby not present.  Load libruby here.
+    include(joinpath(dirname(@__FILE__), "load_libruby.jl"))
+else
+    @static if is_windows()
+        pathbuf = Vector{UInt16}(1024)
+        ret = ccall(:GetModuleFileNameW, stdcall, UInt32,
+                    (Ptr{Void}, Ptr{UInt16}, UInt32),
+                    libruby_handle, pathbuf, length(pathbuf))
+        @assert ret != 0
+        libname = String(Base.transcode(UInt8, pathbuf[1:findfirst(pathbuf, 0)-1]))
+    else
+        libruby_handle = proc_handle
+        # Now determine the name of the ruby library that these symbols are from
+        some_address_in_libruby = Libdl.dlsym(libruby_handle, :rb_sysinit)
+        dlinfo = Ref{Dl_info}()
+        ccall(:dladdr, Cint, (Ptr{Void}, Ptr{Dl_info}), some_address_in_libruby, dlinfo)
+        libname = unsafe_string(dlinfo[].dli_fname)
+    end
+    if Libdl.dlopen_e(libname) != C_NULL
+        const libruby = libname
+    else
+        const libruby = nothing
+    end
+end
+
+if libruby == nothing
+    macro rbsym(func)
+        :($func)
+    end
+    macro rbglobal(name)
+        :(cglobal($name))
+    end
+else
+    macro rbsym(func)
+        :(($func, libruby))
+    end
+    macro rbglobal(name)
+        :(cglobal(($name, libruby)))
+    end
+end
+
+@static if sizeof(Clong) == sizeof(Ptr{Void})
+    typealias VALUE Culong
+    typealias ID Culong
+    typealias SIGNED_VALUE Clong
+else
+    @static if sizeof(Clonglong) == sizeof(Ptr{Void})
+        typealias VALUE Culonglong
+        typealias ID Culonglong
+        typealias SIGNED_VALUE Clonglong
+    else
+        error("shouldn't be reached here")
+    end
+end
+
+# definitions
+# -----------
+
+# special constants - i.e. non-zero and non-fixnum constants
+
+# NOTE: Ruby.jl assumes ruby was built with flonum support.
+
+const Qfalse = VALUE(0x00)          # ...0000 0000
+const Qtrue  = VALUE(0x14)          # ...0001 0100
+const Qnil   = VALUE(0x08)          # ...0000 1000
+const Qundef = VALUE(0x34)          # ...0011 0100
+
+const IMMEDIATE_MASK = VALUE(0x07)
+const FIXNUM_FLAG    = VALUE(0x01)  # ...xxxx xxx1
+const FLONUM_MASK    = VALUE(0x03)
+const FLONUM_FLAG    = VALUE(0x02)  # ...xxxx xx10
+const SYMBOL_FLAG    = VALUE(0x0c)  # ...0000 1100
+
+const SPECIAL_SHIFT  = VALUE(8)
+
+const FIXNUM_MAX = typemax(Clong) >> 1
+const FIXNUM_MIN = typemin(Clong) >> 1
+
+LONG2FIX(i::Clong) = ((VALUE(i) << 1) | FIXNUM_FLAG)
+
+FIX2LONG(x::VALUE) = Clong(SIGNED_VALUE(x) >> 1)
+FIX2ULONG(x::VALUE) = Culong(FIX2LONG(x))
+FIXNUM_P(f::SIGNED_VALUE) = (f & FIXNUM_FLAG) != 0
+POSFIXABLE(f::Integer) = f < FIXNUM_MAX + 1
+NEGFIXABLE(f::Integer) = f >= FIXNUM_MIN
+FIXABLE(f::Integer) = POSFIXABLE(f) && NEGFIXABLE(f)
+
+# initialize
+# ----------
+
+function __init__()
+    already_initialized = 0 != unsafe_load(Ptr{VALUE}(@rbglobal(:rb_cObject)))
+    if !already_initialized
+        ccall((@rbsym :ruby_init), Void, ())
+    end
+end
+
+end # module Ruby

data/lib/julia/version.rb

@@ -1,3 +1,3 @@
 module Julia
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: julia
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Kenta Murata
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-07-13 00:00:00.000000000 Z
+date: 2018-08-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -24,6 +24,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -38,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -56,8 +98,7 @@ description: Julia on Ruby
 email:
 - mrkn@cookpad.com
 executables: []
-extensions:
-- ext/julia/extconf.rb
+extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
@@ -72,7 +113,17 @@ files:
 - examples/pkg_status.rb
 - ext/julia/extconf.rb
 - ext/julia/julia.c
+- ext/julia/julia_internal.h
+- ext/julia/libjulia.c
 - julia.gemspec
+- lib/julia.rb
+- lib/julia/error.rb
+- lib/julia/init.rb
+- lib/julia/libjulia.rb
+- lib/julia/libjulia/finder.rb
+- lib/julia/libjulia/investigator.jl
+- lib/julia/load_libruby.jl
+- lib/julia/ruby.jl
 - lib/julia/version.rb
 homepage: https://github.com/mrkn/ruby-julia
 licenses:
@@ -94,9 +145,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: Julia on Ruby
 test_files: []
-has_rdoc: