rice 4.9.0 → 4.9.1

data/rice/stl/unordered_map.ipp

@@ -14,6 +14,8 @@ namespace Rice
       using Size_T = typename T::size_type;
       using Difference_T = typename T::difference_type;
       using To_Ruby_T = typename detail::remove_cv_recursive_t<Mapped_T>;
+      // For pointer types, use the pointer directly; for non-pointer types, use a reference
+      using Mapped_Parameter_T = std::conditional_t<std::is_pointer_v<Mapped_T>, Mapped_T, Mapped_T&>;
 
     public:
       UnorderedMapHelper(Data_Type<T> klass) : klass_(klass)
@@ -33,7 +35,7 @@ namespace Rice
 
       void register_pair()
       {
-        define_pair<const Key_T, T>();
+        define_pair<const Key_T, Mapped_T>();
       }
 
       void define_constructors()
@@ -42,7 +44,7 @@ namespace Rice
 
         if constexpr (std::is_copy_constructible_v<Key_T> && std::is_copy_constructible_v<Value_T>)
         {
-          klass_.define_constructor(Constructor<T, const T&>());
+          klass_.define_constructor(Constructor<T, const T&>(), Arg("other"));
         }
       }
 
@@ -71,11 +73,11 @@ namespace Rice
             {
               return std::nullopt;
             }
-          })
+          }, Arg("key"))
           .define_method("include?", [](T& unordered_map, Key_T& key) -> bool
           {
               return unordered_map.find(key) != unordered_map.end();
-          })
+          }, Arg("key"))
           .define_method("keys", [](T& unordered_map) -> std::vector<Key_T>
             {
               std::vector<Key_T> result;
@@ -110,8 +112,8 @@ namespace Rice
           klass_.define_method("==", [](T& unordered_map, T& other)->bool
           {
             return unordered_map == other;
-          })
-          .define_method("value?", [](T& unordered_map, Mapped_T& value) -> bool
+          }, Arg("other"))
+          .define_method("value?", [](T& unordered_map, Mapped_Parameter_T value) -> bool
             {
               auto it = std::find_if(unordered_map.begin(), unordered_map.end(),
               [&value](auto& pair)
@@ -120,15 +122,15 @@ namespace Rice
                 });
 
               return it != unordered_map.end();
-          });
+          }, Arg("value"));
           rb_define_alias(klass_, "eql?", "==");
         }
         else
         {
-          klass_.define_method("value?", [](T&, Mapped_T&) -> bool
+          klass_.define_method("value?", [](T&, Mapped_Parameter_T) -> bool
           {
               return false;
-          });
+          }, Arg("value"));
         }
 
         rb_define_alias(klass_, "has_value", "value?");
@@ -151,12 +153,12 @@ namespace Rice
               {
                 return std::nullopt;
               }
-            })
-          .define_method("[]=", [](T& unordered_map, Key_T key, Mapped_T& value) -> Mapped_T
+            }, Arg("key"))
+          .define_method("[]=", [](T& unordered_map, Key_T key, Mapped_Parameter_T value) -> Mapped_T
             {
               unordered_map[key] = value;
               return value;
-            });
+            }, Arg("key").keepAlive(), Arg("value").keepAlive());
 
           rb_define_alias(klass_, "store", "[]=");
       }

data/rice/stl/vector.ipp

@@ -58,13 +58,13 @@ namespace Rice
 
         if constexpr (std::is_copy_constructible_v<Value_T>)
         {
-          klass_.define_constructor(Constructor<T, const T&>())
-                .define_constructor(Constructor<T, Size_T, const Parameter_T>());
+          klass_.define_constructor(Constructor<T, const T&>(), Arg("other"))
+                .define_constructor(Constructor<T, Size_T, const Parameter_T>(), Arg("count"), Arg("value"));
         }
 
         if constexpr (std::is_default_constructible_v<Value_T>)
         {
-          klass_.define_constructor(Constructor<T, Size_T>());
+          klass_.define_constructor(Constructor<T, Size_T>(), Arg("count"));
         }
 
         // Allow creation of a vector from a Ruby Array
@@ -72,18 +72,20 @@ namespace Rice
         {
           // Create a new vector from the array
           T* data = new T();
-          data->reserve(array.size());
 
+          // Wrap the vector
+          detail::Wrapper<T*>* wrapper = detail::wrapConstructed<T>(self, Data_Type<T>::ruby_data_type(), data);
+
+          // Now populate the vector
           detail::From_Ruby<Value_T> fromRuby;
+          data->reserve(array.size());
 
           for (long i = 0; i < array.size(); i++)
           {
             VALUE element = detail::protect(rb_ary_entry, array, i);
             data->push_back(fromRuby.convert(element));
+            wrapper->addKeepAlive(element);
           }
-
-          // Wrap the vector
-          detail::wrapConstructed<T>(self, Data_Type<T>::ruby_data_type(), data);
         });
       }
 
@@ -91,18 +93,18 @@ namespace Rice
       {
         if constexpr (std::is_default_constructible_v<Value_T> && std::is_same_v<Value_T, bool>)
         {
-          klass_.define_method("resize", static_cast<void (T::*)(const size_t, bool)>(&T::resize));
+          klass_.define_method("resize", static_cast<void (T::*)(const size_t, bool)>(&T::resize), Arg("count"), Arg("value"));
         }
         else if constexpr (std::is_default_constructible_v<Value_T>)
         {
-          klass_.define_method("resize", static_cast<void (T::*)(const size_t)>(&T::resize));
+          klass_.define_method("resize", static_cast<void (T::*)(const size_t)>(&T::resize), Arg("count"));
         }
         else
         {
           klass_.define_method("resize", [](const T&, Size_T)
           {
             // Do nothing
-          });
+          }, Arg("count"));
         }
       }
 
@@ -111,13 +113,11 @@ namespace Rice
         klass_.define_method("empty?", &T::empty)
           .define_method("capacity", &T::capacity)
           .define_method("max_size", &T::max_size)
-          .define_method("reserve", &T::reserve)
+          .define_method("reserve", &T::reserve, Arg("new_cap"))
           .define_method("size", &T::size);
-        
+
         rb_define_alias(klass_, "count", "size");
         rb_define_alias(klass_, "length", "size");
-        //detail::protect(rb_define_alias, klass_, "count", "size");
-        //detail::protect(rb_define_alias, klass_, "length", "size");
       }
 
       void define_access_methods()
@@ -158,7 +158,7 @@ namespace Rice
             {
               return vector[index];
             }
-          })
+          }, Arg("pos"))
           .template define_method<Value_T*(T::*)()>("data", &T::data, ReturnBuffer());
         }
         else
@@ -197,7 +197,7 @@ namespace Rice
             {
               return vector[index];
             }
-          });
+          }, Arg("pos"));
         }
 
         klass_.define_method("[]", [this](T& vector, Difference_T start, Difference_T length) -> VALUE
@@ -230,7 +230,7 @@ namespace Rice
 
             return result;
           }
-        }, Return().setValue());
+        }, Arg("start"), Arg("length"), Return().setValue());
 
         rb_define_alias(klass_, "at", "[]");
       }
@@ -243,7 +243,7 @@ namespace Rice
           klass_.define_method("==", [](T& vector, T& other)->bool
           {
             return vector == other;
-          })
+          }, Arg("other"))
           .define_method("delete", [](T& vector, Parameter_T element) -> std::optional<Value_T>
           {
             auto iter = std::find(vector.begin(), vector.end(), element);
@@ -261,11 +261,11 @@ namespace Rice
             {
               return std::nullopt;
             }
-          })
+          }, Arg("value"))
           .define_method("include?", [](T& vector, Parameter_T element)
           {
             return std::find(vector.begin(), vector.end(), element) != vector.end();
-          })
+          }, Arg("value"))
           .define_method("index", [](T& vector, Parameter_T element) -> std::optional<Difference_T>
           {
             auto iter = std::find(vector.begin(), vector.end(), element);
@@ -277,7 +277,7 @@ namespace Rice
             {
               return iter - vector.begin();
             }
-          });
+          }, Arg("value"));
           rb_define_alias(klass_, "eql?", "==");
         }
         else
@@ -285,15 +285,15 @@ namespace Rice
           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"));
         }
       }
 
@@ -315,7 +315,7 @@ namespace Rice
               vector.erase(iter);
               return std::nullopt;
             }
-          })
+          }, Arg("pos"))
           .define_method("insert", [this](T& vector, Difference_T index, Parameter_T element) -> T&
           {
             size_t normalized = normalizeIndex(vector.size(), index, true);
@@ -329,7 +329,7 @@ namespace Rice
             auto iter = vector.begin() + normalized;
             vector.insert(iter, std::move(element));
             return vector;
-          })
+          }, Arg("pos"), Arg("value").keepAlive())
           .define_method("pop", [](T& vector) -> std::optional<Value_T>
           {
             if constexpr (!std::is_copy_assignable_v<Value_T>)
@@ -352,13 +352,13 @@ namespace Rice
           {
             vector.push_back(std::move(element));
             return vector;
-          })
+          }, Arg("value").keepAlive())
         .define_method("shrink_to_fit", &T::shrink_to_fit)
         .define_method("[]=", [this](T& vector, Difference_T index, Parameter_T element) -> void
           {
             index = normalizeIndex(vector.size(), index, true);
             vector[index] = std::move(element);
-          });
+          }, Arg("pos"), Arg("value").keepAlive());
 
         rb_define_alias(klass_, "push_back", "push");
         rb_define_alias(klass_, "<<", "push");
@@ -492,7 +492,19 @@ namespace Rice
           case RUBY_T_ARRAY:
             if constexpr (std::is_default_constructible_v<T>)
             {
-              return Convertible::Exact;
+              // For proper overload resolution when a function has multiple vector type
+              // overloads (e.g., vector<A>& and vector<B>&), we must check if the array
+              // elements can actually be converted to T. Otherwise all vector overloads
+              // score equally and the wrong one may be selected.
+              long size = RARRAY_LEN(value);
+              if (size == 0)
+              {
+                return Convertible::Exact;
+              }
+
+              From_Ruby<remove_cv_recursive_t<T>> fromRuby;
+              VALUE first = rb_ary_entry(value, 0);
+              return fromRuby.is_convertible(first);
             }
           default:
             return Convertible::None;
@@ -548,7 +560,19 @@ namespace Rice
           case RUBY_T_ARRAY:
             if constexpr (std::is_default_constructible_v<T>)
             {
-              return Convertible::Exact;
+              // For proper overload resolution when a function has multiple vector type
+              // overloads (e.g., vector<A>& and vector<B>&), we must check if the array
+              // elements can actually be converted to T. Otherwise all vector overloads
+              // score equally and the wrong one may be selected.
+              long size = RARRAY_LEN(value);
+              if (size == 0)
+              {
+                return Convertible::Exact;
+              }
+
+              From_Ruby<remove_cv_recursive_t<T>> fromRuby;
+              VALUE first = rb_ary_entry(value, 0);
+              return fromRuby.is_convertible(first);
             }
           default:
             return Convertible::None;
@@ -609,7 +633,19 @@ namespace Rice
           case RUBY_T_ARRAY:
             if constexpr (std::is_default_constructible_v<T>)
             {
-              return Convertible::Exact;
+              // For proper overload resolution when a function has multiple vector type
+              // overloads (e.g., vector<A>& and vector<B>&), we must check if the array
+              // elements can actually be converted to T. Otherwise all vector overloads
+              // score equally and the wrong one may be selected.
+              long size = RARRAY_LEN(value);
+              if (size == 0)
+              {
+                return Convertible::Exact;
+              }
+
+              From_Ruby<remove_cv_recursive_t<T>> fromRuby;
+              VALUE first = rb_ary_entry(value, 0);
+              return fromRuby.is_convertible(first);
             }
           default:
             return Convertible::None;

data/test/test_Attribute.cpp

@@ -22,6 +22,21 @@ TEARDOWN(Attribute)
 
 namespace
 {
+  class MyClass2
+  {
+  public:
+    MyClass2(int value) : value(value)
+    {
+    }
+
+    ~MyClass2()
+    {
+      value = -1;
+    }
+
+    int value = 0;
+  };
+
   class SomeClass
   {
   };
@@ -70,6 +85,7 @@ namespace
     char buf[2] = { '0', '1' };
     OldEnum oldEnum = OldValue1;
     NewEnum newEnum = NewEnum::NewValue1;
+    MyClass2* myClass2 = nullptr;
 
     std::string inspect()
     {
@@ -496,4 +512,60 @@ TESTCASE(CounterBufferAttribute)
                         struct.counters_buffer.class)";
   Class klass = (Class)m.module_eval(code);
   ASSERT_EQUAL("Rice::Pointer≺AnonymousNamespace꞉꞉Counter≻", klass.name().c_str());
+}
+
+TESTCASE(TakeOwnership)
+{
+  Module m = define_module("Testing");
+
+  define_class<MyClass2>("MyClass2")
+    .define_constructor(Constructor<MyClass2, int>());
+
+  define_class<DataStruct>("DataStruct")
+    .define_constructor(Constructor<DataStruct>())
+    .define_attr("my_class2", &DataStruct::myClass2, Rice::AttrAccess::ReadWrite, Arg("value").takeOwnership());
+
+  // Create DataStruct, create MyClass2, assign it, nil it, GC, then verify MyClass2 is still alive
+  std::string code = R"(
+    data_struct = DataStruct.new
+    my_class2 = MyClass2.new(42)
+    data_struct.my_class2 = my_class2
+    my_class2 = nil
+    GC.start
+    data_struct
+  )";
+
+  Data_Object<DataStruct> dataStruct = m.module_eval(code);
+
+  // This should work because ownership was transferred - MyClass2 is now owned by C++
+  ASSERT_NOT_EQUAL(nullptr, dataStruct->myClass2);
+  ASSERT_EQUAL(42, dataStruct->myClass2->value);
+}
+
+TESTCASE(KeepAlive)
+{
+  Module m = define_module("Testing");
+
+  define_class<MyClass2>("MyClass2")
+    .define_constructor(Constructor<MyClass2, int>());
+
+  define_class<DataStruct>("DataStruct")
+    .define_constructor(Constructor<DataStruct>())
+    .define_attr("my_class2", &DataStruct::myClass2, Rice::AttrAccess::ReadWrite, Arg("value").keepAlive());
+
+  // Create DataStruct, create MyClass2, assign it, nil it, GC, then verify MyClass2 is still alive
+  std::string code = R"(
+    data_struct = DataStruct.new
+    my_class2 = MyClass2.new(43)
+    data_struct.my_class2 = my_class2
+    my_class2 = nil
+    GC.start
+    data_struct
+  )";
+
+  Data_Object<DataStruct> dataStruct = m.module_eval(code);
+
+  // This should work because keepAlive prevents MyClass2 from being GC'd
+  ASSERT_NOT_EQUAL(nullptr, dataStruct->myClass2);
+  ASSERT_EQUAL(43, dataStruct->myClass2->value);
 }

data/test/test_Callback.cpp

@@ -55,7 +55,10 @@ 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
   ASSERT_EQUAL("1 - 2.0 - true - hello - 4", result);
 }
 

data/test/test_Stl_Map.cpp

@@ -706,3 +706,49 @@ TESTCASE(MapToHash)
   ASSERT_EQUAL("2", detail::From_Ruby<std::string>().convert(hash["Two"].value()));
   ASSERT_EQUAL("3", detail::From_Ruby<std::string>().convert(hash["Three"].value()));
 }
+
+namespace
+{
+  class MyClass2
+  {
+  public:
+    MyClass2(std::string name): name(name)
+    {
+    }
+    std::string name;
+  };
+}
+
+TESTCASE(KeepAlive)
+{
+  Class c = define_class<MyClass2>("MyClass2").
+    define_constructor(Constructor<MyClass2, std::string>()).
+    define_attr("name", &MyClass2::name, AttrAccess::Read);
+
+  define_map<std::string, MyClass2*>("MyClass2PointerMap");
+
+  Module m = define_module("Testing");
+
+  std::string code = R"(
+    map = Std::MyClass2PointerMap.new
+
+    # Test []=
+    map["one"] = MyClass2.new("instance1")
+    map["two"] = MyClass2.new("instance2")
+    map["three"] = MyClass2.new("instance3")
+
+    GC.start
+
+    names = []
+    map.each do |pair|
+      names << pair.second.name
+    end
+    names.sort
+  )";
+
+  Array result = m.module_eval(code);
+  ASSERT_EQUAL(3, result.size());
+  ASSERT_EQUAL("instance1", detail::From_Ruby<std::string>().convert(result[0].value()));
+  ASSERT_EQUAL("instance2", detail::From_Ruby<std::string>().convert(result[1].value()));
+  ASSERT_EQUAL("instance3", detail::From_Ruby<std::string>().convert(result[2].value()));
+}

data/test/test_Stl_Multimap.cpp

@@ -690,4 +690,50 @@ TESTCASE(HashToMultimapMixedTypes)
     m.module_eval(code),
     ASSERT_EQUAL("no implicit conversion of String into Integer", ex.what())
   );
+}
+
+namespace
+{
+  class MyClass2
+  {
+  public:
+    MyClass2(std::string name): name(name)
+    {
+    }
+    std::string name;
+  };
+}
+
+TESTCASE(KeepAlive)
+{
+  Class c = define_class<MyClass2>("MyClass2").
+    define_constructor(Constructor<MyClass2, std::string>()).
+    define_attr("name", &MyClass2::name, AttrAccess::Read);
+
+  define_multimap<std::string, MyClass2*>("MyClass2PointerMultimap");
+
+  Module m = define_module("Testing");
+
+  std::string code = R"(
+    map = Std::MyClass2PointerMultimap.new
+
+    # Test insert
+    map.insert("one", MyClass2.new("instance1"))
+    map.insert("two", MyClass2.new("instance2"))
+    map.insert("three", MyClass2.new("instance3"))
+
+    GC.start
+
+    names = []
+    map.each do |pair|
+      names << pair.second.name
+    end
+    names.sort
+  )";
+
+  Array result = m.module_eval(code);
+  ASSERT_EQUAL(3, result.size());
+  ASSERT_EQUAL("instance1", detail::From_Ruby<std::string>().convert(result[0].value()));
+  ASSERT_EQUAL("instance2", detail::From_Ruby<std::string>().convert(result[1].value()));
+  ASSERT_EQUAL("instance3", detail::From_Ruby<std::string>().convert(result[2].value()));
 }

data/test/test_Stl_Set.cpp

@@ -788,3 +788,37 @@ TESTCASE(Superset)
   Object result = m.instance_eval(code);
   ASSERT_EQUAL(Qtrue, result.value());
 }
+
+TESTCASE(KeepAlive)
+{
+  Class c = define_class<MyClass2>("MyClass2").
+    define_constructor(Constructor<MyClass2, std::string>()).
+    define_attr("name", &MyClass2::name, AttrAccess::Read);
+
+  define_set<MyClass2*>("MyClass2PointerSet");
+
+  Module m = define_module("Testing");
+
+  std::string code = R"(
+    set = Std::MyClass2PointerSet.new
+
+    # Test insert
+    set.insert(MyClass2.new("instance1"))
+    set.insert(MyClass2.new("instance2"))
+    set.insert(MyClass2.new("instance3"))
+
+    GC.start
+
+    names = []
+    set.each do |instance|
+      names << instance.name
+    end
+    names.sort
+  )";
+
+  Array result = m.module_eval(code);
+  ASSERT_EQUAL(3, result.size());
+  ASSERT_EQUAL("instance1", detail::From_Ruby<std::string>().convert(result[0].value()));
+  ASSERT_EQUAL("instance2", detail::From_Ruby<std::string>().convert(result[1].value()));
+  ASSERT_EQUAL("instance3", detail::From_Ruby<std::string>().convert(result[2].value()));
+}

data/test/test_Stl_Unordered_Map.cpp

@@ -704,3 +704,49 @@ TESTCASE(UnorderedMapToHash)
   ASSERT_EQUAL("2", detail::From_Ruby<std::string>().convert(hash["Two"].value()));
   ASSERT_EQUAL("3", detail::From_Ruby<std::string>().convert(hash["Three"].value()));
 }
+
+namespace
+{
+  class MyClass2
+  {
+  public:
+    MyClass2(std::string name): name(name)
+    {
+    }
+    std::string name;
+  };
+}
+
+TESTCASE(KeepAlive)
+{
+  Class c = define_class<MyClass2>("MyClass2").
+    define_constructor(Constructor<MyClass2, std::string>()).
+    define_attr("name", &MyClass2::name, AttrAccess::Read);
+
+  define_unordered_map<std::string, MyClass2*>("MyClass2PointerUnorderedMap");
+
+  Module m = define_module("Testing");
+
+  std::string code = R"(
+    map = Std::MyClass2PointerUnorderedMap.new
+
+    # Test []=
+    map["one"] = MyClass2.new("instance1")
+    map["two"] = MyClass2.new("instance2")
+    map["three"] = MyClass2.new("instance3")
+
+    GC.start
+
+    names = []
+    map.each do |pair|
+      names << pair.second.name
+    end
+    names.sort
+  )";
+
+  Array result = m.module_eval(code);
+  ASSERT_EQUAL(3, result.size());
+  ASSERT_EQUAL("instance1", detail::From_Ruby<std::string>().convert(result[0].value()));
+  ASSERT_EQUAL("instance2", detail::From_Ruby<std::string>().convert(result[1].value()));
+  ASSERT_EQUAL("instance3", detail::From_Ruby<std::string>().convert(result[2].value()));
+}

data/test/test_Stl_Variant.cpp

@@ -403,33 +403,29 @@ TESTCASE(VariantWithTwoVectors)
   Module m = define_module("Testing");
 
   std::string code = R"(vector = Std::Vector≺string≻.new
-                          vector << "a" << "b" << "c"
-                          my_class = MyClass4.new
-                          my_class.variant_index(vector))";
+                        vector << "a" << "b" << "c"
+                        my_class = MyClass4.new
+                        my_class.variant_index(vector))";
 
   Object result = m.module_eval(code);
   ASSERT_EQUAL(0u, detail::From_Ruby<size_t>().convert(result));
 
   code = R"(vector = Std::Vector≺int≻.new
-              vector.push_back(4)
-              my_class = MyClass4.new
-              my_class.variant_index(vector))";
+            vector.push_back(4)
+            my_class = MyClass4.new
+            my_class.variant_index(vector))";
   result = m.module_eval(code);
   ASSERT_EQUAL(1u, detail::From_Ruby<size_t>().convert(result));
 
   code = R"(my_class = MyClass4.new
-              my_class.variant_index(["x", "y", "z"]))";
+            my_class.variant_index(["x", "y", "z"]))";
   result = m.module_eval(code);
   ASSERT_EQUAL(0u, detail::From_Ruby<size_t>().convert(result));
 
   code = R"(my_class = MyClass4.new
-              my_class.variant_index([5, 6]))";
-
-  ASSERT_EXCEPTION_CHECK(
-    Exception,
-    m.module_eval(code),
-    ASSERT_EQUAL("wrong argument type Integer (expected String)", ex.what())
-  );
+            my_class.variant_index([5, 6]))";
+  result = m.module_eval(code);
+  ASSERT_EQUAL(1u, detail::From_Ruby<size_t>().convert(result));
 }
 
 namespace