rice 4.6.1 → 4.7.1

data/test/test_Type.cpp

@@ -1,7 +1,8 @@
-#include "unittest.hpp"
+#include "unittest.hpp"
 #include "embed_ruby.hpp"
 
 #include <rice/rice.hpp>
+#include <rice/stl.hpp>
 
 #include <complex>
 
@@ -40,120 +41,322 @@ TESTCASE(FindGroup)
 {
   std::string name = "class std::vector<class cv::Vec<unsigned char, 2>, class std::allocator<class cv::Vec<unsigned char, 2> > >";
 
-  std::string group = detail::findGroup(name, 0);
+  detail::TypeMapper<int> typeMapper;
+  std::string group = typeMapper.findGroup(name, 0);
   ASSERT_EQUAL("<class cv::Vec<unsigned char, 2>, class std::allocator<class cv::Vec<unsigned char, 2> > >", group.c_str());
 
-  group = detail::findGroup(name, 18);
+  group = typeMapper.findGroup(name, 18);
   ASSERT_EQUAL("<unsigned char, 2>", group.c_str());
   
-  group = detail::findGroup(name, 49);
+  group = typeMapper.findGroup(name, 49);
   ASSERT_EQUAL("<class cv::Vec<unsigned char, 2> >", group.c_str());
 
   ASSERT_EXCEPTION_CHECK(
     std::runtime_error,
-    detail::findGroup(name, 48),
+    typeMapper.findGroup(name, 48),
       ASSERT_EQUAL("Unbalanced Group", ex.what())
   );
 }
 
-TESTCASE(CppClassName)
+TESTCASE(SimplifiedName)
 {
-  std::string typeName = detail::typeName(typeid(std::string));
-  std::string className = detail::cppClassName(typeName);
+  detail::TypeMapper<char*> typeMapper1;
+  std::string className = typeMapper1.simplifiedName();
+  ASSERT_EQUAL("char*", className.c_str());
+
+  detail::TypeMapper<char**> typeMapper2;
+  className = typeMapper2.simplifiedName();
+  ASSERT_EQUAL("char**", className.c_str());
+
+  detail::TypeMapper<double> typeMapper3;
+  className = typeMapper3.simplifiedName();
+  ASSERT_EQUAL("double", className.c_str());
+
+  detail::TypeMapper<double*> typeMapper4;
+  className = typeMapper4.simplifiedName();
+  ASSERT_EQUAL("double*", className.c_str());
+
+  detail::TypeMapper<std::string> typeMapper5;
+  className = typeMapper5.simplifiedName();
   ASSERT_EQUAL("std::string", className.c_str());
 
-  typeName = detail::typeName(typeid(std::wstring));
-  className = detail::cppClassName(typeName);
+  detail::TypeMapper<std::wstring> typeMapper6;
+  className = typeMapper6.simplifiedName();
   ASSERT_EQUAL("std::wstring", className.c_str());
 
-  typeName = detail::typeName(typeid(std::vector<std::string>));
-  className = detail::cppClassName(typeName);
+  detail::TypeMapper<std::vector<std::string>> typeMapper7;
+  className = typeMapper7.simplifiedName();
   ASSERT_EQUAL("std::vector<std::string>", className.c_str());
 
-  typeName = detail::typeName(typeid(std::vector<std::wstring>));
-  className = detail::cppClassName(typeName);
+  detail::TypeMapper<std::vector<std::wstring>> typeMapper8;
+  className = typeMapper8.simplifiedName();
   ASSERT_EQUAL("std::vector<std::wstring>", className.c_str());
 
-  typeName = detail::typeName(typeid(std::vector<double*>));
-  className = detail::cppClassName(typeName);
+  detail::TypeMapper<std::vector<double*>> typeMapper9;
+  className = typeMapper9.simplifiedName();
   ASSERT_EQUAL("std::vector<double*>", className.c_str());
 
-  typeName = detail::typeName(typeid(std::vector<double**>));
-  className = detail::cppClassName(typeName);
+  detail::TypeMapper<std::vector<double**>> typeMapper10;
+  className = typeMapper10.simplifiedName();
   ASSERT_EQUAL("std::vector<double**>", className.c_str());
 
-  typeName = detail::typeName(typeid(Outer::Inner::Vec1));
-  className = detail::cppClassName(typeName);
+  detail::TypeMapper<Outer::Inner::Vec1> typeMapper11;
+  className = typeMapper11.simplifiedName();
   ASSERT_EQUAL("std::vector<std::complex<float>>", className.c_str());
 
-  typeName = detail::typeName(typeid(Outer::Inner::Vec2));
-  className = detail::cppClassName(typeName);
+  detail::TypeMapper<Outer::Inner::Vec2> typeMapper12;
+  className = typeMapper12.simplifiedName();
   ASSERT_EQUAL("std::vector<unsigned char*>", className.c_str());
 
-  typeName = detail::typeName(typeid(Outer::Inner::Vec3));
-  className = detail::cppClassName(typeName);
+  detail::TypeMapper<Outer::Inner::Vec3> typeMapper13;
+  className = typeMapper13.simplifiedName();
   ASSERT_EQUAL("std::vector<Outer::Inner::SomeClass>", className.c_str());
 
-  typeName = detail::typeName(typeid(Outer::Inner::Map1));
-  className = detail::cppClassName(typeName);
+  detail::TypeMapper<Outer::Inner::Map1> typeMapper14;
+  className = typeMapper14.simplifiedName();
   ASSERT_EQUAL("std::map<std::string, std::vector<std::complex<float>>>", className.c_str());
 
-  typeName = detail::typeName(typeid(Outer::Inner::UnorderedMap1));
-  className = detail::cppClassName(typeName);
+  detail::TypeMapper<Outer::Inner::UnorderedMap1> typeMapper15;
+  className = typeMapper15.simplifiedName();
   ASSERT_EQUAL("std::unordered_map<std::string, std::complex<float>>", className.c_str());
 }
 
-TESTCASE(RubyClassName)
+TESTCASE(RubyName)
 {
-  std::string typeName = detail::typeName(typeid(std::string));
-  std::string className = detail::rubyClassName(typeName);
+  detail::TypeMapper<char*> typeMapper1;
+  std::string className = typeMapper1.rubyName();
+  ASSERT_EQUAL("String", className.c_str());
+
+  detail::TypeMapper<const unsigned char> typeMapper2;
+  className = typeMapper2.rubyName();
+  ASSERT_EQUAL("String", className.c_str());
+
+  detail::TypeMapper<const unsigned char*> typeMapper3;
+  className = typeMapper3.rubyName();
+  ASSERT_EQUAL("UnsignedChar", className.c_str());
+
+  detail::TypeMapper<char**> typeMapper4;
+  className = typeMapper4.rubyName();
+  ASSERT_EQUAL("Char", className.c_str());
+
+  detail::TypeMapper<double> typeMapper5;
+  className = typeMapper5.rubyName();
+  ASSERT_EQUAL("Float", className.c_str());
+
+  detail::TypeMapper<double*> typeMapper6;
+  className = typeMapper6.rubyName();
+  ASSERT_EQUAL("Double", className.c_str());
+
+  detail::TypeMapper<Buffer<double*>> typeMapper7;
+  className = typeMapper7.rubyName();
+  ASSERT_EQUAL("Buffer≺double∗≻", className.c_str());
+
+  detail::TypeMapper<std::string> typeMapper8;
+  className = typeMapper8.rubyName();
   ASSERT_EQUAL("String", className.c_str());
 
-  typeName = detail::typeName(typeid(std::wstring));
-  className = detail::rubyClassName(typeName);
+  detail::TypeMapper<std::wstring> typeMapper9;
+  className = typeMapper9.rubyName();
   ASSERT_EQUAL("Wstring", className.c_str());
 
-  typeName = detail::typeName(typeid(std::vector<std::string>));
-  className = detail::rubyClassName(typeName);
+  detail::TypeMapper<std::vector<std::string>> typeMapper10;
+  className = typeMapper10.rubyName();
   ASSERT_EQUAL("Vector≺string≻", className.c_str());
 
-  typeName = detail::typeName(typeid(std::vector<std::wstring>));
-  className = detail::rubyClassName(typeName);
+  detail::TypeMapper<std::vector<std::wstring>> typeMapper11;
+  className = typeMapper11.rubyName();
   ASSERT_EQUAL("Vector≺wstring≻", className.c_str());
 
-  typeName = detail::typeName(typeid(std::vector<double*>));
-  className = detail::rubyClassName(typeName);
+  detail::TypeMapper<std::vector<double*>> typeMapper12;
+  className = typeMapper12.rubyName();
   ASSERT_EQUAL("Vector≺double∗≻", className.c_str());
 
-  typeName = detail::typeName(typeid(std::vector<double**>));
-  className = detail::rubyClassName(typeName);
+  detail::TypeMapper<std::vector<double**>> typeMapper13;
+  className = typeMapper13.rubyName();
   ASSERT_EQUAL("Vector≺double∗∗≻", className.c_str());
 
-  typeName = detail::typeName(typeid(Outer::Inner::Vec1));
-  className = detail::rubyClassName(typeName);
+  detail::TypeMapper<Outer::Inner::Vec1> typeMapper14;
+  className = typeMapper14.rubyName();
   ASSERT_EQUAL("Vector≺complex≺float≻≻", className.c_str());
 
-  typeName = detail::typeName(typeid(Outer::Inner::Vec2));
-  className = detail::rubyClassName(typeName);
+  detail::TypeMapper<Outer::Inner::Vec2> typeMapper15;
+  className = typeMapper15.rubyName();
   ASSERT_EQUAL("Vector≺unsigned char∗≻", className.c_str());
 
-  typeName = detail::typeName(typeid(Outer::Inner::Vec3));
-  className = detail::rubyClassName(typeName);
+  detail::TypeMapper<Outer::Inner::Vec3> typeMapper16;
+  className = typeMapper16.rubyName();
   ASSERT_EQUAL("Vector≺Outer꞉꞉Inner꞉꞉SomeClass≻", className.c_str());
 
-  typeName = detail::typeName(typeid(Outer::Inner::Map1));
-  className = detail::rubyClassName(typeName);
+  detail::TypeMapper<Outer::Inner::Map1> typeMapper17;
+  className = typeMapper17.rubyName();
   ASSERT_EQUAL("Map≺string‚ vector≺complex≺float≻≻≻", className.c_str());
 
-  typeName = detail::typeName(typeid(Outer::Inner::UnorderedMap1));
-  className = detail::rubyClassName(typeName);
+  detail::TypeMapper<Outer::Inner::UnorderedMap1> typeMapper18;
+  className = typeMapper18.rubyName();
   ASSERT_EQUAL("UnorderedMap≺string‚ complex≺float≻≻", className.c_str());
+
+  detail::TypeMapper<Outer::Inner::SomeClass*> typeMapper19;
+  className = typeMapper19.rubyName();
+  ASSERT_EQUAL("SomeClass", className.c_str());
+}
+
+TESTCASE(RubyKlass)
+{
+  Module riceModule = define_module("Rice");
+
+  detail::TypeMapper<int> typeMapper1;
+  VALUE actual = typeMapper1.rubyKlass();
+  ASSERT_EQUAL(rb_cInteger, actual);
+
+  detail::TypeMapper<const int> typeMapper2;
+  actual = typeMapper2.rubyKlass();
+  ASSERT_EQUAL(rb_cInteger, actual);
+
+  detail::TypeMapper<int&> typeMapper3;
+  actual = typeMapper3.rubyKlass();
+  ASSERT_EQUAL(rb_cInteger, actual);
+
+  detail::TypeMapper<const int&> typeMapper4;
+  actual = typeMapper4.rubyKlass();
+  ASSERT_EQUAL(rb_cInteger, actual);
+
+  detail::TypeMapper<char*> typeMapper5;
+  actual = typeMapper5.rubyKlass();
+  ASSERT_EQUAL(rb_cString, actual);
+
+  detail::TypeMapper<const unsigned char> typeMapper6;
+  actual = typeMapper6.rubyKlass();
+  ASSERT_EQUAL(rb_cString, actual);
+
+  define_buffer<unsigned char>();
+  Object expected = riceModule.const_get("Buffer≺unsigned char≻");
+  detail::TypeMapper<Buffer<unsigned char>> typeMapper8;
+  actual = typeMapper8.rubyKlass();
+  ASSERT_EQUAL(expected.value(), actual);
+
+  expected = Object(rb_cObject).const_get("String");
+  detail::TypeMapper<char*> typeMapper9;
+  actual = typeMapper9.rubyKlass();
+  ASSERT_EQUAL(expected.value(), actual);
+
+  define_pointer<char*>();
+  expected = riceModule.const_get("Pointer≺char∗≻");
+  detail::TypeMapper<char**> typeMapper10;
+  actual = typeMapper10.rubyKlass();
+  ASSERT_EQUAL(expected.value(), actual);
+
+  define_pointer<char*>();
+  expected = riceModule.const_get("Pointer≺char∗≻");
+  detail::TypeMapper<const char**> typeMapper11;
+  actual = typeMapper11.rubyKlass();
+  ASSERT_EQUAL(expected.value(), actual);
+
+  define_buffer<char**>();
+  expected = riceModule.const_get("Buffer≺char∗≻");
+  detail::TypeMapper<Buffer<char*>> typeMapper12;
+  actual = typeMapper12.rubyKlass();
+  ASSERT_EQUAL(expected.value(), actual);
+
+  detail::TypeMapper<double> typeMapper13;
+  actual = typeMapper13.rubyKlass();
+  ASSERT_EQUAL(rb_cFloat, actual);
+
+  define_pointer<double>();
+  expected = riceModule.const_get("Pointer≺double≻");
+  detail::TypeMapper<volatile double*> typeMapper14;
+  actual = typeMapper14.rubyKlass();
+  ASSERT_EQUAL(expected.value(), actual);
+
+  define_pointer<double*>();
+  expected = riceModule.const_get("Pointer≺double∗≻");
+  detail::TypeMapper<const volatile double**> typeMapper15;
+  actual = typeMapper15.rubyKlass();
+  ASSERT_EQUAL(expected.value(), actual);
+
+  detail::TypeMapper<std::string> typeMapper16;
+  actual = typeMapper16.rubyKlass();
+  ASSERT_EQUAL(rb_cString, actual);
+
+  define_pointer<std::string>();
+  detail::TypeMapper<std::string*> typeMapper17;
+  expected = riceModule.const_get("Pointer≺string≻");
+  actual = typeMapper17.rubyKlass();
+  ASSERT_EQUAL(expected.value(), actual);
+
+  define_pointer<std::string*>();
+  detail::TypeMapper<std::string**> typeMapper18;
+  expected = riceModule.const_get("Pointer≺string∗≻");
+  actual = typeMapper18.rubyKlass();
+  ASSERT_EQUAL(expected.value(), actual);
+  
+  define_vector<std::string>();
+  Module stdModule("Std");
+
+  detail::TypeMapper<std::vector<std::string>> typeMapper19;
+  expected = stdModule.const_get("Vector≺string≻");
+  actual = typeMapper19.rubyKlass();
+  ASSERT_EQUAL(expected.value(), actual);
+
+  define_class<Outer::Inner::Vec1>("Vec1");
+  detail::TypeMapper<Outer::Inner::Vec1> typeMapper20;
+  expected = Object(rb_cObject).const_get("Vec1");
+  actual = typeMapper20.rubyKlass();
+  ASSERT_EQUAL(expected.value(), actual);
+
+  define_class<Outer::Inner::Map1>("Map1");
+  detail::TypeMapper<Outer::Inner::Map1> typeMapper21;
+  expected = Object(rb_cObject).const_get("Map1");
+  actual = typeMapper21.rubyKlass();
+  ASSERT_EQUAL(expected.value(), actual);
+
+  define_class<Outer::Inner::UnorderedMap1>("UnorderedMap1");
+  detail::TypeMapper<Outer::Inner::UnorderedMap1> typeMapper22;
+  expected = Object(rb_cObject).const_get("UnorderedMap1");
+  actual = typeMapper22.rubyKlass();
+  ASSERT_EQUAL(expected.value(), actual);
+ 
+  define_class<Outer::Inner::SomeClass>("SomeClass");
+  detail::TypeMapper<Outer::Inner::SomeClass**> typeMapper23;
+  expected = Object(rb_cObject).const_get("SomeClass");
+  actual = typeMapper23.rubyKlass();
+  ASSERT_EQUAL(expected.value(), actual);
+
+  using Callback_T = char*(*)(int, double, bool, char*);
+  detail::TypeMapper<Callback_T> typeMapper24;
+  expected = Object(rb_cObject).const_get("Proc");
+  actual = typeMapper24.rubyKlass();
+  ASSERT_EQUAL(expected.value(), actual);
+
+  detail::TypeMapper<std::tuple<float, float>> typeMapper25;
+  expected = Object(rb_cObject).const_get("Array");
+  actual = typeMapper25.rubyKlass();
+  ASSERT_EQUAL(expected.value(), actual);
+
+  detail::TypeMapper<std::optional<float>> typeMapper26;
+  actual = typeMapper26.rubyKlass();
+  ASSERT_EQUAL(rb_cFloat, actual);
+
+  detail::TypeMapper<std::complex<float>> typeMapper27;
+  actual = typeMapper27.rubyKlass();
+  ASSERT_EQUAL(rb_cComplex, actual);
+
+  detail::TypeMapper<std::monostate> typeMapper28;
+  actual = typeMapper28.rubyKlass();
+  ASSERT_EQUAL(rb_cNilClass, actual);
+
+  detail::TypeMapper<std::reference_wrapper<int>> typeMapper29;
+  actual = typeMapper29.rubyKlass();
+  ASSERT_EQUAL(rb_cInteger, actual);
+
+  detail::TypeMapper<std::string_view> typeMapper30;
+  actual = typeMapper30.rubyKlass();
+  ASSERT_EQUAL(rb_cString, actual);
 }
 
 TESTCASE(MakeRubyClass)
 {
-  std::string typeName = detail::typeName(typeid(Outer::Inner::Vec1));
-  std::string rubyClassName = detail::rubyClassName(typeName);
+  detail::TypeMapper<Outer::Inner::Vec1> typeMapper;
+  std::string rubyClassName = typeMapper.rubyName();
 
   Module module = define_module("Testing");
 

data/test/unittest.hpp

@@ -263,6 +263,33 @@ void assert_not_equal(
   }
 }
 
+template<typename T, typename U, typename V>
+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)
+{
+  // Negative deltas don't make sense; treat as failure for clarity.
+  if (delta < 0)
+  {
+    throw Assertion_Failed("assert_in_delta failed: negative delta");
+  }
+  
+  T diff = std::abs(expected - actual);
+  if (!(diff <= delta))
+  {
+    std::stringstream strm;
+    strm << "assert_in_delta failed: |" << actual << " - " << expected << "| = "
+         << diff << " > " << delta;
+    throw Assertion_Failed(strm.str());
+  }
+}
+
 #define FAIL(message, expect, got) \
   do \
   { \
@@ -285,6 +312,14 @@ void assert_not_equal(
     assert_not_equal((x), (y), #x, #y, __FILE__, __LINE__); \
   } while(0)
 
+#define ASSERT_IN_DELTA(x, y, delta) \
+  do \
+  { \
+    ++assertions; \
+    assert_in_delta((x), (y), (delta), #x, #y, #delta, __FILE__, __LINE__); \
+  } while(0)
+
+
 #define ASSERT(x) \
   ASSERT_EQUAL(true, !!x);
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rice
 version: !ruby/object:Gem::Version
-  version: 4.6.1
+  version: 4.7.1
 platform: ruby
 authors:
 - Paul Brannan
@@ -61,7 +61,9 @@ email:
 - curlypaul924@gmail.com
 - jasongroelofs@gmail.com
 - cfis@savagexi.com
-executables: []
+executables:
+- rice-doc.rb
+- rice-rbs.rb
 extensions: []
 extra_rdoc_files:
 - README.md
@@ -75,11 +77,23 @@ files:
 - Gemfile
 - README.md
 - Rakefile
+- bin/rice-doc.rb
+- bin/rice-rbs.rb
 - include/rice/rice.hpp
 - include/rice/stl.hpp
-- lib/make_rice_headers.rb
 - lib/mkmf-rice.rb
 - lib/rice.rb
+- lib/rice/doc.rb
+- lib/rice/doc/cpp_reference.rb
+- lib/rice/doc/doxygen.rb
+- lib/rice/doc/mkdocs.rb
+- lib/rice/doc/rice.rb
+- lib/rice/doc/ruby.rb
+- lib/rice/make_rice_headers.rb
+- lib/rice/native.rb
+- lib/rice/native_registry.rb
+- lib/rice/parameter.rb
+- lib/rice/rbs.rb
 - lib/rice/version.rb
 - lib/rubygems/builder.rb
 - lib/rubygems/cmake_builder.rb
@@ -104,14 +118,17 @@ files:
 - rice/Enum.ipp
 - rice/Exception.hpp
 - rice/Exception.ipp
-- rice/Init.hpp
-- rice/Init.ipp
+- rice/Function.hpp
+- rice/Function.ipp
 - rice/JumpException.hpp
 - rice/JumpException.ipp
 - rice/MemoryView.hpp
 - rice/MemoryView.ipp
+- rice/Pointer.hpp
+- rice/Pointer.ipp
 - rice/Return.hpp
 - rice/Return.ipp
+- rice/api.hpp
 - rice/cpp_api/Array.hpp
 - rice/cpp_api/Array.ipp
 - rice/cpp_api/Builtin_Object.hpp
@@ -143,6 +160,8 @@ files:
 - rice/detail/InstanceRegistry.ipp
 - rice/detail/MethodInfo.hpp
 - rice/detail/MethodInfo.ipp
+- rice/detail/ModuleRegistry.hpp
+- rice/detail/ModuleRegistry.ipp
 - rice/detail/Native.hpp
 - rice/detail/Native.ipp
 - rice/detail/NativeAttributeGet.hpp
@@ -155,22 +174,29 @@ files:
 - rice/detail/NativeCallbackSimple.ipp
 - rice/detail/NativeFunction.hpp
 - rice/detail/NativeFunction.ipp
+- rice/detail/NativeInvoker.hpp
+- rice/detail/NativeInvoker.ipp
 - rice/detail/NativeIterator.hpp
 - rice/detail/NativeIterator.ipp
+- rice/detail/NativeMethod.hpp
+- rice/detail/NativeMethod.ipp
+- rice/detail/NativeProc.hpp
+- rice/detail/NativeProc.ipp
 - rice/detail/NativeRegistry.hpp
 - rice/detail/NativeRegistry.ipp
+- rice/detail/Parameter.hpp
+- rice/detail/Parameter.ipp
 - rice/detail/Proc.hpp
 - rice/detail/Proc.ipp
 - rice/detail/Registries.hpp
 - rice/detail/Registries.ipp
-- rice/detail/RubyFunction.hpp
-- rice/detail/RubyFunction.ipp
 - rice/detail/RubyType.hpp
 - rice/detail/RubyType.ipp
 - rice/detail/Type.hpp
 - rice/detail/Type.ipp
 - rice/detail/TypeRegistry.hpp
 - rice/detail/TypeRegistry.ipp
+- rice/detail/Types.ipp
 - rice/detail/Wrapper.hpp
 - rice/detail/Wrapper.ipp
 - rice/detail/cpp_protect.hpp
@@ -187,6 +213,20 @@ files:
 - rice/libc/file.hpp
 - rice/libc/file.ipp
 - rice/rice.hpp
+- rice/rice_api/Arg.hpp
+- rice/rice_api/Arg.ipp
+- rice/rice_api/ModuleRegistry.hpp
+- rice/rice_api/ModuleRegistry.ipp
+- rice/rice_api/Native.hpp
+- rice/rice_api/Native.ipp
+- rice/rice_api/NativeRegistry.hpp
+- rice/rice_api/NativeRegistry.ipp
+- rice/rice_api/Parameter.hpp
+- rice/rice_api/Parameter.ipp
+- rice/rice_api/Registries.hpp
+- rice/rice_api/Registries.ipp
+- rice/rice_api/TypeRegistry.hpp
+- rice/rice_api/TypeRegistry.ipp
 - rice/ruby_mark.hpp
 - rice/stl.hpp
 - rice/stl/complex.hpp
@@ -195,6 +235,8 @@ files:
 - rice/stl/exception.ipp
 - rice/stl/exception_ptr.hpp
 - rice/stl/exception_ptr.ipp
+- rice/stl/filesystem.hpp
+- rice/stl/filesystem.ipp
 - rice/stl/map.hpp
 - rice/stl/map.ipp
 - rice/stl/monostate.hpp
@@ -233,30 +275,9 @@ files:
 - rice/traits/function_traits.hpp
 - rice/traits/method_traits.hpp
 - rice/traits/rice_traits.hpp
-- sample/callbacks/extconf.rb
-- sample/callbacks/sample_callbacks.cpp
-- sample/callbacks/test.rb
-- sample/enum/extconf.rb
-- sample/enum/sample_enum.cpp
-- sample/enum/test.rb
-- sample/inheritance/animals.cpp
-- sample/inheritance/extconf.rb
-- sample/inheritance/test.rb
-- sample/map/extconf.rb
-- sample/map/map.cpp
-- sample/map/test.rb
 - test/embed_ruby.cpp
 - test/embed_ruby.hpp
-- test/ext/t1/Foo.hpp
-- test/ext/t1/extconf.rb
-- test/ext/t1/t1.cpp
-- test/ext/t2/extconf.rb
-- test/ext/t2/t2.cpp
 - test/extconf.rb
-- test/ruby/test_callbacks_sample.rb
-- test/ruby/test_multiple_extensions.rb
-- test/ruby/test_multiple_extensions_same_class.rb
-- test/ruby/test_multiple_extensions_with_inheritance.rb
 - test/test_Address_Registration_Guard.cpp
 - test/test_Array.cpp
 - test/test_Attribute.cpp
@@ -272,6 +293,7 @@ files:
 - test/test_Exception.cpp
 - test/test_File.cpp
 - test/test_From_Ruby.cpp
+- test/test_GVL.cpp
 - test/test_Hash.cpp
 - test/test_Identifier.cpp
 - test/test_Inheritance.cpp
@@ -298,7 +320,7 @@ files:
 - test/test_Stl_String.cpp
 - test/test_Stl_String_View.cpp
 - test/test_Stl_Tuple.cpp
-- test/test_Stl_Type.cpp
+- test/test_Stl_Type_Info.cpp
 - test/test_Stl_UniquePtr.cpp
 - test/test_Stl_Unordered_Map.cpp
 - test/test_Stl_Variant.cpp
@@ -338,8 +360,4 @@ requirements: []
 rubygems_version: 3.6.9
 specification_version: 4
 summary: Ruby Interface for C++ Extensions
-test_files:
-- test/ruby/test_callbacks_sample.rb
-- test/ruby/test_multiple_extensions.rb
-- test/ruby/test_multiple_extensions_same_class.rb
-- test/ruby/test_multiple_extensions_with_inheritance.rb
+test_files: []

data/rice/Init.hpp

@@ -1,8 +0,0 @@
-#ifndef Rice__Init__hpp_
-#define Rice__Init__hpp_
-
-namespace Rice
-{
-  void init();
-}
-#endif // Rice__Init__hpp_

data/rice/Init.ipp

@@ -1,8 +0,0 @@
-namespace Rice
-{
-  inline void init()
-  {
-    detail::define_ruby_types();
-    define_fundamental_buffer_types();
-  };
-}

data/rice/detail/RubyFunction.hpp

@@ -1,31 +0,0 @@
-#ifndef Rice__detail__ruby_function__hpp_
-#define Rice__detail__ruby_function__hpp_
-
-namespace Rice::detail
-{
-  /* This is functor class that wraps calls to a Ruby C API method. It is needed because
-     rb_protect only supports calling methods that take one argument. Thus 
-     we invoke rb_protect telling it to invoke Ruby_Function::call with an 
-     instance of a Ruby_Function. That instance then in turn calls the original
-     Ruby method passing along its required arguments. */
-
-  template<typename Function_T, typename...Arg_Ts>
-  class RubyFunction
-  {
-  public:
-    using Return_T = typename function_traits<Function_T>::return_type;
-
-  public:
-    RubyFunction(Function_T func, const Arg_Ts&... args);
-    Return_T operator()();
-
-  private:
-    Function_T func_;
-    std::tuple<Arg_Ts...> args_;
-  };
-
-  template<typename Function_T, typename ...Arg_Ts>
-  auto protect(Function_T func, Arg_Ts...args);
-}
-
-#endif // Rice__detail__ruby_function__hpp_