rice 4.7.1 → 4.9.0

data/test/test_Stl_UniquePtr.cpp

@@ -1,4 +1,4 @@
-#include "unittest.hpp"
+#include "unittest.hpp"
 #include "embed_ruby.hpp"
 #include <rice/rice.hpp>
 #include <rice/stl.hpp>
@@ -55,6 +55,11 @@ namespace
     {
       this->flag = value;
     }
+
+    int getFlag()
+    {
+      return this->flag;
+    }
   };
 
   class Factory
@@ -97,7 +102,8 @@ SETUP(UniquePtr)
 
   define_class<MyClass>("MyClass").
     define_constructor(Constructor<MyClass>()).
-    define_method("set_flag", &MyClass::setFlag);
+    define_method("set_flag", &MyClass::setFlag).
+    define_method("get_flag", &MyClass::getFlag);
 
   define_class<Factory>("Factory").
     define_constructor(Constructor<Factory>()).
@@ -203,8 +209,47 @@ TESTCASE(Update)
 
 TESTCASE(Klass)
 {
+  define_unique_ptr<MyClass>();
   detail::TypeMapper<std::unique_ptr<MyClass>> typeMapper;
-  Object expected = Object(rb_cObject).const_get("MyClass");
+  Module aModule("Std");
+  Object expected = aModule.const_get("UniquePtr≺AnonymousNamespace꞉꞉MyClass≻");
   VALUE actual = typeMapper.rubyKlass();
   ASSERT_EQUAL(expected.value(), actual);
+}
+
+TESTCASE(Empty)
+{
+  Module m = define_module("TestingModule");
+
+  std::string code = R"(factory = Factory.new
+                        unique_ptr = factory.transfer
+                        unique_ptr.empty?)";
+
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(Qfalse, result.value());
+}
+
+TESTCASE(Release)
+{
+  MyClass::reset();
+
+  Module m = define_module("TestingModule");
+
+  std::string code = R"(factory = Factory.new
+                        $unique_ptr = factory.transfer
+                        $unique_ptr.release)";
+
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL("MyClass", result.class_name().str());
+
+  code = R"($unique_ptr.empty?)";
+  result = m.module_eval(code);
+  ASSERT_EQUAL(Qtrue, result.value());
+
+  code = R"($unique_ptr.set_flag(8))";
+
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    m.module_eval(code),
+    ASSERT(std::string(ex.what()).find("undefined method") == 0));
 }

data/test/test_Stl_Variant.cpp

@@ -21,12 +21,6 @@ namespace
     int
   >;
 
-  inline std::ostream& operator<<(std::ostream& stream, Intrinsic_Variant_T const& variant)
-  {
-    stream << "Variant(" << "index: " << variant.index() << ")";
-    return stream;
-  }
-
   class MyClass
   {
   public:
@@ -111,7 +105,6 @@ namespace
   public:
     MyClass1()
     {
-      int a = 1;
     }
 
     std::string sayHello()
@@ -125,7 +118,6 @@ namespace
   public:
     MyClass2()
     {
-      int a = 2;
     }
 
     std::string sayHello()
@@ -207,7 +199,7 @@ TESTCASE(IntrinsicReturns)
 
   result = myClass.call("variant_vector");
   std::vector<int> converted = detail::From_Ruby<std::vector<int>>().convert(result);
-  ASSERT_EQUAL(3, converted.size());
+  ASSERT_EQUAL(3u, converted.size());
 
   result = myClass.call("variant_double");
   ASSERT_EQUAL(3.3, detail::From_Ruby<double>().convert(result));
@@ -334,9 +326,9 @@ TESTCASE(Roundtrip)
 /* This test case runs successfully on MSVC but not g++. Having stepped through the code with
   GDB, this sure seems due to a bug with g++. The issue is this variable in created operator():
 
-        Arg_Ts nativeValues = this->getNativeValues(rubyValues, indices);
+        Parameter_Ts nativeValues = this->getNativeValues(rubyValues, indices);
 
- And is then passed to invokeNativeFunction as a const Arg_Ts& nativeArgs where Arg_Ts& is
+ And is then passed to invokeNativeFunction as a const Parameter_Ts& nativeArgs where Parameter_Ts& is
  std::tuple with one element, a reference to a variant. So it doesn't change and the address
  of the variable doesn't change. But for some reason g++ resets the
  the std::variant index to 0 thus breaking the test. Maybe something to do with storing
@@ -416,19 +408,19 @@ TESTCASE(VariantWithTwoVectors)
                           my_class.variant_index(vector))";
 
   Object result = m.module_eval(code);
-  ASSERT_EQUAL(0, detail::From_Ruby<size_t>().convert(result));
+  ASSERT_EQUAL(0u, detail::From_Ruby<size_t>().convert(result));
 
   code = R"(vector = Std::Vector≺int≻.new
               vector.push_back(4)
               my_class = MyClass4.new
               my_class.variant_index(vector))";
   result = m.module_eval(code);
-  ASSERT_EQUAL(1, detail::From_Ruby<size_t>().convert(result));
+  ASSERT_EQUAL(1u, detail::From_Ruby<size_t>().convert(result));
 
   code = R"(my_class = MyClass4.new
               my_class.variant_index(["x", "y", "z"]))";
   result = m.module_eval(code);
-  ASSERT_EQUAL(0, detail::From_Ruby<size_t>().convert(result));
+  ASSERT_EQUAL(0u, detail::From_Ruby<size_t>().convert(result));
 
   code = R"(my_class = MyClass4.new
               my_class.variant_index([5, 6]))";

data/test/test_Stl_Vector.cpp

@@ -18,7 +18,7 @@ TEARDOWN(Vector)
 {
   rb_gc_start();
 }
-/*
+
 namespace
 {
   class MyClass
@@ -65,7 +65,7 @@ TESTCASE(StringVector)
   result = vec.call("last");
   ASSERT_EQUAL("four", detail::From_Ruby<std::string>().convert(result));
 }
-*/
+
 TESTCASE(StringVectorData)
 {
   Module m = define_module("Testing");
@@ -282,24 +282,24 @@ TESTCASE(Slice)
 
   Array result = vec.call("[]", 3, 1);
   std::vector<std::int32_t> slice = result.to_vector<int32_t>();
-  ASSERT_EQUAL(1, slice.size());
+  ASSERT_EQUAL(1u, slice.size());
   ASSERT_EQUAL(10, slice[0]);
 
   result = vec.call("[]", 3, 2);
   slice = result.to_vector<int32_t>();
-  ASSERT_EQUAL(2, slice.size());
+  ASSERT_EQUAL(2u, slice.size());
   ASSERT_EQUAL(10, slice[0]);
   ASSERT_EQUAL(11, slice[1]);
 
   result = vec.call("[]", 4, 10);
   slice = result.to_vector<int32_t>();
-  ASSERT_EQUAL(2, slice.size());
+  ASSERT_EQUAL(2u, slice.size());
   ASSERT_EQUAL(11, slice[0]);
   ASSERT_EQUAL(12, slice[1]);
 
   result = vec.call("[]", -1, 2);
   slice = result.to_vector<int32_t>();
-  ASSERT_EQUAL(1, slice.size());
+  ASSERT_EQUAL(1u, slice.size());
   ASSERT_EQUAL(12, slice[0]);
 }
 
@@ -528,7 +528,7 @@ TESTCASE(NotDefaultConstructable)
   ASSERT_EQUAL(Qnil, result.value());
 
   result = vec.call("length");
-  ASSERT_EQUAL(0, detail::From_Ruby<size_t>().convert(result));
+  ASSERT_EQUAL(0u, detail::From_Ruby<size_t>().convert(result));
 }
 
 TESTCASE(NotPrintable)
@@ -591,16 +591,47 @@ TESTCASE(Comparable)
 
   Object result = vec.call("delete", Comparable(1));
   Comparable comparable = detail::From_Ruby<Comparable>().convert(result);
-  ASSERT_EQUAL(1, comparable.value_);
+  ASSERT_EQUAL(1u, comparable.value_);
 
   result = vec.call("length");
-  ASSERT_EQUAL(2, detail::From_Ruby<size_t>().convert(result));
+  ASSERT_EQUAL(2u, detail::From_Ruby<size_t>().convert(result));
 
   result = vec.call("include?", Comparable(2));
   ASSERT_EQUAL(Qtrue, result.value());
 
   result = vec.call("index", Comparable(3));
-  ASSERT_EQUAL(1, detail::From_Ruby<size_t>().convert(result.value()));
+  ASSERT_EQUAL(1u, detail::From_Ruby<size_t>().convert(result.value()));
+}
+
+TESTCASE(ComparableEqual)
+{
+  define_class<Comparable>("IsComparable").
+    define_constructor(Constructor<Comparable, uint32_t>());
+
+  Comparable comparable1a(1);
+  Comparable comparable1b(1);
+  Comparable comparable2(2);
+
+  Class c = define_vector<Comparable>("ComparableVector");
+
+  Object vec1 = c.call("new");
+  Object vec2 = c.call("new");
+  Object vec3 = c.call("new");
+
+  Object result = vec1.call("eql?", vec2);
+  ASSERT_EQUAL(Qtrue, result.value());
+
+  vec1.call("push", comparable1a);
+  result = vec1.call("==", vec2);
+  ASSERT_EQUAL(Qfalse, result.value());
+
+  vec2.call("push", comparable1b);
+  result = vec1.call("==", vec2);
+  ASSERT_EQUAL(Qtrue, result.value());
+
+  vec3.call("push", comparable2);
+  result = vec1.call("==", vec3);
+  ASSERT_EQUAL(Qfalse, result.value());
 }
 
 namespace
@@ -612,7 +643,7 @@ namespace
     {
     };
 
-    std::string operator==(const ComparableButNotBool& other)
+    std::string operator==(const ComparableButNotBool&)
     {
       return "not a boolean";
     }
@@ -658,7 +689,7 @@ TESTCASE(DefaultConstructable)
   ASSERT_EQUAL(Qnil, result.value());
 
   result = vec.call("length");
-  ASSERT_EQUAL(0, detail::From_Ruby<size_t>().convert(result));
+  ASSERT_EQUAL(0u, detail::From_Ruby<size_t>().convert(result));
 }
 
 TESTCASE(Printable)
@@ -798,7 +829,7 @@ TESTCASE(ToArray)
                         vector.to_a)";
 
   Array array = m.module_eval(code);
-  ASSERT_EQUAL(3u, array.size());
+  ASSERT_EQUAL(3, array.size());
 
   ASSERT_EQUAL("abc", detail::From_Ruby<std::string>().convert(array[0].value()));
   ASSERT_EQUAL("def", detail::From_Ruby<std::string>().convert(array[1].value()));
@@ -842,17 +873,17 @@ TESTCASE(ArrayToVector)
   std::string code = "array_to_vector([7, 9, 1_000_000], [49.0, 78.0, 999.0], %w[one two three])";
   m.module_eval(code);
 
-  ASSERT_EQUAL(3, ints.size());
+  ASSERT_EQUAL(3u, ints.size());
   ASSERT_EQUAL(7, ints[0]);
   ASSERT_EQUAL(9, ints[1]);
   ASSERT_EQUAL(1'000'000, ints[2]);
 
-  ASSERT_EQUAL(3, floats.size());
+  ASSERT_EQUAL(3u, floats.size());
   ASSERT_EQUAL(49.0, floats[0]);
   ASSERT_EQUAL(78.0, floats[1]);
   ASSERT_EQUAL(999.0, floats[2]);
 
-  ASSERT_EQUAL(3, strings.size());
+  ASSERT_EQUAL(3u, strings.size());
   ASSERT_EQUAL("one", strings[0]);
   ASSERT_EQUAL("two", strings[1]);
   ASSERT_EQUAL("three", strings[2]);
@@ -867,17 +898,17 @@ TESTCASE(ArrayToVectorRefs)
   std::string code = "array_to_vector_refs([8, 10, 1_000_001], [50.0, 79.0, 1_000.0], %w[eleven twelve thirteen])";
   m.module_eval(code);
 
-  ASSERT_EQUAL(3, ints.size());
+  ASSERT_EQUAL(3u, ints.size());
   ASSERT_EQUAL(8, ints[0]);
   ASSERT_EQUAL(10, ints[1]);
   ASSERT_EQUAL(1'000'001, ints[2]);
 
-  ASSERT_EQUAL(3, floats.size());
+  ASSERT_EQUAL(3u, floats.size());
   ASSERT_EQUAL(50.0, floats[0]);
   ASSERT_EQUAL(79.0, floats[1]);
   ASSERT_EQUAL(1'000.0, floats[2]);
 
-  ASSERT_EQUAL(3, strings.size());
+  ASSERT_EQUAL(3u, strings.size());
   ASSERT_EQUAL("eleven", strings[0]);
   ASSERT_EQUAL("twelve", strings[1]);
   ASSERT_EQUAL("thirteen", strings[2]);
@@ -892,17 +923,17 @@ TESTCASE(ArrayToVectorPointers)
   std::string code = "array_to_vector_pointers([9, 11, 1_000_002], [51.0, 80.0, 1_001.0], %w[fourteen fifteen sixteen])";
   m.module_eval(code);
 
-  ASSERT_EQUAL(3, ints.size());
+  ASSERT_EQUAL(3u, ints.size());
   ASSERT_EQUAL(9, ints[0]);
   ASSERT_EQUAL(11, ints[1]);
   ASSERT_EQUAL(1'000'002, ints[2]);
 
-  ASSERT_EQUAL(3, floats.size());
+  ASSERT_EQUAL(3u, floats.size());
   ASSERT_EQUAL(51.0, floats[0]);
   ASSERT_EQUAL(80.0, floats[1]);
   ASSERT_EQUAL(1'001.0, floats[2]);
 
-  ASSERT_EQUAL(3, strings.size());
+  ASSERT_EQUAL(3u, strings.size());
   ASSERT_EQUAL("fourteen", strings[0]);
   ASSERT_EQUAL("fifteen", strings[1]);
   ASSERT_EQUAL("sixteen", strings[2]);
@@ -962,11 +993,11 @@ namespace
     static inline std::vector<std::string> instance_{ "one", "two", "three" };
   };
 
-  std::ostream& operator<<(std::ostream& stream, const std::vector<std::string>& vector)
+ /* std::ostream& operator<<(std::ostream& stream, const std::vector<std::string>& vector)
   {
-    stream << "Vector";
+    stream << vector;
     return stream;
-  }
+  }*/
 
   void createFactoryClass()
   {
@@ -1104,7 +1135,7 @@ TESTCASE(StringPointerVector)
 
   Module m(rb_mKernel);
   Data_Object<std::vector<std::string*>> vec = m.call("vector_of_string_pointers");
-  ASSERT_EQUAL(2, vec->size());
+  ASSERT_EQUAL(2u, vec->size());
 
   std::string expected("Hello");
   std::string* actual = (*vec)[0];
@@ -1149,7 +1180,7 @@ TESTCASE(MyClass2PointerVector)
 
   Module m(rb_mKernel);
   Data_Object<std::vector<MyClass2*>> result = m.call("vector_of_myclass2_pointers");
-  ASSERT_EQUAL(1, result->size());
+  ASSERT_EQUAL(1u, result->size());
 
  MyClass2* pMyClass = (*result)[0];
  ASSERT_EQUAL("Hello MyClass2", pMyClass->name);
@@ -1157,17 +1188,17 @@ TESTCASE(MyClass2PointerVector)
 
 namespace
 {
-  bool typeCheckValue(std::vector<std::string> vec)
+  bool typeCheckValue(std::vector<std::string>)
   {
     return true;
   }
 
-  bool typeCheckRef(std::vector<std::string>& vec)
+  bool typeCheckRef(std::vector<std::string>&)
   {
     return true;
   }
 
-  bool typeCheckPtr(std::vector<std::string>* vec)
+  bool typeCheckPtr(std::vector<std::string>*)
   {
     return true;
   }

data/test/test_String.cpp

@@ -118,10 +118,12 @@ TESTCASE(intern)
  */
 
 namespace {
-  void testStringArg(Object self, String string) {
+  void testStringArg(Object, String)
+  {
   }
 }
 
-TESTCASE(use_string_in_wrapped_function) {
+TESTCASE(use_string_in_wrapped_function)
+{
   define_global_function("test_string_arg", &testStringArg);
 }

data/test/test_Struct.cpp

@@ -192,7 +192,7 @@ TESTCASE(instance_swap)
  */
 
 namespace {
-  void testStructArg(Object self, Struct string) {
+  void testStructArg(Object, Struct) {
   }
 }
 

data/test/test_Symbol.cpp

@@ -76,7 +76,7 @@ TESTCASE(to_id)
 
 namespace
 {
-  void testSymbolArg(Object self, Symbol string)
+  void testSymbolArg(Object, Symbol)
   {
   }
 }

data/test/test_To_Ruby.cpp

@@ -28,6 +28,7 @@ TESTCASE(object_to_ruby)
 
 TESTCASE(short_to_ruby)
 {
+#undef min
   ASSERT_EQUAL(INT2NUM(0), detail::to_ruby((short)0));
   ASSERT_EQUAL(INT2NUM(-1), detail::to_ruby((short)-1));
   ASSERT_EQUAL(INT2NUM(1), detail::to_ruby((short)1));

data/test/test_Type.cpp

@@ -41,83 +41,84 @@ TESTCASE(FindGroup)
 {
   std::string name = "class std::vector<class cv::Vec<unsigned char, 2>, class std::allocator<class cv::Vec<unsigned char, 2> > >";
 
-  detail::TypeMapper<int> typeMapper;
-  std::string group = typeMapper.findGroup(name, 0);
+  detail::TypeIndexParser parser(typeid(int), true);
+
+  std::string group = parser.findGroup(name, 0);
   ASSERT_EQUAL("<class cv::Vec<unsigned char, 2>, class std::allocator<class cv::Vec<unsigned char, 2> > >", group.c_str());
 
-  group = typeMapper.findGroup(name, 18);
+  group = parser.findGroup(name, 18);
   ASSERT_EQUAL("<unsigned char, 2>", group.c_str());
   
-  group = typeMapper.findGroup(name, 49);
+  group = parser.findGroup(name, 49);
   ASSERT_EQUAL("<class cv::Vec<unsigned char, 2> >", group.c_str());
 
   ASSERT_EXCEPTION_CHECK(
     std::runtime_error,
-    typeMapper.findGroup(name, 48),
+    parser.findGroup(name, 48),
       ASSERT_EQUAL("Unbalanced Group", ex.what())
   );
 }
 
 TESTCASE(SimplifiedName)
 {
-  detail::TypeMapper<char*> typeMapper1;
-  std::string className = typeMapper1.simplifiedName();
+  detail::TypeIndexParser typeIndexParser1(typeid(char*));
+  std::string className = typeIndexParser1.simplifiedName();
   ASSERT_EQUAL("char*", className.c_str());
 
-  detail::TypeMapper<char**> typeMapper2;
-  className = typeMapper2.simplifiedName();
+  detail::TypeIndexParser typeIndexParser2(typeid(char**));
+  className = typeIndexParser2.simplifiedName();
   ASSERT_EQUAL("char**", className.c_str());
 
-  detail::TypeMapper<double> typeMapper3;
-  className = typeMapper3.simplifiedName();
+  detail::TypeIndexParser typeIndexParser3(typeid(double));
+  className = typeIndexParser3.simplifiedName();
   ASSERT_EQUAL("double", className.c_str());
 
-  detail::TypeMapper<double*> typeMapper4;
-  className = typeMapper4.simplifiedName();
+  detail::TypeIndexParser typeIndexParser4(typeid(double*));
+  className = typeIndexParser4.simplifiedName();
   ASSERT_EQUAL("double*", className.c_str());
 
-  detail::TypeMapper<std::string> typeMapper5;
-  className = typeMapper5.simplifiedName();
+  detail::TypeIndexParser typeIndexParser5(typeid(std::string));
+  className = typeIndexParser5.simplifiedName();
   ASSERT_EQUAL("std::string", className.c_str());
 
-  detail::TypeMapper<std::wstring> typeMapper6;
-  className = typeMapper6.simplifiedName();
+  detail::TypeIndexParser typeIndexParser6(typeid(std::wstring));
+  className = typeIndexParser6.simplifiedName();
   ASSERT_EQUAL("std::wstring", className.c_str());
 
-  detail::TypeMapper<std::vector<std::string>> typeMapper7;
-  className = typeMapper7.simplifiedName();
+  detail::TypeIndexParser typeIndexParser7(typeid(std::vector<std::string>));
+  className = typeIndexParser7.simplifiedName();
   ASSERT_EQUAL("std::vector<std::string>", className.c_str());
 
-  detail::TypeMapper<std::vector<std::wstring>> typeMapper8;
-  className = typeMapper8.simplifiedName();
+  detail::TypeIndexParser typeIndexParser8(typeid(std::vector<std::wstring>));
+  className = typeIndexParser8.simplifiedName();
   ASSERT_EQUAL("std::vector<std::wstring>", className.c_str());
 
-  detail::TypeMapper<std::vector<double*>> typeMapper9;
-  className = typeMapper9.simplifiedName();
+  detail::TypeIndexParser typeIndexParser9(typeid(std::vector<double*>));
+  className = typeIndexParser9.simplifiedName();
   ASSERT_EQUAL("std::vector<double*>", className.c_str());
 
-  detail::TypeMapper<std::vector<double**>> typeMapper10;
-  className = typeMapper10.simplifiedName();
+  detail::TypeIndexParser typeIndexParser10(typeid(std::vector<double**>));
+  className = typeIndexParser10.simplifiedName();
   ASSERT_EQUAL("std::vector<double**>", className.c_str());
 
-  detail::TypeMapper<Outer::Inner::Vec1> typeMapper11;
-  className = typeMapper11.simplifiedName();
+  detail::TypeIndexParser typeIndexParser11(typeid(Outer::Inner::Vec1));
+  className = typeIndexParser11.simplifiedName();
   ASSERT_EQUAL("std::vector<std::complex<float>>", className.c_str());
 
-  detail::TypeMapper<Outer::Inner::Vec2> typeMapper12;
-  className = typeMapper12.simplifiedName();
+  detail::TypeIndexParser typeIndexParser12(typeid(Outer::Inner::Vec2));
+  className = typeIndexParser12.simplifiedName();
   ASSERT_EQUAL("std::vector<unsigned char*>", className.c_str());
 
-  detail::TypeMapper<Outer::Inner::Vec3> typeMapper13;
-  className = typeMapper13.simplifiedName();
+  detail::TypeIndexParser typeIndexParser13(typeid(Outer::Inner::Vec3));
+  className = typeIndexParser13.simplifiedName();
   ASSERT_EQUAL("std::vector<Outer::Inner::SomeClass>", className.c_str());
 
-  detail::TypeMapper<Outer::Inner::Map1> typeMapper14;
-  className = typeMapper14.simplifiedName();
+  detail::TypeIndexParser typeIndexParser14(typeid(Outer::Inner::Map1));
+  className = typeIndexParser14.simplifiedName();
   ASSERT_EQUAL("std::map<std::string, std::vector<std::complex<float>>>", className.c_str());
 
-  detail::TypeMapper<Outer::Inner::UnorderedMap1> typeMapper15;
-  className = typeMapper15.simplifiedName();
+  detail::TypeIndexParser typeIndexParser15(typeid(Outer::Inner::UnorderedMap1));
+  className = typeIndexParser15.simplifiedName();
   ASSERT_EQUAL("std::unordered_map<std::string, std::complex<float>>", className.c_str());
 }
 

data/test/test_global_functions.cpp

@@ -75,7 +75,7 @@ TESTCASE(int_kw_arg_invalid)
   ASSERT_EXCEPTION_CHECK(
     Exception,
     m.instance_eval(code),
-    ASSERT_EQUAL("Unknown keyword: wrong", ex.what())
+    ASSERT_EQUAL("Missing argument. Name: value. Index: 0.", ex.what())
   );
 }
 

data/test/unittest.cpp

@@ -68,7 +68,7 @@ run(Test_Result & result)
       std::cout << ".";
     }
     catch(Assertion_Failed const & ex)
-    {
+      {
       std::cout << "F";
       result.add_failure(Failure(name(), it->name(), ex.what()));
     }

data/test/unittest.hpp

@@ -268,11 +268,11 @@ void assert_in_delta(
   T const& expected,
   U const& actual,
   V const& delta,
-  std::string const& s_t,
-  std::string const& s_u,
-  std::string const& s_delta,
-  std::string const& file,
-  size_t line)
+  std::string const&,
+  std::string const&,
+  std::string const&,
+  std::string const&,
+  size_t)
 {
   // Negative deltas don't make sense; treat as failure for clarity.
   if (delta < 0)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rice
 version: !ruby/object:Gem::Version
-  version: 4.7.1
+  version: 4.9.0
 platform: ruby
 authors:
 - Paul Brannan
@@ -79,11 +79,13 @@ files:
 - Rakefile
 - bin/rice-doc.rb
 - bin/rice-rbs.rb
+- include/rice/api.hpp
 - include/rice/rice.hpp
 - include/rice/stl.hpp
 - lib/mkmf-rice.rb
 - lib/rice.rb
 - lib/rice/doc.rb
+- lib/rice/doc/config.rb
 - lib/rice/doc/cpp_reference.rb
 - lib/rice/doc/doxygen.rb
 - lib/rice/doc/mkdocs.rb
@@ -118,14 +120,15 @@ files:
 - rice/Enum.ipp
 - rice/Exception.hpp
 - rice/Exception.ipp
-- rice/Function.hpp
-- rice/Function.ipp
 - rice/JumpException.hpp
 - rice/JumpException.ipp
 - rice/MemoryView.hpp
 - rice/MemoryView.ipp
+- rice/NoGVL.hpp
 - rice/Pointer.hpp
 - rice/Pointer.ipp
+- rice/Reference.hpp
+- rice/Reference.ipp
 - rice/Return.hpp
 - rice/Return.ipp
 - rice/api.hpp
@@ -154,12 +157,12 @@ files:
 - rice/cpp_api/shared_methods.hpp
 - rice/detail/DefaultHandler.hpp
 - rice/detail/DefaultHandler.ipp
+- rice/detail/Forwards.hpp
+- rice/detail/Forwards.ipp
 - rice/detail/HandlerRegistry.hpp
 - rice/detail/HandlerRegistry.ipp
 - rice/detail/InstanceRegistry.hpp
 - rice/detail/InstanceRegistry.ipp
-- rice/detail/MethodInfo.hpp
-- rice/detail/MethodInfo.ipp
 - rice/detail/ModuleRegistry.hpp
 - rice/detail/ModuleRegistry.ipp
 - rice/detail/Native.hpp
@@ -168,10 +171,8 @@ files:
 - rice/detail/NativeAttributeGet.ipp
 - rice/detail/NativeAttributeSet.hpp
 - rice/detail/NativeAttributeSet.ipp
-- rice/detail/NativeCallbackFFI.hpp
-- rice/detail/NativeCallbackFFI.ipp
-- rice/detail/NativeCallbackSimple.hpp
-- rice/detail/NativeCallbackSimple.ipp
+- rice/detail/NativeCallback.hpp
+- rice/detail/NativeCallback.ipp
 - rice/detail/NativeFunction.hpp
 - rice/detail/NativeFunction.ipp
 - rice/detail/NativeInvoker.hpp
@@ -308,6 +309,7 @@ files:
 - test/test_Overloads.cpp
 - test/test_Ownership.cpp
 - test/test_Proc.cpp
+- test/test_Reference.cpp
 - test/test_Self.cpp
 - test/test_Stl_Exception.cpp
 - test/test_Stl_Map.cpp
@@ -357,7 +359,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.2
 specification_version: 4
 summary: Ruby Interface for C++ Extensions
 test_files: []