rice 4.11.5 → 4.12.0

data/include/rice/stl.hpp

@@ -151,9 +151,9 @@ namespace Rice::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 Rice
 
 namespace Rice::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 Rice::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>>
   {
@@ -1463,6 +1621,24 @@ namespace Rice::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>>
   {
@@ -1626,16 +1802,8 @@ namespace Rice
             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()
@@ -1969,6 +2137,7 @@ namespace Rice
   }
 }
 
+
 // =========   monostate.hpp   =========
 
 
@@ -2230,16 +2399,8 @@ namespace Rice
             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()
@@ -2554,6 +2715,7 @@ namespace Rice
   }
 }
 
+
 // =========   set.hpp   =========
 
 namespace Rice
@@ -2667,23 +2829,23 @@ namespace Rice
 
       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;
@@ -2730,15 +2892,14 @@ namespace Rice
             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()
@@ -3865,6 +4026,9 @@ namespace Rice
   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>;
 
@@ -4151,16 +4315,8 @@ namespace Rice
               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()
@@ -4494,6 +4650,7 @@ namespace Rice
   }
 }
 
+
 // =========   vector.hpp   =========
 
 namespace Rice
@@ -4802,21 +4959,6 @@ namespace Rice
           }, 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()
@@ -5227,6 +5369,24 @@ namespace Rice
     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/rice/version.rb

@@ -1,3 +1,3 @@
 module Rice
-  VERSION = "4.11.5"
+  VERSION = "4.12.0"
 end

data/rice/Constructor.ipp

@@ -41,7 +41,7 @@ namespace Rice
     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);
     }
 
@@ -75,8 +75,8 @@ namespace Rice
       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);
       }
   };
-}
+}

data/rice/Data_Object.ipp

@@ -330,16 +330,6 @@ namespace Rice::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
   {
@@ -685,36 +675,4 @@ namespace Rice::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);
-    }
-  };
 }

data/rice/JumpException.ipp

@@ -34,6 +34,7 @@ namespace Rice
         break;
       case RUBY_TAG_THROW:
         this->message_ = "Unexpected throw";
+        break;
       case RUBY_TAG_RAISE:
         this->message_ = "Ruby exception was thrown";
         break;

data/rice/Reference.hpp

@@ -11,7 +11,7 @@ namespace Rice
 
   public:
     Reference();
-    Reference(T& data);
+    Reference(const T& data);
     Reference(VALUE value);
     T& get();
 
@@ -20,7 +20,7 @@ namespace Rice
   };
 
   // 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

data/rice/Reference.ipp

@@ -6,7 +6,7 @@ namespace Rice
   }
 
   template<typename T>
-  inline Reference<T>::Reference(T& data) : data_(data)
+  inline Reference<T>::Reference(const T& data) : data_(data)
   {
   }
 

data/rice/cpp_api/Encoding.ipp

@@ -9,51 +9,3 @@ namespace Rice
   {
   }
 }
-
-/*namespace Rice::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);
-    }
-  };
-}
-*/

data/rice/cpp_api/Hash.ipp

@@ -248,6 +248,25 @@ namespace Rice::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>
   {

data/rice/cpp_api/Object.hpp

@@ -183,7 +183,7 @@ namespace Rice
     *  \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
@@ -206,7 +206,7 @@ namespace Rice
     *  \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

data/rice/cpp_api/Object.ipp

@@ -42,7 +42,7 @@ namespace Rice
   }
 
   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
@@ -56,10 +56,10 @@ namespace Rice
   }
 
   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);
   }
 

data/rice/cpp_api/String.ipp

@@ -108,6 +108,25 @@ namespace Rice::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;
   };

data/rice/detail/Parameter.ipp

@@ -54,6 +54,12 @@ namespace Rice::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>)
@@ -90,6 +96,11 @@ namespace Rice::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>>)