rice 4.7.0 → 4.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 75730bdd1cda9ed1d24be45b32d1cbe92b6dca8e021fdb39a8b681403fc1814a
-  data.tar.gz: eb653e187ef8d543007ad0ceb3e5712869d598466c21997d2fd759699742df19
+  metadata.gz: c8d106501ff928ca481358d579bffe110efebbd4a98f3de141b8a4e6a853b17a
+  data.tar.gz: 900e679ee80f32d547487133911dfa1ccdd087a41414fb44a1c8b144fec15278
 SHA512:
-  metadata.gz: 7c6a0d269f24af26c836ca71a7684d410d823a6661a26af1bb1ddb205b65067258119d49bcadabe9aa806884a4505213e5489d5638cdd3420b4edccd59e49928
-  data.tar.gz: 1a14760fb0e2903c594ae0e0a3d14077a806bf59c720323a30c6a8bc4958a0e35fd0c0436eedcd6b4a6451e8a7344098be0bab00113964127b4027c790159910
+  metadata.gz: 33837b467af9b734848a7ef09b552ed2ab25f7f86c6fdedbc8f6c85dc42137d2ca46e9fd812198b99baa4af94f1f659d15530f9ecf36a2e147d3ddfb5f3c02ff
+  data.tar.gz: 11bccd16adcb9a117a5ce80c91b219b1102a1fde56086542528a4684cedc84631261c6afb583dbebb0c25c3a2b1908c2196197f36c79cfc7db7322ab104d0388

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 4.7.1 (2025-10-28)
+Updates:
+* Update overload resolution to take into account function arguments that are tagged as buffers via Arg("").setBuffer().
+* Make second parameter optional for Array#push and update docs
+* Remove ostruct runtime dependency
+
 ## 4.7.0 (2025-10-22)
 Updates:
 * Refactor Native wrappers - functions, methods, attributes and procs - to enable introspection API
@@ -28,6 +34,7 @@ Breaking Changes:
    ```
 * You can no longer pass a Buffer<T> to an API that takes a pointer. Instead use Buffer<T>#data or Buffer<T>::release
 * The Rice_Init method has been removed.
+* Array#push requires a second argument.
 
 ## 4.6.1 (2025-06-25)
 * Improve attribute handling. Correctly deal with non-copyable/assignable attributes and return references instead of copies of objects

data/bin/rice-doc.rb

@@ -5,7 +5,6 @@ require_relative '../lib/rice'
 require_relative '../lib/rice/doc'
 
 # Now setup option parser
-require 'ostruct'
 require 'optparse'
 
 module Rice
@@ -51,7 +50,7 @@ module Rice
 		end
 
 		def parse_args
-			@options = OpenStruct.new
+			@options = Struct.new(:exec, :extension, :output).new
 			options.extension = nil
 			options.output = nil
 

data/bin/rice-rbs.rb

@@ -6,7 +6,6 @@ require 'bundler/setup'
 require 'rice'
 
 # Now setup option parser
-require 'ostruct'
 require 'optparse'
 
 module Rice
@@ -52,7 +51,7 @@ module Rice
 		end
 
 		def parse_args
-			@options = OpenStruct.new
+			@options = Struct.new(:exec, :extension, :output).new
 			options.extension = nil
 			options.output = nil
 

data/include/rice/rice.hpp

@@ -1885,8 +1885,8 @@ namespace Rice
    *  Example:
    *  \code
    *    Array a;
-   *    a.push(String("some string"));
-   *    a.push(42);
+   *    a.push(String("some string"), false);
+   *    a.push(42, false);
    *  \endcode
    */
   class Array
@@ -1965,7 +1965,7 @@ namespace Rice
      *  \return the object which was pushed onto the array.
      */
     template<typename T>
-    Object push(T&& obj, bool takeOwnership);
+    Object push(T&& obj, bool takeOwnership = false);
 
     //! Pop an element from the end of the array
     /*! \return the object which was popped from the array, or Qnil if
@@ -8502,7 +8502,6 @@ namespace Rice::detail
     return result;
   }
 
-
   inline const std::vector<std::unique_ptr<Native>>& NativeRegistry::lookup(VALUE klass, ID methodId)
   {
     if (rb_type(klass) == T_ICLASS)
@@ -9515,10 +9514,6 @@ namespace Rice::detail
     // Execute the function but make sure to catch any C++ exceptions!
     return cpp_protect([&]
     {
-      Identifier id(methodId);
-      std::string methodName = id.str();
-      std::string className = rb_class2name(klass);
-
       const std::vector<std::unique_ptr<Native>>& natives = Registries::instance.natives.lookup(klass, methodId);
 
       if (natives.size() == 1)
@@ -9631,10 +9626,10 @@ namespace Rice::detail
 
     if constexpr (std::is_pointer_v<T> && std::is_fundamental_v<std::remove_pointer_t<T>>)
     {
-      Type<Pointer<std::remove_pointer_t<T>>>::verify();
-      Type<Buffer<std::remove_pointer_t<T>>>::verify();
+      Type<Pointer<Base_T>>::verify();
+      Type<Buffer<Base_T>>::verify();
     }
-    if constexpr (std::is_array_v<T>)
+    else if constexpr (std::is_array_v<T>)
     {
       Type<Pointer<std::remove_extent_t<remove_cv_recursive_t<T>>>>::verify();
       Type<Buffer<std::remove_extent_t<remove_cv_recursive_t<T>>>>::verify();
@@ -12742,6 +12737,12 @@ namespace Rice::detail
   class From_Ruby<Symbol>
   {
   public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
     Convertible is_convertible(VALUE value)
     {
       switch (rb_type(value))
@@ -12761,6 +12762,9 @@ namespace Rice::detail
     {
       return Symbol(value);
     }
+
+  private:
+    Arg* arg_ = nullptr;
   };
 }
 
@@ -14021,16 +14025,17 @@ namespace Rice
   template <typename T>
   Exception create_type_exception(VALUE value)
   {
-    if constexpr (std::is_pointer_v<T>)
+    if (Data_Type<T>::is_bound())
     {
-      return Exception(rb_eTypeError, "Wrong argument type. Expected: %s. Received: %s.",
-        detail::protect(rb_class2name, Data_Type<Pointer<std::remove_cv_t<std::remove_pointer_t<T>>>>::klass().value()),
+      return Exception(rb_eTypeError, "Wrong argument type. Expected %s. Received %s.",
+        detail::protect(rb_class2name, Data_Type<T>::klass().value()),
         detail::protect(rb_obj_classname, value));
     }
     else
     {
-      return Exception(rb_eTypeError, "Wrong argument type. Expected: %s. Received: %s.",
-        detail::protect(rb_class2name, Data_Type<detail::intrinsic_type<T>>::klass().value()),
+      detail::TypeMapper<T> typeMapper;
+      return Exception(rb_eTypeError, "Wrong argument type. Expected %s. Received %s.",
+        typeMapper.simplifiedName().c_str(),
         detail::protect(rb_obj_classname, value));
     }
   }
@@ -14506,6 +14511,7 @@ namespace Rice::detail
                   "Please include rice/stl.hpp header for STL support");
 
     using Intrinsic_T = intrinsic_type<T>;
+    using Pointer_T = Pointer<remove_cv_recursive_t<T>>;
 
   public:
     From_Ruby() = default;
@@ -14516,17 +14522,19 @@ namespace Rice::detail
 
     Convertible is_convertible(VALUE value)
     {
+      bool isBuffer = this->arg_->isBuffer();
+
       switch (rb_type(value))
       {
         case RUBY_T_NIL:
           return Convertible::Exact;
           break;
         case RUBY_T_DATA:
-          if (Data_Type<T>::is_descendant(value))
+          if (Data_Type<T>::is_descendant(value) && !isBuffer)
           {
             return Convertible::Exact;
           }
-          else if (Data_Type<Pointer<T>>::is_descendant(value))
+          else if (Data_Type<Pointer_T>::is_descendant(value))
           {
             return Convertible::Exact;
           }
@@ -14539,6 +14547,7 @@ namespace Rice::detail
     T* convert(VALUE value)
     {
       bool isOwner = this->arg_ && this->arg_->isOwner();
+      bool isBuffer = this->arg_ && this->arg_->isBuffer();
 
       switch (rb_type(value))
       {
@@ -14549,19 +14558,26 @@ namespace Rice::detail
         }
         case RUBY_T_DATA:
         {
-          if (Data_Type<T>::is_descendant(value))
+          if (Data_Type<T>::is_descendant(value) && !isBuffer)
           {
             return detail::unwrap<Intrinsic_T>(value, Data_Type<Intrinsic_T>::ruby_data_type(), isOwner);
           }
-          else if (Data_Type<Pointer<T>>::is_descendant(value))
+          else if (Data_Type<Pointer_T>::is_descendant(value))
           {
-            return detail::unwrap<T>(value, Data_Type<Pointer<T>>::ruby_data_type(), isOwner);
+            return detail::unwrap<T>(value, Data_Type<Pointer_T>::ruby_data_type(), isOwner);
           }
           [[fallthrough]];
         }
         default:
         {
-          throw create_type_exception<T*>(value);
+          if (isBuffer || std::is_fundamental_v<T>)
+          {
+            throw create_type_exception<Pointer_T>(value);
+          }
+          else
+          {
+            throw create_type_exception<T>(value);
+          }
         }
       }
     }
@@ -14628,6 +14644,7 @@ namespace Rice::detail
                   "Please include rice/stl.hpp header for STL support");
 
     using Intrinsic_T = intrinsic_type<T>;
+    using Pointer_T = Pointer<remove_cv_recursive_t<T>*>;
   public:
     From_Ruby() = default;
 
@@ -14637,14 +14654,19 @@ namespace Rice::detail
 
     Convertible is_convertible(VALUE value)
     {
+      bool isBuffer = this->arg_ && this->arg_->isBuffer();
+
       switch (rb_type(value))
       {
-        case RUBY_T_DATA:
-          return Data_Type<Pointer<T*>>::is_descendant(value) ? Convertible::Exact : Convertible::None;
-          break;
         case RUBY_T_NIL:
           return Convertible::Exact;
           break;
+        case RUBY_T_DATA:
+          if (Data_Type<Pointer_T>::is_descendant(value) && isBuffer)
+          {
+            return Convertible::Exact;
+          }
+          [[fallthrough]];
         default:
           return Convertible::None;
       }
@@ -14653,23 +14675,34 @@ namespace Rice::detail
     T** convert(VALUE value)
     {
       bool isOwner = this->arg_ && this->arg_->isOwner();
+      bool isBuffer = this->arg_ && this->arg_->isBuffer();
 
       switch (rb_type(value))
       {
-        case RUBY_T_DATA:
-        {
-          T** result = detail::unwrap<Intrinsic_T*>(value, Data_Type<Pointer<T*>>::ruby_data_type(), isOwner);
-          return result;
-          break;
-        }
         case RUBY_T_NIL:
         {
           return nullptr;
           break;
         }
+        case RUBY_T_DATA:
+        {
+          if (Data_Type<Pointer_T>::is_descendant(value) && isBuffer)
+          {
+            T** result = detail::unwrap<Intrinsic_T*>(value, Data_Type<Pointer_T>::ruby_data_type(), isOwner);
+            return result;
+          }
+          [[fallthrough]];
+        }
         default:
         {
-          throw create_type_exception<T**>(value);
+          if (isBuffer)
+          {
+            throw create_type_exception<Pointer_T>(value);
+          }
+          else
+          {
+            throw create_type_exception<T**>(value);
+          }
         }
       }
     }

data/include/rice/stl.hpp

@@ -445,20 +445,38 @@ namespace Rice::detail
   class To_Ruby<std::string_view>
   {
   public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
     VALUE convert(std::string_view const& x)
     {
       return detail::protect(rb_external_str_new, x.data(), (long)x.size());
     }
+
+  private:
+    Arg* arg_ = nullptr;
   };
 
   template<>
   class To_Ruby<std::string_view&>
   {
   public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
     VALUE convert(std::string_view const& x)
     {
       return detail::protect(rb_external_str_new, x.data(), (long)x.size());
     }
+
+  private:
+    Arg* arg_ = nullptr;
   };
 
   template<>

data/lib/rice/rbs.rb

@@ -53,7 +53,7 @@ module Rice
 									 "attr_reader"
 								 else
 									 "attr_writer"
-									end
+								 end
 			"#{attr_type} #{native_attributes.first.name}: #{native_attributes.first.return_type}"
 		end
 
@@ -82,7 +82,7 @@ module Rice
 		end
 
 		def template
-			content = <<~EOS
+			<<~EOS
         module <%= klass.name.split("::")[0..-2].join("::") %>
           class <%= klass.name.split("::").last %>
           <%- native_functions.each do |name, functions| -%>

data/lib/rice/version.rb

@@ -1,3 +1,3 @@
 module Rice
-  VERSION = "4.7.0"
+  VERSION = "4.7.1"
 end

data/rice/Data_Object.ipp

@@ -6,16 +6,17 @@ namespace Rice
   template <typename T>
   Exception create_type_exception(VALUE value)
   {
-    if constexpr (std::is_pointer_v<T>)
+    if (Data_Type<T>::is_bound())
     {
-      return Exception(rb_eTypeError, "Wrong argument type. Expected: %s. Received: %s.",
-        detail::protect(rb_class2name, Data_Type<Pointer<std::remove_cv_t<std::remove_pointer_t<T>>>>::klass().value()),
+      return Exception(rb_eTypeError, "Wrong argument type. Expected %s. Received %s.",
+        detail::protect(rb_class2name, Data_Type<T>::klass().value()),
         detail::protect(rb_obj_classname, value));
     }
     else
     {
-      return Exception(rb_eTypeError, "Wrong argument type. Expected: %s. Received: %s.",
-        detail::protect(rb_class2name, Data_Type<detail::intrinsic_type<T>>::klass().value()),
+      detail::TypeMapper<T> typeMapper;
+      return Exception(rb_eTypeError, "Wrong argument type. Expected %s. Received %s.",
+        typeMapper.simplifiedName().c_str(),
         detail::protect(rb_obj_classname, value));
     }
   }
@@ -491,6 +492,7 @@ namespace Rice::detail
                   "Please include rice/stl.hpp header for STL support");
 
     using Intrinsic_T = intrinsic_type<T>;
+    using Pointer_T = Pointer<remove_cv_recursive_t<T>>;
 
   public:
     From_Ruby() = default;
@@ -501,17 +503,19 @@ namespace Rice::detail
 
     Convertible is_convertible(VALUE value)
     {
+      bool isBuffer = this->arg_->isBuffer();
+
       switch (rb_type(value))
       {
         case RUBY_T_NIL:
           return Convertible::Exact;
           break;
         case RUBY_T_DATA:
-          if (Data_Type<T>::is_descendant(value))
+          if (Data_Type<T>::is_descendant(value) && !isBuffer)
           {
             return Convertible::Exact;
           }
-          else if (Data_Type<Pointer<T>>::is_descendant(value))
+          else if (Data_Type<Pointer_T>::is_descendant(value))
           {
             return Convertible::Exact;
           }
@@ -524,6 +528,7 @@ namespace Rice::detail
     T* convert(VALUE value)
     {
       bool isOwner = this->arg_ && this->arg_->isOwner();
+      bool isBuffer = this->arg_ && this->arg_->isBuffer();
 
       switch (rb_type(value))
       {
@@ -534,19 +539,26 @@ namespace Rice::detail
         }
         case RUBY_T_DATA:
         {
-          if (Data_Type<T>::is_descendant(value))
+          if (Data_Type<T>::is_descendant(value) && !isBuffer)
           {
             return detail::unwrap<Intrinsic_T>(value, Data_Type<Intrinsic_T>::ruby_data_type(), isOwner);
           }
-          else if (Data_Type<Pointer<T>>::is_descendant(value))
+          else if (Data_Type<Pointer_T>::is_descendant(value))
           {
-            return detail::unwrap<T>(value, Data_Type<Pointer<T>>::ruby_data_type(), isOwner);
+            return detail::unwrap<T>(value, Data_Type<Pointer_T>::ruby_data_type(), isOwner);
           }
           [[fallthrough]];
         }
         default:
         {
-          throw create_type_exception<T*>(value);
+          if (isBuffer || std::is_fundamental_v<T>)
+          {
+            throw create_type_exception<Pointer_T>(value);
+          }
+          else
+          {
+            throw create_type_exception<T>(value);
+          }
         }
       }
     }
@@ -613,6 +625,7 @@ namespace Rice::detail
                   "Please include rice/stl.hpp header for STL support");
 
     using Intrinsic_T = intrinsic_type<T>;
+    using Pointer_T = Pointer<remove_cv_recursive_t<T>*>;
   public:
     From_Ruby() = default;
 
@@ -622,14 +635,19 @@ namespace Rice::detail
 
     Convertible is_convertible(VALUE value)
     {
+      bool isBuffer = this->arg_ && this->arg_->isBuffer();
+
       switch (rb_type(value))
       {
-        case RUBY_T_DATA:
-          return Data_Type<Pointer<T*>>::is_descendant(value) ? Convertible::Exact : Convertible::None;
-          break;
         case RUBY_T_NIL:
           return Convertible::Exact;
           break;
+        case RUBY_T_DATA:
+          if (Data_Type<Pointer_T>::is_descendant(value) && isBuffer)
+          {
+            return Convertible::Exact;
+          }
+          [[fallthrough]];
         default:
           return Convertible::None;
       }
@@ -638,23 +656,34 @@ namespace Rice::detail
     T** convert(VALUE value)
     {
       bool isOwner = this->arg_ && this->arg_->isOwner();
+      bool isBuffer = this->arg_ && this->arg_->isBuffer();
 
       switch (rb_type(value))
       {
-        case RUBY_T_DATA:
-        {
-          T** result = detail::unwrap<Intrinsic_T*>(value, Data_Type<Pointer<T*>>::ruby_data_type(), isOwner);
-          return result;
-          break;
-        }
         case RUBY_T_NIL:
         {
           return nullptr;
           break;
         }
+        case RUBY_T_DATA:
+        {
+          if (Data_Type<Pointer_T>::is_descendant(value) && isBuffer)
+          {
+            T** result = detail::unwrap<Intrinsic_T*>(value, Data_Type<Pointer_T>::ruby_data_type(), isOwner);
+            return result;
+          }
+          [[fallthrough]];
+        }
         default:
         {
-          throw create_type_exception<T**>(value);
+          if (isBuffer)
+          {
+            throw create_type_exception<Pointer_T>(value);
+          }
+          else
+          {
+            throw create_type_exception<T**>(value);
+          }
         }
       }
     }

data/rice/cpp_api/Array.hpp

@@ -12,8 +12,8 @@ namespace Rice
    *  Example:
    *  \code
    *    Array a;
-   *    a.push(String("some string"));
-   *    a.push(42);
+   *    a.push(String("some string"), false);
+   *    a.push(42, false);
    *  \endcode
    */
   class Array
@@ -92,7 +92,7 @@ namespace Rice
      *  \return the object which was pushed onto the array.
      */
     template<typename T>
-    Object push(T&& obj, bool takeOwnership);
+    Object push(T&& obj, bool takeOwnership = false);
 
     //! Pop an element from the end of the array
     /*! \return the object which was popped from the array, or Qnil if

data/rice/cpp_api/Symbol.ipp

@@ -104,6 +104,12 @@ namespace Rice::detail
   class From_Ruby<Symbol>
   {
   public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
     Convertible is_convertible(VALUE value)
     {
       switch (rb_type(value))
@@ -123,5 +129,8 @@ namespace Rice::detail
     {
       return Symbol(value);
     }
+
+  private:
+    Arg* arg_ = nullptr;
   };
 }

data/rice/detail/Native.ipp

@@ -66,10 +66,6 @@ namespace Rice::detail
     // Execute the function but make sure to catch any C++ exceptions!
     return cpp_protect([&]
     {
-      Identifier id(methodId);
-      std::string methodName = id.str();
-      std::string className = rb_class2name(klass);
-
       const std::vector<std::unique_ptr<Native>>& natives = Registries::instance.natives.lookup(klass, methodId);
 
       if (natives.size() == 1)
@@ -182,10 +178,10 @@ namespace Rice::detail
 
     if constexpr (std::is_pointer_v<T> && std::is_fundamental_v<std::remove_pointer_t<T>>)
     {
-      Type<Pointer<std::remove_pointer_t<T>>>::verify();
-      Type<Buffer<std::remove_pointer_t<T>>>::verify();
+      Type<Pointer<Base_T>>::verify();
+      Type<Buffer<Base_T>>::verify();
     }
-    if constexpr (std::is_array_v<T>)
+    else if constexpr (std::is_array_v<T>)
     {
       Type<Pointer<std::remove_extent_t<remove_cv_recursive_t<T>>>>::verify();
       Type<Buffer<std::remove_extent_t<remove_cv_recursive_t<T>>>>::verify();

data/rice/detail/NativeRegistry.ipp

@@ -59,7 +59,6 @@ namespace Rice::detail
     return result;
   }
 
-
   inline const std::vector<std::unique_ptr<Native>>& NativeRegistry::lookup(VALUE klass, ID methodId)
   {
     if (rb_type(klass) == T_ICLASS)

data/rice/stl/string_view.ipp

@@ -20,20 +20,38 @@ namespace Rice::detail
   class To_Ruby<std::string_view>
   {
   public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
     VALUE convert(std::string_view const& x)
     {
       return detail::protect(rb_external_str_new, x.data(), (long)x.size());
     }
+
+  private:
+    Arg* arg_ = nullptr;
   };
 
   template<>
   class To_Ruby<std::string_view&>
   {
   public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
     VALUE convert(std::string_view const& x)
     {
       return detail::protect(rb_external_str_new, x.data(), (long)x.size());
     }
+
+  private:
+    Arg* arg_ = nullptr;
   };
 
   template<>

data/rice.gemspec

@@ -67,7 +67,6 @@ Ruby extensions with C++ easier.
   ]
 
   s.required_ruby_version = ">= 3.1"
-  s.add_dependency "ostruct"
   s.add_development_dependency "bundler"
   s.add_development_dependency "rake"
   s.add_development_dependency "minitest"

data/test/test_Buffer.cpp

@@ -594,7 +594,7 @@ TESTCASE(pass_objects)
 {
   Module m = define_module("Testing");
   m.define_module_function<size_t(*)(const MyClassBuf*, size_t)>("sum_ids", &sumIds, Arg("myClasses").setBuffer());
-  m.define_module_function<size_t(*)(const MyClassBuf**, size_t)>("sum_ids_ptr", &sumIds);
+  m.define_module_function<size_t(*)(const MyClassBuf**, size_t)>("sum_ids_ptr", &sumIds, Arg("myClasses").setBuffer());
 
   define_class_under<MyClassBuf>(m, "MyClassBuf").
     define_constructor(Constructor<MyClassBuf, int>()).

data/test/test_Data_Object.cpp

@@ -95,7 +95,7 @@ TESTCASE(data_object_construct_from_ruby_object_and_wrong_class)
   ASSERT_EXCEPTION_CHECK(
     Exception,
     Data_Object<Bar> bar(wrapped_foo),
-    ASSERT_EQUAL("Wrong argument type. Expected: Bar. Received: MyDataType.", ex.what()));
+    ASSERT_EQUAL("Wrong argument type. Expected Bar. Received MyDataType.", ex.what()));
 }
 
 TESTCASE(data_object_copy_construct)

data/test/test_Data_Type.cpp

@@ -871,7 +871,8 @@ TESTCASE(pointer_of_ranges_wrong)
     .define_attr("x", &RangesTest::RangeCustom::x)
     .define_attr("y", &RangesTest::RangeCustom::y);
 
-  m.define_module_function<int(*)(const RangesTest::RangeCustom*, int)>("sum_ranges_wrong", RangesTest::sumRanges);
+  m.define_module_function<int(*)(const RangesTest::RangeCustom*, int)>("sum_ranges_wrong", RangesTest::sumRanges,
+                                  Arg("ranges").setBuffer());
 
   std::string code = R"(range1 = RangeCustom.new(1, 2)
                         range2 = RangeCustom.new(3, 4)
@@ -883,7 +884,7 @@ TESTCASE(pointer_of_ranges_wrong)
   ASSERT_EXCEPTION_CHECK(
     Rice::Exception,
     m.module_eval(code),
-    ASSERT_EQUAL("Wrong argument type. Expected: Rice::Pointer≺RangesTest꞉꞉RangeCustom≻. Received: Rice::Buffer≺RangesTest꞉꞉RangeCustom≻.", ex.what())
+    ASSERT_EQUAL("Wrong argument type. Expected Rice::Pointer≺RangesTest꞉꞉RangeCustom≻. Received Rice::Buffer≺RangesTest꞉꞉RangeCustom≻.", ex.what())
   );
 }
 

data/test/test_From_Ruby.cpp

@@ -200,7 +200,7 @@ TESTCASE(signed_char_pointer)
   ASSERT_EXCEPTION_CHECK(
     Exception,
     fromRuby.convert(rb_float_new(11.11)),
-    ASSERT_EQUAL("Wrong argument type. Expected: Rice::Pointer≺signed char≻. Received: Float.", ex.what())
+    ASSERT_EQUAL("Wrong argument type. Expected Rice::Pointer≺signed char≻. Received Float.", ex.what())
   );
 }
 
@@ -279,7 +279,7 @@ TESTCASE(unsigned_char_pointer)
   ASSERT_EXCEPTION_CHECK(
     Exception,
     detail::From_Ruby<const char*>().convert(rb_float_new(11.11)),
-    ASSERT_EQUAL("Wrong argument type. Expected: Rice::Pointer≺char≻. Received: Float.", ex.what())
+    ASSERT_EQUAL("Wrong argument type. Expected Rice::Pointer≺char≻. Received Float.", ex.what())
   );
 }
 
@@ -414,7 +414,7 @@ TESTCASE(float_array_array)
 {
   Module m = define_module("Testing");
 
-  m.define_singleton_function("array_array_to_string", &arrayofArraysToString<float>);
+  m.define_singleton_function("array_array_to_string", &arrayofArraysToString<float>, Arg("buffer").setBuffer());
 
   std::string code = R"(buffer = Rice::Buffer≺float∗≻.new([[1.1, 2.2], [3.3, 4.4], [5.5, 6.6]])
                         array_array_to_string(buffer.data, buffer.size, 2))";
@@ -441,7 +441,7 @@ TESTCASE(float_array_array)
   ASSERT_EXCEPTION_CHECK(
     Exception,
     m.module_eval(code),
-    ASSERT_EQUAL("Wrong argument type. Expected: Rice::Pointer≺float∗≻. Received: Array.", ex.what())
+    ASSERT_EQUAL("Wrong argument type. Expected Rice::Pointer≺float∗≻. Received Array.", ex.what())
   );
 }
 

data/test/test_Overloads.cpp

@@ -647,7 +647,7 @@ TESTCASE(int_conversion_6)
   Class c = define_class<MyClass3>("MyClass3").
     define_constructor(Constructor<MyClass3>()).
     define_method<std::string(MyClass3::*)(unsigned char)>("run", &MyClass3::run).
-    define_method<std::string(MyClass3::*)(unsigned char*)>("run", &MyClass3::run);
+    define_method<std::string(MyClass3::*)(unsigned char*)>("run", &MyClass3::run, Arg("value").setBuffer());
 
   Module m = define_module("Testing");
 
@@ -707,8 +707,8 @@ TESTCASE(NonConstRef)
   Module m = define_module("Testing");
 
   std::string code = R"(my_class4 = MyClass4.new
-                          my_class5 = MyClass5.new(my_class4)
-                          my_class5.result)";
+                        my_class5 = MyClass5.new(my_class4)
+                        my_class5.result)";
   String result = m.module_eval(code);
   ASSERT_EQUAL("non-const ref", result.str());
 }
@@ -726,8 +726,8 @@ TESTCASE(ConstRef)
   Module m = define_module("Testing");
 
   std::string code = R"(my_class4 = MyClass4.const_instance
-                          my_class5 = MyClass5.new(my_class4)
-                          my_class5.result)";
+                        my_class5 = MyClass5.new(my_class4)
+                        my_class5.result)";
   String result = m.module_eval(code);
   ASSERT_EQUAL("const ref", result.str());
 }
@@ -799,8 +799,56 @@ TESTCASE(ConstPointer)
   Module m = define_module("Testing");
 
   std::string code = R"(my_class6 = MyClass6.const_instance
-                          my_class7 = MyClass7.new(my_class6)
-                          my_class7.result)";
+                        my_class7 = MyClass7.new(my_class6)
+                        my_class7.result)";
   String result = m.module_eval(code);
   ASSERT_EQUAL("const pointer", result.str());
 }
+
+namespace
+{
+  std::string pointer(const MyClass6* data)
+  {
+    return "pointer";
+  }
+
+  std::string pointer(MyClass6* data)
+  {
+    return "pointerBuffer";
+  }
+}
+
+TESTCASE(PointerNotBuffer)
+{
+  Module m = define_module("Testing");
+
+  define_class<MyClass6>("MyClass").
+    define_constructor(Constructor<MyClass6>());
+
+  m.define_module_function<std::string(*)(const MyClass6*)>("pointer", pointer).
+    define_module_function<std::string(*)(MyClass6*)>("pointer", pointer, Arg("data").setBuffer());
+
+  std::string code = R"(my_class6 = MyClass6.new
+                        pointer(my_class6))";
+  
+  String result = m.module_eval(code);
+  ASSERT_EQUAL("pointer", result.str());
+}
+
+TESTCASE(PointerBuffer)
+{
+  Module m = define_module("Testing");
+
+  define_class<MyClass6>("MyClass").
+    define_constructor(Constructor<MyClass6>());
+
+  m.define_function<std::string(*)(const MyClass6*)>("pointer", pointer).
+    define_function<std::string(*)(MyClass6*)>("pointer", pointer, Arg("data").setBuffer());
+
+  std::string code = R"(my_class6 = MyClass6.new
+                        buffer = Rice::Buffer≺AnonymousNamespace꞉꞉MyClass6≻.new(my_class6)
+                        pointer(buffer.data))";
+
+  String result = m.module_eval(code);
+  ASSERT_EQUAL("pointerBuffer", result.str());
+}

data/test/test_Stl_String_View.cpp

@@ -91,3 +91,13 @@ TESTCASE(std_string_view_from_ruby_refefence)
   string.instance_eval("self[1] = 'a'");
   //ASSERT_EQUAL("tast", view);
 }
+
+namespace {
+  std::string_view testStringViewReturn(Object self) {
+    return "test";
+  }
+}
+
+TESTCASE(use_string_view_in_wrapped_function) {
+  define_global_function("test_string_view_return", &testStringViewReturn);
+}

data/test/test_Symbol.cpp

@@ -73,3 +73,15 @@ TESTCASE(to_id)
   Symbol symbol("Foo");
   ASSERT_EQUAL(Identifier("Foo"), symbol.to_id());
 }
+
+namespace
+{
+  void testSymbolArg(Object self, Symbol string)
+  {
+  }
+}
+
+TESTCASE(use_symbol_in_wrapped_function)
+{
+  define_global_function("test_symbol_arg", &testSymbolArg);
+}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rice
 version: !ruby/object:Gem::Version
-  version: 4.7.0
+  version: 4.7.1
 platform: ruby
 authors:
 - Paul Brannan
@@ -11,20 +11,6 @@ bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: ostruct
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement