rice 4.8.0 → 4.9.1

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_Inheritance.cpp

@@ -128,12 +128,12 @@ TESTCASE(base_pointer_method_call)
 
   Module m = define_module("Testing");
 
-  Object message = m.module_eval(R"EOS(notification = EmailNotification.new
-                                         notification.message)EOS");
+  Object message = m.module_eval(R"(notification = EmailNotification.new
+                                    notification.message)");
   ASSERT_EQUAL("Email", detail::From_Ruby<std::string>().convert(message));
 
-  message = m.module_eval(R"EOS(notification = PushNotification.new
-                                  notification.message)EOS");
+  message = m.module_eval(R"(notification = PushNotification.new
+                             notification.message)");
   ASSERT_EQUAL("Push", detail::From_Ruby<std::string>().convert(message));
 }
 
@@ -151,12 +151,12 @@ TESTCASE(base_pointer_function_argument)
   define_global_function("process_notification", &processNotification);
 
   Module m = define_module("Testing");
-  Object message = m.module_eval(R"EOS(notification = EmailNotification.new
-                                         process_notification(notification))EOS");
+  Object message = m.module_eval(R"(notification = EmailNotification.new
+                                    process_notification(notification))");
   ASSERT_EQUAL("Email", detail::From_Ruby<std::string>().convert(message));
 
-  message = m.module_eval(R"EOS(notification = PushNotification.new
-                                  process_notification(notification))EOS");
+  message = m.module_eval(R"(notification = PushNotification.new
+                             process_notification(notification))");
   ASSERT_EQUAL("Push", detail::From_Ruby<std::string>().convert(message));
 }
 
@@ -175,12 +175,12 @@ TESTCASE(module_base_pointer_method_call)
 
   Module m = define_module("Testing");
 
-  Object message = m.module_eval(R"EOS(notification = Inheritance::EmailNotification.new
-                                       notification.message)EOS");
+  Object message = m.module_eval(R"(notification = Inheritance::EmailNotification.new
+                                    notification.message)");
   ASSERT_EQUAL("Email", detail::From_Ruby<std::string>().convert(message));
 
-  message = m.module_eval(R"EOS(notification = Inheritance::PushNotification.new
-                                  notification.message)EOS");
+  message = m.module_eval(R"(notification = Inheritance::PushNotification.new
+                             notification.message)");
   ASSERT_EQUAL("Push", detail::From_Ruby<std::string>().convert(message));
 }
 
@@ -219,8 +219,8 @@ TESTCASE(base_pointer_constructor)
 
   Module m = define_module("Testing");
 
-  Object result = m.module_eval(R"EOS(notification = PushNotification.new
+  Object result = m.module_eval(R"(notification = PushNotification.new
                                         processor = Processor.new(notification)
-                                        processor.process)EOS");
+                                        processor.process)");
   ASSERT_EQUAL("Push", detail::From_Ruby<std::string>().convert(result));
 }

data/test/test_Keep_Alive_No_Wrapper.cpp

@@ -75,11 +75,15 @@ TESTCASE(test_keep_alive_no_wrapper)
   Module m = define_module("TestingModule");
   Object zoo = m.module_eval("@zoo = Zoo.new");
 
+  std::string code = R"(@zoo.get_pets.each do |pet|
+                          puts pet.get_name
+                        end)";
+
   // get_pets returns an Array (builtin type) so Return().keepAlive()
-  // shall result in std::runtime_error
+  // should result in std::runtime_error
   ASSERT_EXCEPTION_CHECK(
     Exception,
-    m.module_eval("@zoo.get_pets.each do |pet| puts pet.name; end"),
+    m.module_eval(code),
     ASSERT_EQUAL("wrong argument type Array (expected wrapped C++ object)",
                  ex.what())
   );

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()));
+}