rice 4.11.2 → 4.11.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bbea336b28656bc1123b687fe1649c58c5c497cc01efafeabe7efdac71577d46
-  data.tar.gz: 4910c437a1e878c3c0dc534828ee89b499cf14a3d3ab4011ead2944f6063cca4
+  metadata.gz: 2b52ff5ddc64209e1c252d529111695d833a57d1362e15b6d223777194dc6750
+  data.tar.gz: 214c2b675683e68d026440cc83499a7de0faa6282563c0bfa028c925e677f195
 SHA512:
-  metadata.gz: 9f8f3dc946883c516c3e3e79ea11866503cd059d95765586789490c31fbd0881ed6d5fb905fd9f60120df3f2d4980a2a50bb8005d245e17feb94f85d217bbf3a
-  data.tar.gz: 2b69b75163ca48b82f5b11041094885d64b5c18abe0b7306912e96a94f5f986afeb968127fc7b6b3d513ee6297160adc7bd0008d1cbdfc669d0660e3aa7e8d2c
+  metadata.gz: fdee833532115137ec7e375e83e377c5e21a634b44e0b67bb5954ea3ad04a2983ef3c6ffc5d5deb804b1d94c7b76f04d2cc94b73b054aaa0722f01fd39f58c37
+  data.tar.gz: 23e9990bbf398a067608c29028018840506254f3a8a00a7f6cc56840ec88e70007d0309656b297b20ab31776805b3deccb14e16fface820b0ec7d3340aafc0f3

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 4.11.3 (2026-03-11)
+
+### Bug Fixes
+
+* Fix C++20 compilation error with `std::ostringstream::str` overload (#395)
+* Add `function_traits` specializations for ref-qualified member functions (`&`, `const&`)
+
+### Enhancements
+
+* Support C++20 and C++23 compilation
+* Make C++ standard version configurable via `--with-cxx-standard` in mkmf-rice
+* Add `/Zc:__cplusplus` to MSVC build flags
+* Add CMake-based CI job testing C++17, C++20, and C++23
+* Add test case for function pointer struct attributes
+* Add support for `std::shared_ptr<const T>`
+* Add support for `std::unique_ptr<const T>`
+* Add support for non-constructible objects in std::pair, std::map, std::multimap
+* Add support for wrapping pointers to abstract types that cannot be created nor destroyed
+* Fix converting std::nullptr_t to Ruby
+
 ## 4.11.2 (2026-02-21)
 
 ### Enhancements

data/CMakePresets.json

@@ -116,7 +116,7 @@
       "toolchainFile": "$env{VCPKG_ROOT}\\scripts\\buildsystems\\vcpkg.cmake",
       "cacheVariables": {
         "CMAKE_EXPORT_COMPILE_COMMANDS": "ON",
-        "CMAKE_CXX_FLAGS": "/EHs /W4 /bigobj /utf-8 /D_CRT_SECURE_NO_DEPRECATE /D_CRT_NONSTDC_NO_DEPRECATE"
+        "CMAKE_CXX_FLAGS": "/EHs /W4 /bigobj /utf-8 /Zc:__cplusplus /D_CRT_SECURE_NO_DEPRECATE /D_CRT_NONSTDC_NO_DEPRECATE"
       },
       "condition": {
         "type": "equals",
@@ -155,7 +155,7 @@
       "cacheVariables": {
         "CMAKE_BUILD_TYPE": "Debug",
         "CMAKE_CXX_COMPILER": "clang-cl.exe",
-        "CMAKE_CXX_FLAGS": "/EHs /W4 /bigobj /utf-8 /D_CRT_SECURE_NO_DEPRECATE /D_CRT_NONSTDC_NO_DEPRECATE /clang:-Wno-unused-private-field",
+        "CMAKE_CXX_FLAGS": "/EHs /W4 /bigobj /utf-8 /Zc:__cplusplus /D_CRT_SECURE_NO_DEPRECATE /D_CRT_NONSTDC_NO_DEPRECATE /clang:-Wno-unused-private-field",
         "CMAKE_CXX_FLAGS_DEBUG": "/Od /Zi"
       }
     },
@@ -166,7 +166,7 @@
       "cacheVariables": {
         "CMAKE_BUILD_TYPE": "Release",
         "CMAKE_CXX_COMPILER": "clang-cl.exe",
-        "CMAKE_CXX_FLAGS": "/EHs /W4 /bigobj /utf-8 /D_CRT_SECURE_NO_DEPRECATE /D_CRT_NONSTDC_NO_DEPRECATE /clang:-Wno-unused-private-field",
+        "CMAKE_CXX_FLAGS": "/EHs /W4 /bigobj /utf-8 /Zc:__cplusplus /D_CRT_SECURE_NO_DEPRECATE /D_CRT_NONSTDC_NO_DEPRECATE /clang:-Wno-unused-private-field",
         "CMAKE_CXX_FLAGS_RELEASE": "/O2 /DNDEBUG",
         "CMAKE_INTERPROCEDURAL_OPTIMIZATION": "ON"
       }

data/include/rice/rice.hpp

@@ -556,6 +556,27 @@ namespace Rice::detail
   {
   };
 
+  // ref-qualified member Functions on C++ classes (C++20 uses these for std library types)
+  template<typename Return_T, typename Class_T, typename...Parameter_Ts>
+  struct function_traits<Return_T(Class_T::*)(Parameter_Ts...) &> : public function_traits<Return_T(Class_T*, Parameter_Ts...)>
+  {
+  };
+
+  template<typename Return_T, typename Class_T, typename...Parameter_Ts>
+  struct function_traits<Return_T(Class_T::*)(Parameter_Ts...) const&> : public function_traits<Return_T(Class_T*, Parameter_Ts...)>
+  {
+  };
+
+  template<typename Return_T, typename Class_T, typename...Parameter_Ts>
+  struct function_traits<Return_T(Class_T::*)(Parameter_Ts...) & noexcept> : public function_traits<Return_T(Class_T*, Parameter_Ts...)>
+  {
+  };
+
+  template<typename Return_T, typename Class_T, typename...Parameter_Ts>
+  struct function_traits<Return_T(Class_T::*)(Parameter_Ts...) const& noexcept> : public function_traits<Return_T(Class_T*, Parameter_Ts...)>
+  {
+  };
+
   /*// Functors and lambdas
   template<class Function_T>
   struct function_traits<Function_T&> : public function_traits<Function_T>
@@ -8854,31 +8875,15 @@ namespace Rice::detail
       }
     }
 
-    void* convert(VALUE value)
+    std::nullptr_t convert(VALUE value)
     {
       if (value == Qnil)
       {
         return nullptr;
       }
 
-      if (this->arg_ && this->arg_->isOpaque())
-      {
-        return (void*)value;
-      }
-
-      switch (rb_type(value))
-      {
-        case RUBY_T_NIL:
-        {
-          return nullptr;
-          break;
-        }
-        default:
-        {
-          throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
-            detail::protect(rb_obj_classname, value), "nil");
-        }
-      }
+      throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
+        detail::protect(rb_obj_classname, value), "nil");
     }
   private:
     Arg* arg_ = nullptr;
@@ -10277,7 +10282,9 @@ namespace Rice::detail
 
     if constexpr (is_complete_v<T>)
     {
-      if constexpr (std::is_destructible_v<T>)
+      // is_abstract_v requires a complete type, so nest inside is_complete_v.
+      // Deleting an abstract class through a non-virtual destructor is UB.
+      if constexpr (std::is_destructible_v<T> && !std::is_abstract_v<T>)
       {
         if (this->isOwner_)
         {

data/include/rice/stl.hpp

@@ -1133,8 +1133,12 @@ namespace Rice::stl
 
     void define_methods()
     {
+#if __cplusplus >= 202002L
+      klass_.define_method<std::string(std::ostringstream::*)() const&>("str", &std::ostringstream::str)
+#else
       klass_.define_method<std::string(std::ostringstream::*)() const>("str", &std::ostringstream::str)
-            .define_method("str=", [](std::ostringstream& stream, const std::string& s) { stream.str(s); }, Arg("str"));
+#endif
+      .define_method("str=", [](std::ostringstream& stream, const std::string& s) { stream.str(s); }, Arg("str"));
 
       rb_define_alias(klass_, "to_s", "str");
     }
@@ -1310,8 +1314,12 @@ namespace Rice
     private:
       void define_constructors()
       {
-        klass_.define_constructor(Constructor<T>())
-              .define_constructor(Constructor<T, First_Parameter_T, Second_Parameter_T>(), Arg("x").keepAlive(), Arg("y").keepAlive());
+        if constexpr (std::is_default_constructible_v<T>)
+        {
+          klass_.define_constructor(Constructor<T>());
+        }
+
+        klass_.define_constructor(Constructor<T, First_Parameter_T, Second_Parameter_T>(), Arg("x").keepAlive(), Arg("y").keepAlive());
 
         if constexpr (std::is_copy_constructible_v<First_T> && std::is_copy_constructible_v<Second_T>)
         {
@@ -1650,7 +1658,7 @@ namespace Rice
             }, Arg("key"))
           .define_method("[]=", [](T& map, Key_T key, Mapped_Parameter_T value) -> Mapped_T
             {
-              map[key] = value;
+              map.insert_or_assign(key, value);
               return value;
             }, Arg("key").keepAlive(), Arg("value").keepAlive());
 
@@ -1772,7 +1780,7 @@ namespace Rice
         // exceptions propogate back to Ruby
         return cpp_protect([&]
         {
-          result->operator[](From_Ruby<T>().convert(key)) = From_Ruby<U>().convert(value);
+          result->insert_or_assign(From_Ruby<T>().convert(key), From_Ruby<U>().convert(value));
           return ST_CONTINUE;
         });
       }
@@ -3201,7 +3209,11 @@ namespace Rice
 
     if constexpr (detail::is_complete_v<T> && !std::is_void_v<T>)
     {
-      result.define_constructor(Constructor<SharedPtr_T, typename SharedPtr_T::element_type*>(), Arg("value").takeOwnership());
+      // is_abstract_v requires a complete type, so it must be nested inside the is_complete_v check
+      if constexpr (!std::is_abstract_v<T>)
+      {
+        result.define_constructor(Constructor<SharedPtr_T, typename SharedPtr_T::element_type*>(), Arg("value").takeOwnership());
+      }
     }
 
     // Forward methods to wrapped T
@@ -3256,7 +3268,7 @@ namespace Rice::detail
     }
     else if (rb_typeddata_inherited_p(this->inner_rb_data_type_, requestedType))
     {
-      return this->data_.get();
+      return (void*)this->data_.get();
     }
     else
     {
@@ -3931,7 +3943,7 @@ namespace Rice::detail
     }
     else if (rb_typeddata_inherited_p(this->inner_rb_data_type_, requestedType))
     {
-      return this->data_.get();
+      return (void*)this->data_.get();
     }
     else
     {
@@ -4171,7 +4183,7 @@ namespace Rice
             }, Arg("key"))
           .define_method("[]=", [](T& unordered_map, Key_T key, Mapped_Parameter_T value) -> Mapped_T
             {
-              unordered_map[key] = value;
+              unordered_map.insert_or_assign(key, value);
               return value;
             }, Arg("key").keepAlive(), Arg("value").keepAlive());
 
@@ -4293,7 +4305,7 @@ namespace Rice
         // exceptions propogate back to Ruby
         return cpp_protect([&]
         {
-          result->operator[](From_Ruby<T>().convert(key)) = From_Ruby<U>().convert(value);
+          result->insert_or_assign(From_Ruby<T>().convert(key), From_Ruby<U>().convert(value));
           return ST_CONTINUE;
         });
       }

data/lib/mkmf-rice.rb

@@ -24,14 +24,16 @@ end
 # Now pull in the C++ support
 include MakeMakefile['C++']
 
-# Rice needs c++17.
+# Rice needs c++17 or higher. Use --with-cxx-standard=20 to override.
+std = with_config('cxx-standard', '17')
+
 if IS_MSWIN
-  $CXXFLAGS += " /std:c++17 /EHs /permissive- /bigobj /utf-8"
+  $CXXFLAGS += " /std:c++#{std} /EHs /permissive- /bigobj /utf-8 /Zc:__cplusplus"
   $CPPFLAGS += " -D_ALLOW_KEYWORD_MACROS -D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE"
 elsif IS_MINGW
-  $CXXFLAGS += " -std=c++17 -Wa,-mbig-obj"
+  $CXXFLAGS += " -std=c++#{std} -Wa,-mbig-obj"
 else
-  $CXXFLAGS += " -std=c++17"
+  $CXXFLAGS += " -std=c++#{std}"
 end
 
 # Rice needs to include its header. Let's setup the include path

data/lib/rice/version.rb

@@ -1,3 +1,3 @@
 module Rice
-  VERSION = "4.11.2"
+  VERSION = "4.11.3"
 end

data/rice/detail/Wrapper.ipp

@@ -121,7 +121,9 @@ namespace Rice::detail
 
     if constexpr (is_complete_v<T>)
     {
-      if constexpr (std::is_destructible_v<T>)
+      // is_abstract_v requires a complete type, so nest inside is_complete_v.
+      // Deleting an abstract class through a non-virtual destructor is UB.
+      if constexpr (std::is_destructible_v<T> && !std::is_abstract_v<T>)
       {
         if (this->isOwner_)
         {

data/rice/detail/from_ruby.ipp

@@ -1608,31 +1608,15 @@ namespace Rice::detail
       }
     }
 
-    void* convert(VALUE value)
+    std::nullptr_t convert(VALUE value)
     {
       if (value == Qnil)
       {
         return nullptr;
       }
 
-      if (this->arg_ && this->arg_->isOpaque())
-      {
-        return (void*)value;
-      }
-
-      switch (rb_type(value))
-      {
-        case RUBY_T_NIL:
-        {
-          return nullptr;
-          break;
-        }
-        default:
-        {
-          throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
-            detail::protect(rb_obj_classname, value), "nil");
-        }
-      }
+      throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
+        detail::protect(rb_obj_classname, value), "nil");
     }
   private:
     Arg* arg_ = nullptr;

data/rice/stl/map.ipp

@@ -156,7 +156,7 @@ namespace Rice
             }, Arg("key"))
           .define_method("[]=", [](T& map, Key_T key, Mapped_Parameter_T value) -> Mapped_T
             {
-              map[key] = value;
+              map.insert_or_assign(key, value);
               return value;
             }, Arg("key").keepAlive(), Arg("value").keepAlive());
 
@@ -278,7 +278,7 @@ namespace Rice
         // exceptions propogate back to Ruby
         return cpp_protect([&]
         {
-          result->operator[](From_Ruby<T>().convert(key)) = From_Ruby<U>().convert(value);
+          result->insert_or_assign(From_Ruby<T>().convert(key), From_Ruby<U>().convert(value));
           return ST_CONTINUE;
         });
       }

data/rice/stl/ostream.ipp

@@ -59,8 +59,12 @@ namespace Rice::stl
 
     void define_methods()
     {
+#if __cplusplus >= 202002L
+      klass_.define_method<std::string(std::ostringstream::*)() const&>("str", &std::ostringstream::str)
+#else
       klass_.define_method<std::string(std::ostringstream::*)() const>("str", &std::ostringstream::str)
-            .define_method("str=", [](std::ostringstream& stream, const std::string& s) { stream.str(s); }, Arg("str"));
+#endif
+      .define_method("str=", [](std::ostringstream& stream, const std::string& s) { stream.str(s); }, Arg("str"));
 
       rb_define_alias(klass_, "to_s", "str");
     }

data/rice/stl/pair.ipp

@@ -24,8 +24,12 @@ namespace Rice
     private:
       void define_constructors()
       {
-        klass_.define_constructor(Constructor<T>())
-              .define_constructor(Constructor<T, First_Parameter_T, Second_Parameter_T>(), Arg("x").keepAlive(), Arg("y").keepAlive());
+        if constexpr (std::is_default_constructible_v<T>)
+        {
+          klass_.define_constructor(Constructor<T>());
+        }
+
+        klass_.define_constructor(Constructor<T, First_Parameter_T, Second_Parameter_T>(), Arg("x").keepAlive(), Arg("y").keepAlive());
 
         if constexpr (std::is_copy_constructible_v<First_T> && std::is_copy_constructible_v<Second_T>)
         {

data/rice/stl/shared_ptr.ipp

@@ -32,7 +32,11 @@ namespace Rice
 
     if constexpr (detail::is_complete_v<T> && !std::is_void_v<T>)
     {
-      result.define_constructor(Constructor<SharedPtr_T, typename SharedPtr_T::element_type*>(), Arg("value").takeOwnership());
+      // is_abstract_v requires a complete type, so it must be nested inside the is_complete_v check
+      if constexpr (!std::is_abstract_v<T>)
+      {
+        result.define_constructor(Constructor<SharedPtr_T, typename SharedPtr_T::element_type*>(), Arg("value").takeOwnership());
+      }
     }
 
     // Forward methods to wrapped T
@@ -87,7 +91,7 @@ namespace Rice::detail
     }
     else if (rb_typeddata_inherited_p(this->inner_rb_data_type_, requestedType))
     {
-      return this->data_.get();
+      return (void*)this->data_.get();
     }
     else
     {

data/rice/stl/unique_ptr.ipp

@@ -83,7 +83,7 @@ namespace Rice::detail
     }
     else if (rb_typeddata_inherited_p(this->inner_rb_data_type_, requestedType))
     {
-      return this->data_.get();
+      return (void*)this->data_.get();
     }
     else
     {

data/rice/stl/unordered_map.ipp

@@ -156,7 +156,7 @@ namespace Rice
             }, Arg("key"))
           .define_method("[]=", [](T& unordered_map, Key_T key, Mapped_Parameter_T value) -> Mapped_T
             {
-              unordered_map[key] = value;
+              unordered_map.insert_or_assign(key, value);
               return value;
             }, Arg("key").keepAlive(), Arg("value").keepAlive());
 
@@ -278,7 +278,7 @@ namespace Rice
         // exceptions propogate back to Ruby
         return cpp_protect([&]
         {
-          result->operator[](From_Ruby<T>().convert(key)) = From_Ruby<U>().convert(value);
+          result->insert_or_assign(From_Ruby<T>().convert(key), From_Ruby<U>().convert(value));
           return ST_CONTINUE;
         });
       }

data/rice/traits/function_traits.hpp

@@ -102,6 +102,27 @@ namespace Rice::detail
   {
   };
 
+  // ref-qualified member Functions on C++ classes (C++20 uses these for std library types)
+  template<typename Return_T, typename Class_T, typename...Parameter_Ts>
+  struct function_traits<Return_T(Class_T::*)(Parameter_Ts...) &> : public function_traits<Return_T(Class_T*, Parameter_Ts...)>
+  {
+  };
+
+  template<typename Return_T, typename Class_T, typename...Parameter_Ts>
+  struct function_traits<Return_T(Class_T::*)(Parameter_Ts...) const&> : public function_traits<Return_T(Class_T*, Parameter_Ts...)>
+  {
+  };
+
+  template<typename Return_T, typename Class_T, typename...Parameter_Ts>
+  struct function_traits<Return_T(Class_T::*)(Parameter_Ts...) & noexcept> : public function_traits<Return_T(Class_T*, Parameter_Ts...)>
+  {
+  };
+
+  template<typename Return_T, typename Class_T, typename...Parameter_Ts>
+  struct function_traits<Return_T(Class_T::*)(Parameter_Ts...) const& noexcept> : public function_traits<Return_T(Class_T*, Parameter_Ts...)>
+  {
+  };
+
   /*// Functors and lambdas
   template<class Function_T>
   struct function_traits<Function_T&> : public function_traits<Function_T>

data/test/test_Attribute.cpp

@@ -590,4 +590,35 @@ TESTCASE(KeepAlive)
   // This should work because keepAlive prevents MyClass2 from being GC'd
   ASSERT_NOT_EQUAL(nullptr, dataStruct->myClass2);
   ASSERT_EQUAL(43, dataStruct->myClass2->value);
+}
+
+namespace
+{
+  struct FuncPtrStruct
+  {
+    int (*callback)(int) = nullptr;
+  };
+}
+
+TESTCASE(function_pointer_attribute)
+{
+  Module m = define_module("Testing");
+
+  Class c = define_class<FuncPtrStruct>("FuncPtrStruct")
+    .define_constructor(Constructor<FuncPtrStruct>())
+    .define_attr("callback", &FuncPtrStruct::callback);
+
+  Object o = c.call("new");
+
+  // Set the callback via Ruby using a lambda
+  std::string code = R"(struct = FuncPtrStruct.new
+                        struct.callback = lambda { |x| x * 2 }
+                        struct)";
+
+  Data_Object<FuncPtrStruct> funcPtrStruct = m.module_eval(code);
+
+  // Invoke the callback from C++ to verify it works
+  ASSERT_NOT_EQUAL(nullptr, funcPtrStruct->callback);
+  int result = funcPtrStruct->callback(5);
+  ASSERT_EQUAL(10, result);
 }

data/test/test_Callback.cpp

@@ -55,10 +55,8 @@ TESTCASE(LambdaCallBack)
   ASSERT((globalCallback != nullptr));
 
   int ref = 4;
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wwrite-strings"
-  char* result = triggerCallback(1, 2, true, "hello", ref);
-#pragma GCC diagnostic pop
+  char hello[] = "hello";
+  char* result = triggerCallback(1, 2, true, hello, ref);
   ASSERT_EQUAL("1 - 2.0 - true - hello - 4", result);
 }
 

data/test/test_From_Ruby.cpp

@@ -615,3 +615,17 @@ TESTCASE(void_pointer_array)
   Object result = m.module_eval(code);
   ASSERT_EQUAL("[4, 3, 2, 1]", detail::From_Ruby<std::string>().convert(result.value()));
 }
+
+TESTCASE(nullptr_t)
+{
+  detail::From_Ruby<std::nullptr_t> fromRuby;
+
+  std::nullptr_t result = fromRuby.convert(Qnil);
+  ASSERT_EQUAL(nullptr, result);
+
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    fromRuby.convert(rb_str_new2("not nil")),
+    ASSERT_EQUAL("wrong argument type String (expected nil)", ex.what())
+  );
+}

data/test/test_Stl_Map.cpp

@@ -365,6 +365,62 @@ TESTCASE(NotPrintable)
   ASSERT_EQUAL("[Not printable]", detail::From_Ruby<std::string>().convert(result));
 }
 
+namespace
+{
+  // Type with no default constructor - verifies insert_or_assign works in []=
+  class NoDefaultMap
+  {
+  public:
+    NoDefaultMap(int value) : value_(value) {}
+    int value() const { return value_; }
+
+    bool operator==(const NoDefaultMap& other) const
+    {
+      return this->value_ == other.value_;
+    }
+
+  private:
+    int value_;
+  };
+}
+
+TESTCASE(NoDefaultConstructor)
+{
+  define_class<NoDefaultMap>("NoDefaultMap").
+    define_constructor(Constructor<NoDefaultMap, int>(), Arg("value")).
+    define_method("value", &NoDefaultMap::value);
+
+  Class c = define_map<std::string, NoDefaultMap>("NoDefaultMap_Map");
+
+  Object map = c.call("new");
+
+  // Test []= (insert_or_assign) with non-default-constructible value
+  map.call("[]=", "one", NoDefaultMap(1));
+  map.call("[]=", "two", NoDefaultMap(2));
+
+  Object result = map.call("size");
+  ASSERT_EQUAL(2, detail::From_Ruby<int32_t>().convert(result));
+
+  // Test [] access
+  result = map.call("[]", "one");
+  ASSERT_EQUAL(1, detail::From_Ruby<int>().convert(result.call("value")));
+
+  // Test update existing key
+  map.call("[]=", "one", NoDefaultMap(10));
+  result = map.call("[]", "one");
+  ASSERT_EQUAL(10, detail::From_Ruby<int>().convert(result.call("value")));
+
+  result = map.call("size");
+  ASSERT_EQUAL(2, detail::From_Ruby<int32_t>().convert(result));
+
+  // Test delete
+  result = map.call("delete", "two");
+  ASSERT_EQUAL(2, detail::From_Ruby<int>().convert(result.call("value")));
+
+  result = map.call("size");
+  ASSERT_EQUAL(1, detail::From_Ruby<int32_t>().convert(result));
+}
+
 namespace
 {
   class Comparable

data/test/test_Stl_Pair.cpp

@@ -144,6 +144,38 @@ TESTCASE(AutoRegister)
   ASSERT(result.is_instance_of(pair.class_of()));
 }
 
+namespace
+{
+  // Type with no default constructor - like cv::detail::tracking::tbm::Track
+  class NoDefault
+  {
+  public:
+    NoDefault(int value) : value_(value) {}
+    int value() const { return value_; }
+  private:
+    int value_;
+  };
+}
+
+TESTCASE(PairNoDefaultConstructor)
+{
+  define_class<NoDefault>("NoDefault").
+    define_constructor(Constructor<NoDefault, int>(), Arg("value")).
+    define_method("value", &NoDefault::value);
+
+  // This should compile and work even though NoDefault has no default constructor.
+  // The pair's default constructor should be skipped, but the two-argument constructor should work.
+  Class c = define_pair<const int, NoDefault>("IntNoDefaultPair");
+
+  Object pair = c.call("new", 42, NoDefault(7));
+
+  Object result = pair.call("first");
+  ASSERT_EQUAL(42, detail::From_Ruby<int>().convert(result));
+
+  result = pair.call("second");
+  ASSERT_EQUAL(7, detail::From_Ruby<int>().convert(result.call("value")));
+}
+
 namespace
 {
   struct SomeStruct

data/test/test_Stl_SharedPtr.cpp

@@ -609,6 +609,99 @@ TESTCASE(InheritedForwarding)
   ASSERT_EQUAL(456, detail::From_Ruby<int>().convert(result));
 }
 
+// --- shared_ptr<const T> tests ---
+// When shared_ptr wraps a const T, the Wrapper::get() method must handle
+// the const-to-void* conversion. Without a cast, data_.get() returns
+// const T* which cannot implicitly convert to void*.
+namespace
+{
+  class ConstTarget
+  {
+  public:
+    int value;
+
+    ConstTarget() : value(0) {}
+    ConstTarget(int v) : value(v) {}
+
+    int getValue() const { return value; }
+  };
+
+  std::shared_ptr<const ConstTarget> createConstTarget(int v)
+  {
+    return std::make_shared<const ConstTarget>(v);
+  }
+
+  int extractConstTargetValue(std::shared_ptr<const ConstTarget> ptr)
+  {
+    return ptr->getValue();
+  }
+}
+
+TESTCASE(SharedPtrConstT)
+{
+  define_class<ConstTarget>("ConstTarget").
+    define_constructor(Constructor<ConstTarget, int>(),
+      Arg("v")).
+    define_method("get_value", &ConstTarget::getValue);
+
+  Module m = define_module("SharedPtrConstTest").
+    define_module_function("create_const_target", &createConstTarget).
+    define_module_function("extract_const_target_value", &extractConstTargetValue);
+
+  // Test that shared_ptr<const T> can be unwrapped to access the inner T
+  std::string code = R"(ptr = create_const_target(42)
+                        extract_const_target_value(ptr))";
+
+  Object result = m.instance_eval(code);
+  ASSERT_EQUAL(42, detail::From_Ruby<int>().convert(result.value()));
+}
+
+// Abstract class with non-virtual destructor - like cv::cudacodec::NVSurfaceToColorConverter
+namespace
+{
+  class AbstractClass
+  {
+  public:
+    virtual bool compute(int value) const = 0;
+    ~AbstractClass() {}  // non-virtual destructor
+  };
+
+  class ConcreteImpl : public AbstractClass
+  {
+  public:
+    bool compute(int value) const override { return value > 0; }
+  };
+
+  std::shared_ptr<AbstractClass> createAbstract()
+  {
+    return std::make_shared<ConcreteImpl>();
+  }
+
+  bool useAbstract(std::shared_ptr<AbstractClass> ptr, int value)
+  {
+    return ptr->compute(value);
+  }
+}
+
+TESTCASE(SharedPtrAbstractT)
+{
+  // shared_ptr<T> where T is abstract should NOT define a constructor taking T*,
+  // because deleting through a non-virtual destructor on an abstract class is UB.
+  define_class<AbstractClass>("AbstractClass").
+    define_method("compute", &AbstractClass::compute,
+      Arg("value"));
+
+  Module m = define_module("SharedPtrAbstractTest").
+    define_module_function("create_abstract", &createAbstract).
+    define_module_function("use_abstract", &useAbstract);
+
+  std::string code = R"(ptr = create_abstract
+                        use_abstract(ptr, 5))";
+
+  Object result = m.instance_eval(code);
+  ASSERT_EQUAL(Qtrue, result.value());
+}
+
 // Forward declaration only - IncompleteClass is never defined
 class IncompleteClass;
 

data/test/test_Stl_UniquePtr.cpp

@@ -252,4 +252,51 @@ TESTCASE(Release)
     Exception,
     m.module_eval(code),
     ASSERT(std::string(ex.what()).find("undefined method") == 0));
+}
+
+// --- unique_ptr<const T> tests ---
+// When unique_ptr wraps a const T, the Wrapper::get() method must handle
+// the const-to-void* conversion. Without a cast, data_.get() returns
+// const T* which cannot implicitly convert to void*.
+namespace
+{
+  class ConstTarget
+  {
+  public:
+    int value;
+
+    ConstTarget() : value(0) {}
+    ConstTarget(int v) : value(v) {}
+
+    int getValue() const { return value; }
+  };
+
+  std::unique_ptr<const ConstTarget> createConstTarget(int v)
+  {
+    return std::make_unique<const ConstTarget>(v);
+  }
+
+  int extractConstTargetValue(const std::unique_ptr<const ConstTarget>& ptr)
+  {
+    return ptr->getValue();
+  }
+}
+
+TESTCASE(UniquePtrConstT)
+{
+  define_class<ConstTarget>("ConstTarget").
+    define_constructor(Constructor<ConstTarget, int>(),
+      Arg("v")).
+    define_method("get_value", &ConstTarget::getValue);
+
+  Module m = define_module("UniquePtrConstTest").
+    define_module_function("create_const_target", &createConstTarget).
+    define_module_function("extract_const_target_value", &extractConstTargetValue);
+
+  // Test that unique_ptr<const T> can be unwrapped to access the inner T
+  std::string code = R"(ptr = create_const_target(42)
+                        extract_const_target_value(ptr))";
+
+  Object result = m.instance_eval(code);
+  ASSERT_EQUAL(42, detail::From_Ruby<int>().convert(result.value()));
 }

data/test/test_Stl_Unordered_Map.cpp

@@ -357,6 +357,62 @@ TESTCASE(NotPrintable)
   ASSERT_EQUAL("[Not printable]", detail::From_Ruby<std::string>().convert(result));
 }
 
+namespace
+{
+  // Type with no default constructor - verifies insert_or_assign works in []=
+  class NoDefaultUnorderedMap
+  {
+  public:
+    NoDefaultUnorderedMap(int value) : value_(value) {}
+    int value() const { return value_; }
+
+    bool operator==(const NoDefaultUnorderedMap& other) const
+    {
+      return this->value_ == other.value_;
+    }
+
+  private:
+    int value_;
+  };
+}
+
+TESTCASE(NoDefaultConstructor)
+{
+  define_class<NoDefaultUnorderedMap>("NoDefaultUnorderedMap").
+    define_constructor(Constructor<NoDefaultUnorderedMap, int>(), Arg("value")).
+    define_method("value", &NoDefaultUnorderedMap::value);
+
+  Class c = define_unordered_map<std::string, NoDefaultUnorderedMap>("NoDefaultUnorderedMap_Map");
+
+  Object map = c.call("new");
+
+  // Test []= (insert_or_assign) with non-default-constructible value
+  map.call("[]=", "one", NoDefaultUnorderedMap(1));
+  map.call("[]=", "two", NoDefaultUnorderedMap(2));
+
+  Object result = map.call("size");
+  ASSERT_EQUAL(2, detail::From_Ruby<int32_t>().convert(result));
+
+  // Test [] access
+  result = map.call("[]", "one");
+  ASSERT_EQUAL(1, detail::From_Ruby<int>().convert(result.call("value")));
+
+  // Test update existing key
+  map.call("[]=", "one", NoDefaultUnorderedMap(10));
+  result = map.call("[]", "one");
+  ASSERT_EQUAL(10, detail::From_Ruby<int>().convert(result.call("value")));
+
+  result = map.call("size");
+  ASSERT_EQUAL(2, detail::From_Ruby<int32_t>().convert(result));
+
+  // Test delete
+  result = map.call("delete", "two");
+  ASSERT_EQUAL(2, detail::From_Ruby<int>().convert(result.call("value")));
+
+  result = map.call("size");
+  ASSERT_EQUAL(1, detail::From_Ruby<int32_t>().convert(result));
+}
+
 namespace
 {
   class Comparable

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rice
 version: !ruby/object:Gem::Version
-  version: 4.11.2
+  version: 4.11.3
 platform: ruby
 authors:
 - Paul Brannan