rice 4.3.3 → 4.5.0

data/rice/global_function.hpp

@@ -1,8 +1,6 @@
 #ifndef Rice__global_function__hpp_
 #define Rice__global_function__hpp_
 
-#include "Arg.hpp"
-
 namespace Rice
 {
    //! Define an global function
@@ -20,6 +18,4 @@ namespace Rice
   void define_global_function(char const * name, Function_T&& func, Arg_Ts const& ...args);
 } // Rice
 
-#include "global_function.ipp"
-
 #endif // Rice__global_function__hpp_

data/rice/global_function.ipp

@@ -1,7 +1,6 @@
-#include "cpp_api/Module.hpp"
 
 template<typename Function_T, typename...Arg_Ts>
 void Rice::define_global_function(char const * name, Function_T&& func, Arg_Ts const& ...args)
 {
-  Module(rb_mKernel).define_module_function(name, std::forward<Function_T>(func), args...);
+    Module(rb_mKernel).define_module_function(name, std::forward<Function_T>(func), args...);
 }

data/rice/rice.hpp

@@ -1,64 +1,147 @@
 #ifndef Rice__hpp_
 #define Rice__hpp_
 
-// Traits
+// Ruby
 #include "detail/ruby.hpp"
+
+// C++ headers -h has to come after Ruby on MacOS for reasons I do not understand
+#include <cstdio>
+#include <string>
+#include <typeinfo>
+#include <typeindex>
+
+#ifdef _MSC_VER
+  // Prevent _strdup deprecated message on MSVC
+  #define strdup _strdup 
+#endif
+
+// Traits
 #include "traits/rice_traits.hpp"
 #include "traits/function_traits.hpp"
 #include "traits/method_traits.hpp"
 #include "traits/attribute_traits.hpp"
 
+// Helpers
+#include "detail/TupleIterator.hpp"
+
 // Code for C++ to call Ruby
-#include "Exception_defn.hpp"
-#include "detail/Jump_Tag.hpp"
+#include "Exception.hpp"
+#include "JumpException.hpp"
+#include "JumpException.ipp"
 #include "detail/RubyFunction.hpp"
+#include "detail/RubyFunction.ipp"
 
-// Code for Ruby to call C++
-#include "detail/ExceptionHandler.hpp"
+// C++ API declarations
 #include "detail/Type.hpp"
+#include "cpp_api/Encoding.hpp"
+#include "cpp_api/Identifier.hpp"
+#include "cpp_api/Identifier.ipp"
+#include "cpp_api/Object.hpp"
+#include "cpp_api/Builtin_Object.hpp"
+#include "cpp_api/String.hpp"
+#include "cpp_api/Symbol.hpp"
+#include "cpp_api/Array.hpp"
+#include "cpp_api/Hash.hpp"
+
+// Type Conversion declarations
+#include "detail/RubyType.hpp"
+#include "detail/RubyType.ipp"
+#include "detail/Wrapper.hpp"
+#include "detail/to_ruby.hpp"
+#include "detail/from_ruby.hpp"
+#include "detail/Native.hpp"
+
+// Registries
 #include "detail/TypeRegistry.hpp"
 #include "detail/InstanceRegistry.hpp"
+#include "detail/DefaultHandler.hpp"
 #include "detail/HandlerRegistry.hpp"
 #include "detail/NativeRegistry.hpp"
 #include "detail/Registries.hpp"
-#include "detail/cpp_protect.hpp"
-#include "detail/Wrapper.hpp"
-#include "Return.hpp"
+
+// To / From Ruby
 #include "Arg.hpp"
-#include "detail/MethodInfo.hpp"
-#include "detail/from_ruby.hpp"
-#include "detail/to_ruby.hpp"
-#include "Identifier.hpp"
+#include "Arg.ipp"
+#include "Return.hpp"
+#include "Return.ipp"
+#include "detail/to_ruby.ipp"
+#include "detail/from_ruby.ipp"
+#include "detail/Proc.hpp"
+
+// Registries
+#include "detail/TypeRegistry.ipp"
+#include "detail/InstanceRegistry.ipp"
+#include "detail/DefaultHandler.ipp"
+#include "detail/HandlerRegistry.ipp"
+#include "detail/NativeRegistry.ipp"
+#include "detail/Registries.ipp"
+
+#include "detail/Type.ipp"
+
+// Code for Ruby to call C++
 #include "Exception.ipp"
-#include "detail/NativeAttribute.hpp"
+#include "detail/cpp_protect.hpp"
+#include "detail/Wrapper.ipp"
+#include "detail/MethodInfo.hpp"
+#include "detail/MethodInfo.ipp"
+#include "detail/Native.ipp"
+#include "detail/NativeAttributeGet.hpp"
+#include "detail/NativeAttributeGet.ipp"
+#include "detail/NativeAttributeSet.hpp"
+#include "detail/NativeAttributeSet.ipp"
 #include "detail/NativeFunction.hpp"
+#include "detail/NativeFunction.ipp"
 #include "detail/NativeIterator.hpp"
-#include "HandlerRegistration.hpp"
+#include "detail/NativeIterator.ipp"
+#include "detail/NativeCallbackFFI.hpp"
+#include "detail/NativeCallbackFFI.ipp"
+#include "detail/NativeCallbackSimple.hpp"
+#include "detail/NativeCallbackSimple.ipp"
+#include "detail/Proc.ipp"
+
+// C++ API definitions
+#include "cpp_api/Encoding.ipp"
+#include "cpp_api/Object.ipp"
+#include "cpp_api/Builtin_Object.ipp"
+#include "cpp_api/String.ipp"
+#include "cpp_api/Array.ipp"
+#include "cpp_api/Hash.ipp"
+#include "cpp_api/Symbol.ipp"
 
-// C++ classes for using the Ruby API
-#include "cpp_api/Object.hpp"
-#include "cpp_api/Builtin_Object.hpp"
-#include "cpp_api/String.hpp"
-#include "cpp_api/Array.hpp"
-#include "cpp_api/Hash.hpp"
-#include "cpp_api/Symbol.hpp"
 #include "cpp_api/Module.hpp"
+#include "cpp_api/Module.ipp"
 #include "cpp_api/Class.hpp"
+#include "cpp_api/Class.ipp"
 #include "cpp_api/Struct.hpp"
+#include "cpp_api/Struct.ipp"
+
 #include "Address_Registration_Guard.hpp"
+#include "Address_Registration_Guard.ipp"
 #include "global_function.hpp"
+#include "global_function.ipp"
 
-// Code involed in creating custom DataTypes (ie, Ruby classes that wrap C++ classes)
+// Code involved in creating custom DataTypes (ie, Ruby classes that wrap C++ classes)
 #include "ruby_mark.hpp"
 #include "detail/default_allocation_func.hpp"
 #include "Director.hpp"
 #include "Data_Type.hpp"
+#include "Data_Type.ipp"
 #include "detail/default_allocation_func.ipp"
 #include "Constructor.hpp"
+#include "Constructor.ipp"
+#include "Callback.hpp"
+#include "Callback.ipp"
 #include "Data_Object.hpp"
+#include "Data_Object.ipp"
 #include "Enum.hpp"
+#include "Enum.ipp"
+#include "MemoryView.hpp"
+#include "MemoryView.ipp"
 
 // Dependent on Module, Class, Array and String
 #include "forward_declares.ipp"
 
+// For now include libc support - maybe should be separate header file someday
+#include "libc/file.hpp"
+
 #endif // Rice__hpp_

data/rice/ruby_mark.hpp

@@ -1,5 +1,5 @@
-#ifndef ruby_mark__hpp
-#define ruby_mark__hpp
+#ifndef Rice__ruby_mark__hpp_
+#define Rice__ruby_mark__hpp_
 
 //! Default function to call to mark a data object.
 /*! This function can be specialized for a particular type to override
@@ -12,4 +12,5 @@ namespace Rice
   {
   }
 }
-#endif // ruby_mark__hpp
+#endif // Rice__ruby_mark__hpp_
+

data/rice/stl.hpp

@@ -1,6 +1,8 @@
 #ifndef Rice__stl__hpp_
 #define Rice__stl__hpp_
 
+#include "stl/exception.hpp"
+#include "stl/exception_ptr.hpp"
 #include "stl/string.hpp"
 #include "stl/string_view.hpp"
 #include "stl/complex.hpp"
@@ -8,6 +10,8 @@
 #include "stl/reference_wrapper.hpp"
 #include "stl/smart_ptr.hpp"
 #include "stl/monostate.hpp"
+#include "stl/type_index.hpp"
+#include "stl/type_info.hpp"
 #include "stl/variant.hpp"
 #include "stl/pair.hpp"
 #include "stl/map.hpp"

data/test/embed_ruby.cpp

@@ -7,15 +7,18 @@ void embed_ruby()
 
   if (!initialized__)
   {
+    RUBY_INIT_STACK;
+
     int argc = 0;
     char* argv = nullptr;
     char** pArgv = &argv;
 
     ruby_sysinit(&argc, &pArgv);
+
     ruby_init();
     ruby_init_loadpath();
 
-#if RUBY_API_VERSION_MAJOR == 3 && RUBY_API_VERSION_MINOR >= 3
+#if RUBY_API_VERSION_MAJOR == 3 && RUBY_API_VERSION_MINOR >= 1
     // Force the prelude / builtins
     const char* opts[] = { "ruby", "-e;" };
     ruby_options(2, (char**)opts);

data/test/extconf.rb

@@ -2,6 +2,8 @@ require 'bundler/setup'
 require 'mkmf-rice'
 require 'rbconfig'
 
+abort "libffi not found" unless have_libffi
+
 # Totally hack mkmf to make a unittest executable instead of a shared library
 target_exe = "unittest#{RbConfig::CONFIG['EXEEXT']}"
 $cleanfiles << target_exe

data/test/ruby/test_multiple_extensions_same_class.rb

@@ -1,14 +1,14 @@
-$: << File.join(__dir__, '..', 'ext')
-
-require 'minitest'
-require 'minitest/autorun'
-
-class MultipleExtensionsSameClassTest < Minitest::Test
-  def test_multiple_extensions_same_class
-    require 't1/t1'
-    require 't2/t2'
-
-    foo = Foo.new
-    assert_equal 42, foo.foo
-  end
-end
+$: << File.join(__dir__, '..', 'ext')
+
+require 'minitest'
+require 'minitest/autorun'
+
+class MultipleExtensionsSameClassTest < Minitest::Test
+  def test_multiple_extensions_same_class
+    require 't1/t1'
+    require 't2/t2'
+
+    foo = Foo.new
+    assert_equal 42, foo.foo
+  end
+end

data/test/test_Address_Registration_Guard.cpp

@@ -11,6 +11,11 @@ SETUP(Address_Registration_Guard)
   embed_ruby();
 }
 
+TEARDOWN(Address_Registration_Guard)
+{
+  rb_gc_start();
+}
+
 TESTCASE(register_address)
 {
   VALUE v = Qnil;

data/test/test_Array.cpp

@@ -24,13 +24,24 @@ SETUP(Array)
   embed_ruby();
 }
 
-TESTCASE(default_construct)
+TEARDOWN(Array)
+{
+  rb_gc_start();
+}
+
+TESTCASE(construct_default)
 {
   Array a;
   ASSERT_EQUAL(T_ARRAY, rb_type(a));
   ASSERT_EQUAL(0, RARRAY_LEN(a.value()));
 }
 
+TESTCASE(construct_capacity)
+{
+  Array a((long)10);
+  ASSERT_EQUAL(0, RARRAY_LEN(a.value()));
+}
+
 TESTCASE(construct_from_vector_of_int)
 {
   std::vector<int> v;

data/test/test_Attribute.cpp

@@ -14,12 +14,23 @@ SETUP(Attribute)
   embed_ruby();
 }
 
+TEARDOWN(Attribute)
+{
+  Rice::detail::Registries::instance.types.clearUnverifiedTypes();
+  rb_gc_start();
+}
+
 namespace
 {
   class SomeClass
   {
   };
 
+  class NotAssignable
+  {
+    NotAssignable& operator=(const NotAssignable&) = delete;
+  };
+
   struct DataStruct
   {
     static inline float staticFloat = 1.0;
@@ -29,7 +40,9 @@ namespace
     std::string readWriteString = "Read Write";
     int writeInt = 0;
     const char* readChars = "Read some chars!";
+    const int constInt = 5;
     SomeClass someClass;
+    NotAssignable notAssignable;
 
     std::string inspect()
     {
@@ -57,21 +70,28 @@ TESTCASE(attributes)
   // Test readonly attribute
   Object result = o.call("read_chars");
   ASSERT_EQUAL("Read some chars!", detail::From_Ruby<char*>().convert(result));
-  ASSERT_EXCEPTION_CHECK(
-    Exception,
-    o.call("read_char=", "some text"),
-    ASSERT(std::string(ex.what()).find("undefined method `read_char='") == 0)
-  );
 
+  if constexpr (!oldRuby)
+  {
+    ASSERT_EXCEPTION_CHECK(
+      Exception,
+      o.call("read_char=", "some text"),
+      ASSERT(std::string(ex.what()).find("undefined method `read_char='") == 0)
+    );
+  }
   // Test writeonly attribute
   result = o.call("write_int=", 5);
   ASSERT_EQUAL(5, detail::From_Ruby<int>().convert(result.value()));
   ASSERT_EQUAL(5, dataStruct->writeInt);
-  ASSERT_EXCEPTION_CHECK(
-    Exception,
-    o.call("write_int", 3),
-    ASSERT(std::string(ex.what()).find("undefined method `write_int'") == 0)
-  );
+
+  if constexpr (!oldRuby)
+  {
+    ASSERT_EXCEPTION_CHECK(
+      Exception,
+      o.call("write_int", 3),
+      ASSERT(std::string(ex.what()).find("undefined method `write_int'") == 0)
+    );
+  }
 
   // Test readwrite attribute
   result = o.call("read_write_string=", "Set a string");
@@ -82,6 +102,48 @@ TESTCASE(attributes)
   ASSERT_EQUAL("Set a string", detail::From_Ruby<std::string>().convert(result.value()));
 }
 
+TESTCASE(const_attribute)
+{
+  Class c = define_class<DataStruct>("DataStruct")
+    .define_constructor(Constructor<DataStruct>())
+    .define_attr("const_int", &DataStruct::constInt);
+
+  Data_Object<DataStruct> o = c.call("new");
+  const DataStruct* dataStruct = o.get();
+
+  if constexpr (!oldRuby)
+  {
+    ASSERT_EXCEPTION_CHECK(
+      Exception,
+      o.call("const_int=", 5),
+      ASSERT(std::string(ex.what()).find("undefined method `const_int='") == 0)
+    );
+  }
+}
+
+TESTCASE(not_copyable_attribute)
+{
+  Class notAssignableClass = define_class<NotAssignable>("NotAssignable")
+    .define_constructor(Constructor<NotAssignable>());
+    
+  Class c = define_class<DataStruct>("DataStruct")
+    .define_constructor(Constructor<DataStruct>())
+    .define_attr("not_assignable", &DataStruct::notAssignable);
+
+  Data_Object<NotAssignable> notAssignable = notAssignableClass.call("new");
+
+  Data_Object<DataStruct> o = c.call("new");
+  
+  if constexpr (!oldRuby)
+  {
+    ASSERT_EXCEPTION_CHECK(
+      Exception,
+      o.call("not_assignable=", notAssignable),
+      ASSERT(std::string(ex.what()).find("undefined method `not_assignable='") == 0)
+    );
+  }
+}
+
 TESTCASE(static_attributes)
 {
   Class c = define_class<DataStruct>("DataStruct")
@@ -98,11 +160,15 @@ TESTCASE(static_attributes)
 
   result = c.call("static_string");
   ASSERT_EQUAL("Static string", detail::From_Ruby<std::string>().convert(result.value()));
-  ASSERT_EXCEPTION_CHECK(
-    Exception,
-    c.call("static_string=", true),
-    ASSERT(std::string(ex.what()).find("undefined method `static_string='") == 0)
-  );
+
+  if constexpr (!oldRuby)
+  {
+    ASSERT_EXCEPTION_CHECK(
+      Exception,
+      c.call("static_string=", true),
+      ASSERT(std::string(ex.what()).find("undefined method `static_string='") == 0)
+    );
+  }
 }
 
 TESTCASE(global_attributes)
@@ -128,20 +194,36 @@ TESTCASE(not_defined)
   Data_Type<DataStruct> c = define_class<DataStruct>("DataStruct");
 
 #ifdef _MSC_VER
-  const char* message = "Type is not defined with Rice: class `anonymous namespace'::SomeClass";
+  const char* message = "The following types are not registered with Rice:\n  class `anonymous namespace'::SomeClass\n";
 #else
-  const char* message = "Type is not defined with Rice: (anonymous namespace)::SomeClass";
+  const char* message = "The following types are not registered with Rice:\n  (anonymous namespace)::SomeClass\n";
 #endif
 
+  c.define_singleton_attr("some_class_static", &DataStruct::someClassStatic);
+
   ASSERT_EXCEPTION_CHECK(
     std::invalid_argument,
-    c.define_singleton_attr("some_class_static", &DataStruct::someClassStatic),
+    Rice::detail::Registries::instance.types.validateTypes(),
     ASSERT_EQUAL(message, ex.what())
   );
 
+#ifdef _MSC_VER
+  message = "Type is not registered with Rice: class `anonymous namespace'::SomeClass";
+#else
+  message = "Type is not registered with Rice: (anonymous namespace)::SomeClass";
+#endif
+
   ASSERT_EXCEPTION_CHECK(
-    std::invalid_argument,
-    c.define_attr("some_class", &DataStruct::someClass),
+    Rice::Exception,
+    c.call("some_class_static"),
     ASSERT_EQUAL(message, ex.what())
   );
-}
+
+  c.define_attr("some_class", &DataStruct::someClass);
+  Object o = c.call("new");
+  ASSERT_EXCEPTION_CHECK(
+    Rice::Exception,
+    o.call("some_class"),
+    ASSERT_EQUAL(message, ex.what())
+  );
+}

data/test/test_Builtin_Object.cpp

@@ -11,6 +11,11 @@ SETUP(Builtin_Object)
   embed_ruby();
 }
 
+TEARDOWN(Builtin_Object)
+{
+  rb_gc_start();
+}
+
 TESTCASE(construct_with_object)
 {
   Class c(rb_cObject);