ruby-qt6-rice 6.2.0 → 6.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6a6aeeea52c229e9ec9107f0a878f810f4da0f57f1125e4d234a7cbee9f34f26
-  data.tar.gz: b4a14875c07b82212e67509d0ca6554390a841e1c27a477a249f21329d67f223
+  metadata.gz: 7e2a94980ff633cdca492697fb85cbf928ffd56f15a331a2f0c333b38ac225d5
+  data.tar.gz: 33f79c9e4d15dcc41ca59680c4e0250873824e70a29deaf6c6869989a0f0d48f
 SHA512:
-  metadata.gz: 1a0e49a306ecd7bb4cee1081b75e46255cb2d8a94a1da790d6b7863b1eecb657111a324faea87076eedd950471f049f8f9f21b718a8d476e7cf12d7b1b484bd3
-  data.tar.gz: e8e55d43cabc562f8570fbb84c14405d336b37a2b31501c8f10f818c8911ff2bf53dc43db5fea72f1f6a1783edb78bcfd0540ce6b877d33850591b7cc948ae90
+  metadata.gz: d06f805fa53f1960d9a9a1e656f9d1f217c69ef0ec54afc5f9f9597307760600e485307c90089673aa5dcbf806bf3863c0f3aceedc9a0725103260f19e1667b4
+  data.tar.gz: 1f000daa8dfc865a39bd3e589713cf2ad065da20c67b130a9862c9c38146015fd79784e35d8c9f19dc2eff9dde3110cd1c42c24a76b474512f586bb43fbb254a

data/include/rice/core/rice.hpp

@@ -189,6 +189,9 @@ namespace Rice4RubyQt6
     constexpr bool is_ostreamable_v = is_ostreamable<T>::value;
 
     // Is the type comparable?
+    // Libraries with unconstrained operator== declarations may specialize this
+    // trait to false when equality is not actually usable by Rice's STL
+    // wrappers.
     template<typename T, typename SFINAE = void>
     struct is_comparable : std::false_type {};
 
@@ -556,6 +559,27 @@ namespace Rice4RubyQt6::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>
@@ -838,6 +862,7 @@ namespace Rice4RubyQt6::detail
 // =========   Anchor.hpp   =========
 
 #include <ruby.h>
+#include <ruby/vm.h>
 
 namespace Rice4RubyQt6
 {
@@ -872,7 +897,6 @@ namespace Rice4RubyQt6
       VALUE get() const;
 
     private:
-      static void disable(VALUE);
       static void registerExitHandler();
 
       inline static bool enabled_ = true;
@@ -1073,6 +1097,7 @@ namespace Rice4RubyQt6
         break;
       case RUBY_TAG_THROW:
         this->message_ = "Unexpected throw";
+        break;
       case RUBY_TAG_RAISE:
         this->message_ = "Ruby exception was thrown";
         break;
@@ -1569,6 +1594,7 @@ namespace Rice4RubyQt6::detail
     static constexpr double SignedToUnsigned = 0.5;// Penalty for signed to unsigned (can't represent negatives)
     static constexpr double FloatToInt = 0.5;      // Domain change penalty when converting float to int (lossy)
     static constexpr double ConstMismatch = 0.99;  // Penalty for const mismatch
+    static constexpr double RValueMismatch = 0.98; // Prefer borrowing wrapped objects over moving from them
   };
 }
 
@@ -1646,23 +1672,28 @@ namespace Rice4RubyQt6
 {
   namespace detail
   {
-    inline Anchor::Anchor(VALUE value) : value_(value)
+    inline Anchor::Anchor(VALUE value)
     {
+      // rb_gc_register_address() can trigger GC, so we must register the
+      // empty this->value_ slot before storing a heap VALUE in it.
+      // RB_GC_GUARD(value) keeps the ctor argument alive through the end of
+      // this method until the registered slot has been updated.
       if (!RB_SPECIAL_CONST_P(value))
       {
         Anchor::registerExitHandler();
         detail::protect(rb_gc_register_address, &this->value_);
         this->registered_ = true;
       }
+      this->value_ = value;
+      RB_GC_GUARD(value);
     }
 
     inline Anchor::~Anchor()
     {
       if (Anchor::enabled_ && this->registered_)
       {
-        detail::protect(rb_gc_unregister_address, &this->value_);
+        rb_gc_unregister_address(&this->value_);
       }
-      // Ruby auto detects VALUEs in the stack, so make sure up in case this object is on the stack
       this->registered_ = false;
       this->value_ = Qnil;
     }
@@ -1672,17 +1703,18 @@ namespace Rice4RubyQt6
       return this->value_;
     }
 
-    // This will be called by ruby at exit - we want to disable further unregistering
-    inline void Anchor::disable(VALUE)
-    {
-      Anchor::enabled_ = false;
-    }
-
     inline void Anchor::registerExitHandler()
     {
       if (!Anchor::exitHandlerRegistered_)
       {
-        detail::protect(rb_set_end_proc, &Anchor::disable, Qnil);
+        // Use ruby_vm_at_exit which fires AFTER the VM is destroyed,
+        // not rb_set_end_proc which fires BEFORE. rb_set_end_proc
+        // runs as an end_proc in LIFO order alongside at_exit blocks,
+        // so its timing depends on require order — if the extension
+        // loads after minitest/autorun, the disable callback runs
+        // before tests execute, causing Anchor destructors to skip
+        // rb_gc_unregister_address and leave dangling root pointers.
+        ruby_vm_at_exit([](ruby_vm_t*) { Anchor::enabled_ = false; });
         Anchor::exitHandlerRegistered_ = true;
       }
     }
@@ -2005,7 +2037,7 @@ namespace Rice4RubyQt6
     *  \endcode
     */
     template<typename ...Parameter_Ts>
-    Object call(Identifier id, Parameter_Ts... args) const;
+    Object call(Identifier id, Parameter_Ts&&... args) const;
 
     //! Call the Ruby method specified by 'id' on object 'obj'.
     /*! Pass in arguments (arg1, arg2, ...).  The arguments will be converted to
@@ -2028,7 +2060,7 @@ namespace Rice4RubyQt6
     *  \endcode
     */
     template<typename ...Parameter_Ts>
-    Object call_kw(Identifier id, Parameter_Ts... args) const;
+    Object call_kw(Identifier id, Parameter_Ts&&... args) const;
 
     //! Vectorized call.
     /*! Calls the method identified by id with the list of arguments
@@ -4261,7 +4293,7 @@ namespace Rice4RubyQt6
 
   public:
     Reference();
-    Reference(T& data);
+    Reference(const T& data);
     Reference(VALUE value);
     T& get();
 
@@ -4270,7 +4302,7 @@ namespace Rice4RubyQt6
   };
 
   // Specialization needed when VALUE type matches T, causing constructor ambiguity
-  // between Reference(T&) and Reference(VALUE). VALUE is unsigned long when
+  // between Reference(const T&) and Reference(VALUE). VALUE is unsigned long when
   // SIZEOF_LONG == SIZEOF_VOIDP (Linux/macOS) and unsigned long long when
   // SIZEOF_LONG_LONG == SIZEOF_VOIDP (Windows x64).
 #if SIZEOF_LONG == SIZEOF_VOIDP
@@ -4442,6 +4474,12 @@ namespace Rice4RubyQt6::detail
         {
           result = Convertible::None;
         }
+        // Existing wrapped Ruby objects should prefer borrowing overloads to
+        // rvalue-reference overloads so they are not silently moved-from.
+        else if constexpr (std::is_rvalue_reference_v<T>)
+        {
+          result = Convertible::RValueMismatch;
+        }
         // It is ok to send a non-const value to a const parameter but
         // prefer non-const to non-const by slightly decreasing the score
         else if (!isConst && is_const_any_v<T>)
@@ -4478,6 +4516,11 @@ namespace Rice4RubyQt6::detail
     {
       return this->fromRuby_.convert(valueOpt.value());
     }
+    else if constexpr (std::is_rvalue_reference_v<T>)
+    {
+      // Rvalue-reference parameters cannot safely use stored default values.
+      // Materializing them from std::any would require moving from shared state.
+    }
     // Remember std::is_copy_constructible_v<std::vector<std::unique_ptr<T>>>> returns true. Sigh.
     // So special case vector handling
     else if constexpr (detail::is_std_vector_v<detail::intrinsic_type<T>>)
@@ -6442,6 +6485,25 @@ namespace Rice4RubyQt6
       Arg* arg_ = nullptr;
     };
 
+    template<>
+    class To_Ruby<char*&>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(const char* data)
+      {
+        return To_Ruby<char*>(arg_).convert(data);
+      }
+
+    private:
+      Arg* arg_ = nullptr;
+    };
+
     template<int N>
     class To_Ruby<char[N]>
     {
@@ -6474,6 +6536,25 @@ namespace Rice4RubyQt6
       Arg* arg_ = nullptr;
     };
 
+    template<int N>
+    class To_Ruby<char(&)[N]>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(const char (&buffer)[N])
+      {
+        return To_Ruby<char[N]>(arg_).convert(buffer);
+      }
+
+    private:
+      Arg* arg_ = nullptr;
+    };
+
     // ===========  unsigned char  ============
     template<>
     class To_Ruby<unsigned char>
@@ -7195,6 +7276,25 @@ namespace Rice4RubyQt6
       Arg* arg_ = nullptr;
     };
 
+    template<>
+    class To_Ruby<std::nullptr_t&>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(std::nullptr_t const)
+      {
+        return Qnil;
+      }
+
+    private:
+      Arg* arg_ = nullptr;
+    };
+
     // ===========  void  ============
     template<>
     class To_Ruby<void>
@@ -7253,6 +7353,7 @@ namespace Rice4RubyQt6
     };
  }
 }
+
 // =========   from_ruby.ipp   =========
 #include <limits>
 #include <optional>
@@ -8864,31 +8965,15 @@ namespace Rice4RubyQt6::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;
@@ -9049,7 +9134,7 @@ namespace Rice4RubyQt6
   }
 
   template<typename T>
-  inline Reference<T>::Reference(T& data) : data_(data)
+  inline Reference<T>::Reference(const T& data) : data_(data)
   {
   }
 
@@ -10287,7 +10372,10 @@ namespace Rice4RubyQt6::detail
 
     if constexpr (is_complete_v<T>)
     {
-      if constexpr (std::is_destructible_v<T>)
+      // is_polymorphic_v requires a complete type, so nest inside is_complete_v.
+      // Deleting a polymorphic class through a non-virtual destructor is UB,
+      // but it is safe if the destructor is virtual.
+      if constexpr (std::is_destructible_v<T> && (!std::is_polymorphic_v<T> || std::has_virtual_destructor_v<T>))
       {
         if (this->isOwner_)
         {
@@ -12659,6 +12747,25 @@ namespace Rice4RubyQt6::detail
     }
   };
 
+  // Wraps a C++ function as a Ruby proc
+  template<typename Return_T, typename ...Parameter_Ts>
+  class To_Ruby<Return_T(*&)(Parameter_Ts...)>
+  {
+  public:
+    using Proc_T = Return_T(*&)(Parameter_Ts...);
+
+    To_Ruby() = default;
+
+    explicit To_Ruby(Arg*)
+    {}
+
+    VALUE convert(Proc_T proc)
+    {
+      // Wrap the C+++ function pointer as a Ruby Proc
+      return NativeProc<Proc_T>::createRubyProc(std::forward<Proc_T>(proc));
+    }
+  };
+
   // Makes a Ruby proc callable as C callback
   template<typename Return_T, typename ...Parameter_Ts>
   class From_Ruby<Return_T(*)(Parameter_Ts...)>
@@ -12711,53 +12818,6 @@ namespace Rice4RubyQt6
   }
 }
 
-/*namespace Rice4RubyQt6::detail
-{
-  template<>
-  struct Type<Encoding>
-  {
-    static bool verify()
-    {
-      return true;
-    }
-  };
-  
-  template<>
-  class To_Ruby<Encoding>
-  {
-  public:
-    VALUE convert(const Encoding& encoding)
-    {
-    //  return x.value();
-    }
-  };
-
-  template<>
-  class From_Ruby<Encoding>
-  {
-  public:
-    Convertible is_convertible(VALUE value)
-    {
-      switch (rb_type(value))
-      {
-        case RUBY_T_SYMBOL:
-          return Convertible::Exact;
-          break;
-      case RUBY_T_STRING:
-          return Convertible::Cast;
-          break;
-        default:
-          return Convertible::None;
-        }
-    }
-
-    Encoding convert(VALUE value)
-    {
-     // return Symbol(value);
-    }
-  };
-}
-*/
 // =========   Object.ipp   =========
 namespace Rice4RubyQt6
 {
@@ -12803,7 +12863,7 @@ namespace Rice4RubyQt6
   }
 
   template<typename ...Parameter_Ts>
-  inline Object Object::call(Identifier id, Parameter_Ts... args) const
+  inline Object Object::call(Identifier id, Parameter_Ts&&... args) const
   {
     /* IMPORTANT - We store VALUEs in an array that is a local variable.
        That allows the Ruby garbage collector to find them when scanning
@@ -12817,10 +12877,10 @@ namespace Rice4RubyQt6
   }
 
   template<typename ...Parameter_Ts>
-  inline Object Object::call_kw(Identifier id, Parameter_Ts... args) const
+  inline Object Object::call_kw(Identifier id, Parameter_Ts&&... args) const
   {
     /* IMPORTANT - See call() above */
-    std::array<VALUE, sizeof...(Parameter_Ts)> values = { detail::To_Ruby<detail::remove_cv_recursive_t<Parameter_Ts>>().convert(args)... };
+    std::array<VALUE, sizeof...(Parameter_Ts)> values = { detail::To_Ruby<detail::remove_cv_recursive_t<Parameter_Ts>>().convert(std::forward<Parameter_Ts>(args))... };
     return detail::protect(rb_funcallv_kw, this->validated_value(), id.id(), (int)values.size(), (const VALUE*)values.data(), RB_PASS_KEYWORDS);
   }
 
@@ -13168,6 +13228,25 @@ namespace Rice4RubyQt6::detail
       return x.value();
     }
 
+    private:
+    Arg* arg_ = nullptr;
+  };
+
+  template<>
+  class To_Ruby<String&>
+  {
+  public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    VALUE convert(String const& x)
+    {
+      return x.value();
+    }
+
   private:
     Arg* arg_ = nullptr;
   };
@@ -13901,6 +13980,25 @@ namespace Rice4RubyQt6::detail
     Arg* arg_ = nullptr;
   };
 
+  template<>
+  class To_Ruby<Hash&>
+  {
+  public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    VALUE convert(Hash const& x)
+    {
+      return x.value();
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+  };
+
   template<>
   class From_Ruby<Hash>
   {
@@ -15132,7 +15230,7 @@ namespace Rice4RubyQt6
     static void initialize(VALUE self, Parameter_Ts...args)
     {
       // Call C++ constructor
-      T* data = new T(args...);
+      T* data = new T(std::forward<Parameter_Ts>(args)...);
       detail::wrapConstructed<T>(self, Data_Type<T>::ruby_data_type(), data);
     }
 
@@ -15166,11 +15264,12 @@ namespace Rice4RubyQt6
       static void initialize(Object self, Parameter_Ts...args)
       {
         // Call C++ constructor
-        T* data = new T(self, args...);
+        T* data = new T(self, std::forward<Parameter_Ts>(args)...);
         detail::wrapConstructed<T>(self.value(), Data_Type<T>::ruby_data_type(), data);
       }
   };
 }
+
 // =========   Callback.hpp   =========
 
 namespace Rice4RubyQt6
@@ -15533,16 +15632,6 @@ namespace Rice4RubyQt6::detail
     Arg* arg_ = nullptr;
   };
 
-  template<typename T>
-  class To_Ruby<Data_Object<T>>
-  {
-  public:
-    VALUE convert(const Object& x)
-    {
-      return x.value();
-    }
-  };
-
   template <typename T>
   class From_Ruby
   {
@@ -15888,38 +15977,6 @@ namespace Rice4RubyQt6::detail
     Arg* arg_ = nullptr;
     std::vector<Intrinsic_T*> vector_;
   };
-
-  template<typename T>
-  class From_Ruby<Data_Object<T>>
-  {
-    static_assert(!std::is_fundamental_v<intrinsic_type<T>>,
-                  "Data_Object cannot be used with fundamental types");
-
-    static_assert(!std::is_same_v<T, std::map<T, T>> && !std::is_same_v<T, std::unordered_map<T, T>> &&
-                  !std::is_same_v<T, std::monostate> && !std::is_same_v<T, std::multimap<T, T>> &&
-                  !std::is_same_v<T, std::optional<T>> && !std::is_same_v<T, std::pair<T, T>> &&
-                  !std::is_same_v<T, std::set<T>> && !std::is_same_v<T, std::string> &&
-                  !std::is_same_v<T, std::vector<T>>,
-                  "Please include rice/stl.hpp header for STL support");
-
-  public:
-    double is_convertible(VALUE value)
-    {
-      switch (rb_type(value))
-      {
-        case RUBY_T_DATA:
-          return Data_Type<T>::is_descendant(value) ? Convertible::Exact : Convertible::None;
-          break;
-        default:
-          return Convertible::None;
-        }
-    }
-
-    static Data_Object<T> convert(VALUE value)
-    {
-      return Data_Object<T>(value);
-    }
-  };
 }
 
 // =========   Enum.hpp   =========

data/include/rice/core/stl.hpp

@@ -151,9 +151,9 @@ namespace Rice4RubyQt6::stl
       klass_.define_method("initialize", [](VALUE self, VALUE callable) -> void
       {
         // Create std::function that wraps the Ruby callable
-        Function_T* data = new Function_T([callable](auto... args)
+        Function_T* data = new Function_T([callable](auto&&... args)
         {
-          Object result = Object(callable).call("call", args...);
+          Object result = Object(callable).call("call", std::forward<decltype(args)>(args)...);
 
           using Return_T = typename Function_T::result_type;
           if constexpr (!std::is_void_v<Return_T>)
@@ -211,6 +211,146 @@ namespace Rice4RubyQt6
 
 namespace Rice4RubyQt6::detail
 {
+  template<typename Return_T, typename ...Parameter_Ts>
+  inline std::function<Return_T(Parameter_Ts...)> makeRubyFunction(VALUE value)
+  {
+    Pin proc(value);
+
+    return [proc = std::move(proc)](Parameter_Ts... args) -> Return_T
+    {
+      Object result = Object(proc.value()).call("call", std::forward<Parameter_Ts>(args)...);
+
+      if constexpr (!std::is_void_v<Return_T>)
+      {
+        return From_Ruby<std::remove_cv_t<Return_T>>().convert(result);
+      }
+    };
+  }
+
+  template<typename Return_T, typename ...Parameter_Ts>
+  class From_Ruby<std::function<Return_T(Parameter_Ts...)>>
+  {
+  public:
+    using Function_T = std::function<Return_T(Parameter_Ts...)>;
+
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    double is_convertible(VALUE value)
+    {
+      switch (rb_type(value))
+      {
+        case RUBY_T_DATA:
+          return Data_Type<Function_T>::is_descendant(value) ? Convertible::Exact : Convertible::None;
+        default:
+          return protect(rb_obj_is_proc, value) == Qtrue ? Convertible::ConstMismatch : Convertible::None;
+      }
+    }
+
+    Function_T convert(VALUE value)
+    {
+      if (Data_Type<Function_T>::is_descendant(value))
+      {
+        return *detail::unwrap<Function_T>(value, Data_Type<Function_T>::ruby_data_type(), false);
+      }
+      else if (protect(rb_obj_is_proc, value) == Qtrue)
+      {
+        return makeRubyFunction<Return_T, Parameter_Ts...>(value);
+      }
+      else
+      {
+        throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
+          detail::protect(rb_obj_classname, value), "std::function");
+      }
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+  };
+
+  template<typename Return_T, typename ...Parameter_Ts>
+  class From_Ruby<std::function<Return_T(Parameter_Ts...)>&>
+  {
+  public:
+    using Function_T = std::function<Return_T(Parameter_Ts...)>;
+
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    double is_convertible(VALUE value)
+    {
+      return From_Ruby<Function_T>(arg_).is_convertible(value);
+    }
+
+    Function_T& convert(VALUE value)
+    {
+      if (Data_Type<Function_T>::is_descendant(value))
+      {
+        return *detail::unwrap<Function_T>(value, Data_Type<Function_T>::ruby_data_type(), false);
+      }
+      else if (protect(rb_obj_is_proc, value) == Qtrue)
+      {
+        converted_ = makeRubyFunction<Return_T, Parameter_Ts...>(value);
+        return converted_;
+      }
+      else
+      {
+        throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
+          detail::protect(rb_obj_classname, value), "std::function");
+      }
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+    Function_T converted_;
+  };
+
+  template<typename Return_T, typename ...Parameter_Ts>
+  class From_Ruby<std::function<Return_T(Parameter_Ts...)>&&>
+  {
+  public:
+    using Function_T = std::function<Return_T(Parameter_Ts...)>;
+
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    double is_convertible(VALUE value)
+    {
+      return From_Ruby<Function_T>(arg_).is_convertible(value);
+    }
+
+    Function_T&& convert(VALUE value)
+    {
+      if (Data_Type<Function_T>::is_descendant(value))
+      {
+        return std::move(*detail::unwrap<Function_T>(value, Data_Type<Function_T>::ruby_data_type(), false));
+      }
+      else if (protect(rb_obj_is_proc, value) == Qtrue)
+      {
+        converted_ = makeRubyFunction<Return_T, Parameter_Ts...>(value);
+        return std::move(converted_);
+      }
+      else
+      {
+        throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
+          detail::protect(rb_obj_classname, value), "std::function");
+      }
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+    Function_T converted_;
+  };
+
   template<typename Signature_T>
   struct Type<std::function<Signature_T>>
   {
@@ -867,6 +1007,24 @@ namespace Rice4RubyQt6::detail
     Arg* arg_ = nullptr;
   };
 
+  template<>
+  class To_Ruby<std::nullopt_t&>
+  {
+  public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Arg* arg) : arg_(arg)
+    {}
+
+    VALUE convert(const std::nullopt_t&)
+    {
+      return Qnil;
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+  };
+
   template<typename T>
   class To_Ruby<std::optional<T>>
   {
@@ -1133,8 +1291,12 @@ namespace Rice4RubyQt6::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 +1472,12 @@ namespace Rice4RubyQt6
     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>)
         {
@@ -1455,6 +1621,24 @@ namespace Rice4RubyQt6::detail
     Arg* arg_ = nullptr;
   };
 
+  template<typename T>
+  class To_Ruby<std::reference_wrapper<T>&>
+  {
+  public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Arg* arg) : arg_(arg)
+    {}
+
+    VALUE convert(const std::reference_wrapper<T>& data)
+    {
+      return To_Ruby<T&>().convert(data.get());
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+  };
+
   template<typename T>
   class From_Ruby<std::reference_wrapper<T>>
   {
@@ -1618,16 +1802,8 @@ namespace Rice4RubyQt6
             return it != map.end();
           }, Arg("value"));
           rb_define_alias(klass_, "eql?", "==");
+          rb_define_alias(klass_, "has_value", "value?");
         }
-        else
-        {
-          klass_.define_method("value?", [](T&, Mapped_Parameter_T) -> bool
-          {
-              return false;
-          }, Arg("value"));
-        }
-
-        rb_define_alias(klass_, "has_value", "value?");
       }
 
       void define_modify_methods()
@@ -1650,7 +1826,7 @@ namespace Rice4RubyQt6
             }, 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 +1948,7 @@ namespace Rice4RubyQt6
         // 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;
         });
       }
@@ -1961,6 +2137,7 @@ namespace Rice4RubyQt6
   }
 }
 
+
 // =========   monostate.hpp   =========
 
 
@@ -2222,16 +2399,8 @@ namespace Rice4RubyQt6
             return it != multimap.end();
           }, Arg("value"));
           rb_define_alias(klass_, "eql?", "==");
+          rb_define_alias(klass_, "has_value", "value?");
         }
-        else
-        {
-          klass_.define_method("value?", [](T&, Mapped_Parameter_T) -> bool
-          {
-              return false;
-          }, Arg("value"));
-        }
-
-        rb_define_alias(klass_, "has_value", "value?");
       }
 
       void define_modify_methods()
@@ -2546,6 +2715,7 @@ namespace Rice4RubyQt6
   }
 }
 
+
 // =========   set.hpp   =========
 
 namespace Rice4RubyQt6
@@ -2659,23 +2829,23 @@ namespace Rice4RubyQt6
 
       void define_operators()
       {
-        klass_
-          .define_method("<<", [](T& self, Parameter_T value) -> T&
-          {
-            self.insert(value);
-            return self;
-          }, Arg("value").keepAlive())
-          .define_method("==", [](const T& self, const T& other) -> bool
+        klass_.define_method("<<", [](T& self, Parameter_T value) -> T&
+        {
+          self.insert(value);
+          return self;
+        }, Arg("value").keepAlive());
+
+        if constexpr (detail::is_comparable_v<Value_T>)
+        {
+          klass_.define_method("==", [](const T& self, const T& other) -> bool
           {
-            if constexpr (detail::is_comparable_v<Value_T>)
-            {
-              return self == other;
-            }
-            else
-            {
-              return false;
-            }
-          }, Arg("other"))
+            return self == other;
+          }, Arg("other"));
+
+          rb_define_alias(klass_, "eql?", "==");
+        }
+
+        klass_
           .define_method("&", [](const T& self, const T& other) -> T
           {
             T result;
@@ -2722,15 +2892,14 @@ namespace Rice4RubyQt6
             return std::includes(self.begin(), self.end(),
                                  other.begin(), other.end());
           }, Arg("other"));
-        
-          rb_define_alias(klass_, "eql?", "==");
-          rb_define_alias(klass_, "intersection", "&");
-          rb_define_alias(klass_, "union", "|");
-          rb_define_alias(klass_, "difference", "-");
-          rb_define_alias(klass_, "proper_subset?", "<");
-          rb_define_alias(klass_, "subset?", "<");
-          rb_define_alias(klass_, "proper_superset?", ">");
-          rb_define_alias(klass_, "superset?", ">");
+
+        rb_define_alias(klass_, "intersection", "&");
+        rb_define_alias(klass_, "union", "|");
+        rb_define_alias(klass_, "difference", "-");
+        rb_define_alias(klass_, "proper_subset?", "<");
+        rb_define_alias(klass_, "subset?", "<");
+        rb_define_alias(klass_, "proper_superset?", ">");
+        rb_define_alias(klass_, "superset?", ">");
       }
 
       void define_enumerable()
@@ -3201,7 +3370,11 @@ namespace Rice4RubyQt6
 
     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 +3429,7 @@ namespace Rice4RubyQt6::detail
     }
     else if (rb_typeddata_inherited_p(this->inner_rb_data_type_, requestedType))
     {
-      return this->data_.get();
+      return (void*)this->data_.get();
     }
     else
     {
@@ -3853,6 +4026,9 @@ namespace Rice4RubyQt6
   template<typename T>
   Data_Type<std::unique_ptr<T>> define_unique_ptr(std::string klassName)
   {
+    static_assert(detail::is_complete_v<T>,
+      "Rice does not support binding std::unique_ptr<T> when T is incomplete.");
+
     using UniquePtr_T = std::unique_ptr<T>;
     using Data_Type_T = Data_Type<UniquePtr_T>;
 
@@ -3931,7 +4107,7 @@ namespace Rice4RubyQt6::detail
     }
     else if (rb_typeddata_inherited_p(this->inner_rb_data_type_, requestedType))
     {
-      return this->data_.get();
+      return (void*)this->data_.get();
     }
     else
     {
@@ -4139,16 +4315,8 @@ namespace Rice4RubyQt6
               return it != unordered_map.end();
           }, Arg("value"));
           rb_define_alias(klass_, "eql?", "==");
+          rb_define_alias(klass_, "has_value", "value?");
         }
-        else
-        {
-          klass_.define_method("value?", [](T&, Mapped_Parameter_T) -> bool
-          {
-              return false;
-          }, Arg("value"));
-        }
-
-        rb_define_alias(klass_, "has_value", "value?");
       }
 
       void define_modify_methods()
@@ -4171,7 +4339,7 @@ namespace Rice4RubyQt6
             }, 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 +4461,7 @@ namespace Rice4RubyQt6
         // 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;
         });
       }
@@ -4482,6 +4650,7 @@ namespace Rice4RubyQt6
   }
 }
 
+
 // =========   vector.hpp   =========
 
 namespace Rice4RubyQt6
@@ -4790,21 +4959,6 @@ namespace Rice4RubyQt6
           }, Arg("value"));
           rb_define_alias(klass_, "eql?", "==");
         }
-        else
-        {
-          klass_.define_method("delete", [](T&, Parameter_T) -> std::optional<Value_T>
-          {
-            return std::nullopt;
-          }, Arg("value"))
-          .define_method("include?", [](const T&, Parameter_T)
-          {
-            return false;
-          }, Arg("value"))
-          .define_method("index", [](const T&, Parameter_T) -> std::optional<Difference_T>
-          {
-            return std::nullopt;
-          }, Arg("value"));
-        }
       }
 
       void define_modify_methods()
@@ -5215,6 +5369,24 @@ namespace Rice4RubyQt6
     private:
       Arg* arg_ = nullptr;
     };
+
+    template<>
+    class To_Ruby<std::vector<bool>::reference&>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {}
+
+      VALUE convert(const std::vector<bool>::reference& value)
+      {
+        return value ? Qtrue : Qfalse;
+      }
+
+    private:
+      Arg* arg_ = nullptr;
+    };
   }
 }
 

data/lib/qt6/rice/version.rb

@@ -2,6 +2,6 @@
 
 module RubyQt6
   module Rice
-    RICE_RUBYGEM_VERSION = "6.2.0"
+    RICE_RUBYGEM_VERSION = "6.3.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby-qt6-rice
 version: !ruby/object:Gem::Version
-  version: 6.2.0
+  version: 6.3.0
 platform: ruby
 authors:
 - John Doe