[DRAFT] Support for TruffleRuby/GraalVM

.gitignore

@@ -7,6 +7,7 @@
 /pkg/
 /spec/reports/
 /tmp/
+vendor/
 
 __pycache__/
 .ipynb_checkpoints/

Rakefile

@@ -8,16 +8,21 @@ require "rspec/core/rake_task"
 Dir[File.expand_path('../tasks/**/*.rake', __FILE__)].each {|f| load f }
 
 gem_spec = eval(File.read('pycall.gemspec'))
-Rake::ExtensionTask.new('pycall', gem_spec) do |ext|
-  ext.lib_dir = File.join(*['lib', ENV['FAT_DIR']].compact)
-  ext.cross_compile = true
-  ext.cross_platform = %w[x86-mingw32 x64-mingw32]
-  ext.cross_compiling do |s|
-    s.files.concat %w[lib/2.2/pycall.so lib/2.3/pycall.so lib/2.4/pycall.so]
+
+if RUBY_ENGINE != "truffleruby"
+  Rake::ExtensionTask.new('pycall', gem_spec) do |ext|
+    ext.lib_dir = File.join(*['lib', ENV['FAT_DIR']].compact)
+    ext.cross_compile = true
+    ext.cross_platform = %w[x86-mingw32 x64-mingw32]
+    ext.cross_compiling do |s|
+      s.files.concat %w[lib/2.2/pycall.so lib/2.3/pycall.so lib/2.4/pycall.so]
+    end
   end
 end
 
-Rake::ExtensionTask.new('pycall/spec_helper')
+if RUBY_ENGINE != "truffleruby"
+  Rake::ExtensionTask.new('pycall/spec_helper')
+end
 
 desc "Compile binaries for mingw platform using rake-compiler-dock"
 task 'build:mingw' do
@@ -28,4 +33,7 @@ end
 RSpec::Core::RakeTask.new(:spec)
 
 task :default => :spec
-task spec: :compile
+if RUBY_ENGINE != "truffleruby"
+  task spec: :compile
+end
+

ext/pycall/extconf.rb

@@ -1,3 +1,16 @@
+# Building with TruffleRuby does not work / is not required
+# Seems like putting out an empty Makefile is the best solution to skip build
+# https://stackoverflow.com/questions/17406246/native-extensions-fallback-to-pure-ruby-if-not-supported-on-gem-install/50886432
+
+if RUBY_ENGINE == "truffleruby"
+  mfile = open("Makefile", "wb")
+  mfile.puts '.PHONY: install'
+  mfile.puts 'install:'
+  mfile.puts "\t" + '@echo "You are using Truffleruby, therefore skipping build of native extension"'
+  mfile.close
+  exit 0
+end
+
 require 'mkmf'
 
 create_makefile('pycall')

lib/pycall.rb

@@ -1,114 +1,5 @@
-module PyCall
-  require 'pycall/version'
-  require 'pycall/libpython'
-  require 'pycall/pyerror'
-  require 'pycall/pyobject_wrapper'
-  require 'pycall/pytypeobject_wrapper'
-  require 'pycall/pymodule_wrapper'
-  require 'pycall/init'
-
-  module_function
-
-  def builtins
-    @builtins ||= wrap_module(LibPython::API.builtins_module_ptr)
-  end
-
-  def callable?(obj)
-    case obj
-    when PyObjectWrapper
-      builtins.callable(obj.__pyptr__)
-    when PyPtr
-      builtins.callable(obj)
-    else
-      raise TypeError, "unexpected argument type #{obj.class} (expected PyCall::PyPtr or its wrapper)"
-    end
-  end
-
-  def dir(obj)
-    case obj
-    when PyObjectWrapper
-      builtins.dir(obj.__pyptr__)
-    when PyPtr
-      builtins.dir(obj)
-    else
-      raise TypeError, "unexpected argument type #{obj.class} (expected PyCall::PyPtr or its wrapper)"
-    end
-  end
-
-  def eval(expr, globals: nil, locals: nil)
-    globals ||= import_module(:__main__).__dict__
-    builtins.eval(expr, globals, locals)
-  end
-
-  def exec(code, globals: nil, locals: nil)
-    globals ||= import_module(:__main__).__dict__
-    if PYTHON_VERSION >= '3'
-      builtins.exec(code, globals, locals)
-    else
-      import_module('PyCall.six').exec_(code, globals, locals)
-    end
-  end
-
-  def getattr(*args)
-    obj, *rest = args
-    LibPython::Helpers.getattr(obj.__pyptr__, *rest)
-  end
-
-  def hasattr?(obj, name)
-    LibPython::Helpers.hasattr?(obj.__pyptr__, name)
-  end
-
-  def same?(left, right)
-    case left
-    when PyObjectWrapper
-      case right
-      when PyObjectWrapper
-        return left.__pyptr__ == right.__pyptr__
-      end
-    end
-    false
-  end
-
-  def import_module(name)
-    LibPython::Helpers.import_module(name)
-  end
-
-  def len(obj)
-    case obj
-    when PyObjectWrapper
-      builtins.len(obj.__pyptr__)
-    when PyPtr
-      builtins.len(obj)
-    else
-      raise TypeError, "unexpected argument type #{obj.class} (expected PyCall::PyPtr or its wrapper)"
-    end
-  end
-
-  def sys
-    @sys ||= import_module('sys')
-  end
-
-  def tuple(iterable=nil)
-    pyptr = if iterable
-              builtins.tuple.(iterable)
-            else
-              builtins.tuple.()
-            end
-    Tuple.wrap_pyptr(pyptr)
-  end
-
-  def with(ctx)
-    begin
-      yield ctx.__enter__
-    rescue PyError => err
-      raise err unless ctx.__exit__(err.type, err.value, err.traceback)
-    rescue Exception => err
-      # TODO: support telling what exception has been catched
-      raise err unless ctx.__exit__(err.class, err, err.backtrace_locations)
-    else
-      ctx.__exit__(nil, nil, nil)
-    end
-  end
-end
-
-require 'pycall/iruby_helper' if defined? IRuby
+if RUBY_ENGINE == "truffleruby"
+  require 'pycall/truffleruby/pycall'
+else
+  require 'pycall/pycall'
+end

lib/pycall/import.rb

@@ -1,120 +1,7 @@
 require 'pycall'
 
-module PyCall
-  module Import
-    class << self
-      attr_reader :main_object
-    end
-  end
-end
-
-PyCall::Import.instance_variable_set(:@main_object, self)
-
-module PyCall
-  module Import
-    def pyimport(mod_name, as: nil)
-      as = mod_name unless as
-      check_valid_module_variable_name(mod_name, as)
-      mod = PyCall.import_module(mod_name)
-      define_singleton_method(as) { mod }
-    end
-
-    # This function is implemented as a mimic of `import_from` function defined in `Python/ceval.c`.
-    def pyfrom(mod_name, import: nil)
-      raise ArgumentError, "missing identifier(s) to be imported" unless import
-
-      mod_name = mod_name.to_str if mod_name.respond_to? :to_str
-      mod_name = mod_name.to_s if mod_name.is_a? Symbol
-
-      import = Array(import)
-      fromlist = import.map.with_index do |import_name, i|
-        case import_name
-        when assoc_array_matcher
-          import_name[0]
-        when Symbol, String
-          import_name
-        else
-          raise ArgumentError, "wrong type of import name #{import_name.class} (expected String or Symbol)"
-        end
-      end
-      from_list = PyCall.tuple(from_list)
-
-      main_dict_ptr = PyCall.import_module('__main__').__dict__.__pyptr__
-      globals = main_dict_ptr # FIXME: this should mimic to `import_name` function defined in `Python/ceval.c`.
-      locals = main_dict_ptr # FIXME: this should mimic to `import_name` function defined in `Python/ceval.c`.
-      level = 0 # TODO: support prefixed dots (#25)
-      mod = LibPython::Helpers.import_module(mod_name, globals, locals, fromlist, level)
-
-      import.each do |import_name|
-        case import_name
-        when assoc_array_matcher
-          name, asname = *import_name
-        when Symbol, String
-          name, asname = import_name, import_name
-        end
-
-        if PyCall::LibPython::Helpers.hasattr?(mod.__pyptr__, name)
-          pyobj = PyCall::LibPython::Helpers.getattr(mod.__pyptr__, name)
-          define_name(asname, pyobj)
-          next
-        end
-
-        if mod.respond_to? :__name__
-          pkgname = mod.__name__
-          fullname = "#{pkgname}.#{name}"
-          sys_modules = PyCall.import_module('sys').modules
-          if sys_modules.has_key?(fullname)
-            pyobj = module_dict[fullname]
-            define_name(asname, pyobj)
-            next
-          end
-        end
-
-        raise ArgumentError, "cannot import name #{fullname}" unless pyobj
-      end
-    end
-
-    private
-
-    def define_name(name, pyobj)
-      if callable?(pyobj) && !type_object?(pyobj)
-        define_singleton_method(name) do |*args|
-          LibPython::Helpers.call_object(pyobj.__pyptr__, *args)
-        end
-      else
-        if constant_name?(name)
-          context = self
-          context = (self == PyCall::Import.main_object) ? Object : self
-          context.module_eval { const_set(name, pyobj) }
-        else
-          define_singleton_method(name) { pyobj }
-        end
-      end
-    end
-
-    def constant_name?(name)
-      name =~ /\A[A-Z]/
-    end
-
-    def check_valid_module_variable_name(mod_name, var_name)
-      var_name = var_name.to_s if var_name.kind_of? Symbol
-      if var_name.include?('.')
-        raise ArgumentError, "#{var_name} is not a valid module variable name, use pyimport #{mod_name}, as: <name>"
-      end
-    end
-
-    def assoc_array_matcher
-      @assoc_array_matcher ||= ->(ary) do
-        ary.is_a?(Array) && ary.length == 2
-      end
-    end
-
-    def callable?(pyobj)
-      LibPython::Helpers.callable?(pyobj.__pyptr__)
-    end
-
-    def type_object?(pyobj)
-      pyobj.__pyptr__.kind_of? PyTypePtr
-    end
-  end
+if RUBY_ENGINE == "truffleruby"
+  require 'pycall/truffleruby/import'
+else
+  require 'pycall/import_pycall'
 end