Merge branch 'inheritance_support_in_type_map'

Author: mrkn

README.md

@@ -17,6 +17,12 @@ Ruby to Python.
 
 pycall.rb supports Ruby version 2.3 or higher.
 
+## Supported Python versions
+
+pycall.rb supports Python version 2.7 or higher.
+
+Note that in Python 2.7 old-style class, that is defined without a super class, is not fully supported in pycall.rb.
+
 ## Installation
 
 Add this line to your application's Gemfile:

ext/pycall/libpython.c

@@ -94,6 +94,7 @@ pycall_init_libpython_api_table(VALUE libpython_handle)
   INIT_API_TABLE_ENTRY(_PyObject_New, required);
   INIT_API_TABLE_ENTRY(PyCallable_Check, required);
   INIT_API_TABLE_ENTRY(PyObject_IsInstance, required);
+  INIT_API_TABLE_ENTRY(PyObject_IsSubclass, required);
   INIT_API_TABLE_ENTRY2(PyObject_Hash._hash_t, PyObject_Hash, required);
   INIT_API_TABLE_ENTRY(PyObject_RichCompare, required);
   INIT_API_TABLE_ENTRY(PyObject_Call, required);

ext/pycall/pycall.c

@@ -452,7 +452,7 @@ get_pytypeobj_ptr(VALUE obj)
 static inline PyTypeObject*
 try_get_pytypeobj_ptr(VALUE obj)
 {
-  if (is_pycall_pytypeptr(obj)) return NULL;
+  if (!is_pycall_pytypeptr(obj)) return NULL;
   return (PyTypeObject*)DATA_PTR(obj);
 }
 
@@ -541,6 +541,20 @@ pycall_pytypeptr_eqq(VALUE obj, VALUE other)
   return Qfalse;
 }
 
+static VALUE
+pycall_pytypeptr_subclass_p(VALUE obj, VALUE other)
+{
+  PyTypeObject* pytype = get_pytypeobj_ptr(obj);
+  if (is_pycall_pyptr(other)) {
+    PyTypeObject* pytype_other = try_get_pytypeobj_ptr(other);
+    if (pytype_other) {
+      int res =  Py_API(PyObject_IsSubclass)((PyObject *)pytype, (PyObject *)pytype_other);
+      return res ? Qtrue : Qfalse;
+    }
+  }
+  return Qfalse;
+}
+
 /* ==== PyCall::LibPython::API ==== */
 
 static VALUE
@@ -1277,11 +1291,39 @@ pycall_pyobject_wrapper_check_get_pyobj_ptr(VALUE obj, PyTypeObject *pytypeobj)
 
 /* ==== PyCall::Conversion ==== */
 
+static int
+get_mapped_ancestor_class_iter(VALUE key, VALUE value, VALUE arg)
+{
+  VALUE *args = (VALUE *)arg;
+  if (RTEST(pycall_pytypeptr_subclass_p(args[0], key))) {
+    args[1] = value;
+    return ST_STOP;
+  }
+  return ST_CONTINUE;
+}
+
+static VALUE
+pycall_python_type_mapping_get_mapped_ancestor_class(VALUE pytypeptr)
+{
+  VALUE args[2];
+  args[0] = pytypeptr;
+  args[1] = Qnil;
+
+  rb_hash_foreach(python_type_mapping, get_mapped_ancestor_class_iter, (VALUE)args);
+
+  return args[1];
+}
+
 static VALUE
 pycall_python_type_mapping_get_mapped_class(VALUE pytypeptr)
 {
+  VALUE mapped;
   (void)check_get_pytypeobj_ptr(pytypeptr);
-  return rb_hash_lookup(python_type_mapping, pytypeptr);
+  mapped = rb_hash_lookup(python_type_mapping, pytypeptr);
+  if (NIL_P(mapped)) {
+    mapped = pycall_python_type_mapping_get_mapped_ancestor_class(pytypeptr);
+  }
+  return mapped;
 }
 
 static int
@@ -2179,6 +2221,7 @@ Init_pycall(void)
   rb_define_method(cPyTypePtr, "__tp_basicsize__", pycall_pytypeptr_get_tp_basicsize, 0);
   rb_define_method(cPyTypePtr, "__tp_flags__", pycall_pytypeptr_get_tp_flags, 0);
   rb_define_method(cPyTypePtr, "===", pycall_pytypeptr_eqq, 1);
+  rb_define_method(cPyTypePtr, "<", pycall_pytypeptr_subclass_p, 1);
 
   /* PyCall::LibPython::API */
 

ext/pycall/pycall_internal.h

@@ -529,6 +529,7 @@ typedef struct {
   PyObject * (* _PyObject_New)(PyTypeObject *);
   int (* PyCallable_Check)(PyObject *);
   int (* PyObject_IsInstance)(PyObject *, PyObject *);
+  int (* PyObject_IsSubclass)(PyObject *, PyObject *);
   union {
     long      (* _long)(PyObject *);
     Py_hash_t (* _hash_t)(PyObject *);

lib/pycall/conversion.rb

@@ -49,6 +49,15 @@ def ===(other)
       end
     end
 
+    def <(other)
+      case other
+      when PyTypeObjectWrapper
+        __pyptr__ < other.__pyptr__
+      else
+        raise TypeError, "compared with non class/module"
+      end
+    end
+
     private
 
     def register_python_type_mapping

lib/pycall/pytypeobject_wrapper.rb

@@ -115,6 +115,42 @@ module PyCall
         subject { Conversion.to_ruby(Conversion.from_ruby(large_string)) }
         it { is_expected.to eq(large_string) }
       end
+
+      describe 'inheritance support' do
+        let(:pymod) { PyCall.import_module('pycall.simple_class') }
+        let(:simple_class) { pymod.SimpleClass }
+        let(:simple_sub_class) { pymod.SimpleSubClass }
+
+        context 'when the super class was registered to python type mapping' do
+          before do
+            Conversion.register_python_type_mapping(simple_class.__pyptr__, simple_class)
+          end
+
+          after do
+            Conversion.unregister_python_type_mapping(simple_class.__pyptr__)
+          end
+
+          specify do
+            expect(simple_class.new).to be_instance_of(simple_class)
+            expect(simple_sub_class.new).to be_instance_of(simple_class)
+          end
+
+          context 'when the subclass was also registered to python type mapping' do
+            before do
+              Conversion.register_python_type_mapping(simple_sub_class.__pyptr__, simple_sub_class)
+            end
+
+            after do
+              Conversion.unregister_python_type_mapping(simple_sub_class.__pyptr__)
+            end
+
+            specify do
+              expect(simple_class.new).to be_instance_of(simple_class)
+              expect(simple_sub_class.new).to be_instance_of(simple_sub_class)
+            end
+          end
+        end
+      end
     end
 
     describe '.from_ruby' do