rice 4.6.0 → 4.6.1

data/rice/Data_Type.ipp

@@ -61,7 +61,7 @@ namespace Rice
 
     auto instances = unbound_instances();
     for (auto instance: instances)
-    { 
+    {
       instance->set_value(klass);
     }
     instances.clear();
@@ -240,7 +240,7 @@ namespace Rice
       return false;
     }
   }
-   
+
   template<typename Base_T>
   inline Class get_superklass()
   {
@@ -280,7 +280,7 @@ namespace Rice
     Class superKlass = get_superklass<Base_T>();
     return define_class_under<T, Base_T>(parent, id, superKlass);
   }
-  
+
   template<typename T, typename Base_T>
   inline Data_Type<T> define_class(char const* name)
   {
@@ -314,42 +314,53 @@ namespace Rice
   template <typename Attribute_T>
   inline Data_Type<T>& Data_Type<T>::define_attr(std::string name, Attribute_T attribute, AttrAccess access)
   {
-    // Make sure the Attribute type has been previously seen by Rice
-    detail::verifyType<typename detail::attribute_traits<Attribute_T>::attr_type>();
-
-    // Define native attribute getter
-    if (access == AttrAccess::ReadWrite || access == AttrAccess::Read)
-      detail::NativeAttributeGet<Attribute_T>::define(klass_, name, std::forward<Attribute_T>(attribute));
-
-    using Attr_T = typename detail::NativeAttributeSet<Attribute_T>::Attr_T;
-    if constexpr (!std::is_const_v<Attr_T> &&
-                  (std::is_fundamental_v<Attr_T> || std::is_assignable_v<Attr_T, Attr_T>))
-    {
-      // Define native attribute setter
-      if (access == AttrAccess::ReadWrite || access == AttrAccess::Write)
-        detail::NativeAttributeSet<Attribute_T>::define(klass_, name, std::forward<Attribute_T>(attribute));
-    }
-
-    return *this;
+    return this->define_attr_internal<Attribute_T>(this->klass_, name, std::forward<Attribute_T>(attribute), access);
   }
 
   template <typename T>
   template <typename Attribute_T>
   inline Data_Type<T>& Data_Type<T>::define_singleton_attr(std::string name, Attribute_T attribute, AttrAccess access)
   {
-    // Make sure the Attribute type has been previously seen by Rice
-    detail::verifyType<typename detail::attribute_traits<Attribute_T>::attr_type>();
-
-    // Define native attribute
     VALUE singleton = detail::protect(rb_singleton_class, this->value());
+    return this->define_attr_internal<Attribute_T>(singleton, name, std::forward<Attribute_T>(attribute), access);
+  }
+
+  template <typename T>
+  template <typename Attribute_T>
+  inline Data_Type<T>& Data_Type<T>::define_attr_internal(VALUE klass, std::string name, Attribute_T attribute, AttrAccess access)
+  {
+    using Attr_T = typename detail::attribute_traits<Attribute_T>::attr_type;
 
-    // Define native attribute getter
+    // Make sure the Attribute type has been previously seen by Rice
+    detail::verifyType<Attr_T>();
+
+    // Define attribute getter
     if (access == AttrAccess::ReadWrite || access == AttrAccess::Read)
-      detail::NativeAttributeGet<Attribute_T>::define(singleton, name, std::forward<Attribute_T>(attribute));
+    {
+      detail::NativeAttributeGet<Attribute_T>::define(klass, name, std::forward<Attribute_T>(attribute));
+    }
 
-    // Define native attribute setter
+    // Define attribute setter
     if (access == AttrAccess::ReadWrite || access == AttrAccess::Write)
-      detail::NativeAttributeSet<Attribute_T>::define(singleton, name, std::forward<Attribute_T>(attribute));
+    {
+      if constexpr (std::is_const_v<Attr_T>)
+      {
+        throw std::runtime_error("Cannot define attribute writer for a const attribute: " + name);
+      }
+      else if constexpr (!std::is_fundamental_v<Attr_T> && !std::is_assignable_v<Attr_T, Attr_T>)
+      {
+        throw std::runtime_error("Cannot define attribute writer for a non assignable attribute: " + name);
+      }
+      else if constexpr (!std::is_fundamental_v<Attr_T> && !std::is_copy_constructible_v<Attr_T>)
+      {
+        throw std::runtime_error("Cannot define attribute writer for a non copy constructible attribute: " + name);
+      }
+      else
+      {
+        // Define native attribute setter
+        detail::NativeAttributeSet<Attribute_T>::define(klass, name, std::forward<Attribute_T>(attribute));
+      }
+    }
 
     return *this;
   }

data/rice/detail/NativeAttributeGet.ipp

@@ -41,7 +41,18 @@ namespace Rice::detail
     if constexpr (std::is_member_object_pointer_v<Attribute_T>)
     {
       Receiver_T* nativeSelf = From_Ruby<Receiver_T*>().convert(self);
-      return To_Ruby<To_Ruby_T>().convert(nativeSelf->*attribute_);
+
+      if constexpr (std::is_fundamental_v<detail::intrinsic_type<To_Ruby_T>> ||
+                    (std::is_array_v<To_Ruby_T> && std::is_fundamental_v<std::remove_extent_t<To_Ruby_T>>))
+      {
+        return To_Ruby<To_Ruby_T>().convert(nativeSelf->*attribute_);
+      }
+      else
+      {
+        // If the attribute is an object return a reference to avoid a copy (and avoid issues with
+        // attributes that are not assignable, copy constructible or move constructible)
+        return To_Ruby<To_Ruby_T&>().convert(nativeSelf->*attribute_);
+      }
     }
     else
     {

data/rice/detail/NativeAttributeSet.ipp

@@ -42,39 +42,21 @@ namespace Rice::detail
   template<typename Attribute_T>
   inline VALUE NativeAttributeSet<Attribute_T>::operator()(size_t argc, const VALUE* argv, VALUE self)
   {
-    if constexpr (std::is_fundamental_v<intrinsic_type<Attr_T>> && std::is_pointer_v<Attr_T>)
-    {
-      static_assert(true, "An fundamental value, such as an integer, cannot be assigned to an attribute that is a pointer.");
-    }
-    else if constexpr (std::is_same_v<intrinsic_type<Attr_T>, std::string> && std::is_pointer_v<Attr_T>)
-    {
-      static_assert(true, "An string cannot be assigned to an attribute that is a pointer.");
-    }
-
     if (argc != 1)
     {
       throw std::runtime_error("Incorrect number of parameters for setting attribute. Attribute: " + this->name_);
     }
 
     VALUE value = argv[0];
-    
-    if constexpr (!std::is_null_pointer_v<Receiver_T> && 
-                  !std::is_const_v<Attr_T> && 
-                  (std::is_fundamental_v<Attr_T> || std::is_assignable_v<Attr_T, Attr_T>))
+
+    if constexpr (!std::is_null_pointer_v<Receiver_T>)
     {
       Receiver_T* nativeSelf = From_Ruby<Receiver_T*>().convert(self);
       nativeSelf->*attribute_ = From_Ruby<T_Unqualified>().convert(value);
     }
-    else if constexpr (std::is_null_pointer_v<Receiver_T> && 
-                       !std::is_const_v<Attr_T> &&
-                       (std::is_fundamental_v<Attr_T> || std::is_assignable_v<Attr_T, Attr_T>))
-    {
-      *attribute_ = From_Ruby<T_Unqualified>().convert(value);
-    }
     else
     {
-      // Should never get here because define_attr won't compile this code, but just in case!
-      throw std::invalid_argument("Could not set attribute. Attribute: " + this->name_);
+      *attribute_ = From_Ruby<T_Unqualified>().convert(value);
     }
 
     return value;

data/rice/detail/NativeCallbackFFI.ipp

@@ -1,4 +1,5 @@
 #ifdef HAVE_LIBFFI
+#include <tuple>
 #include <ffi.h>
 
 namespace Rice::detail

data/rice/detail/NativeFunction.ipp

@@ -2,6 +2,7 @@
 #include <array>
 #include <stdexcept>
 #include <sstream>
+#include <tuple>
 
 namespace Rice::detail
 {

data/rice/detail/RubyFunction.ipp

@@ -1,5 +1,6 @@
 
 #include <any>
+#include <tuple>
 
 namespace Rice::detail
 {

data/rice/detail/Type.ipp

@@ -228,7 +228,6 @@ namespace Rice::detail
     return base;
   }
 
-
   inline std::string rubyClassName(const std::string& typeInfoName)
   {
     std::string base = cppClassName(typeInfoName);

data/rice/stl/vector.ipp

@@ -133,68 +133,67 @@ namespace Rice
           }
         })
         .define_method("last", [](const T& vector) -> std::optional<Value_T>
+        {
+          if (vector.size() > 0)
           {
-            if (vector.size() > 0)
-            {
-              return vector.back();
-            }
-            else
-            {
-              return std::nullopt;
-            }
-          })
+            return vector.back();
+          }
+          else
+          {
+            return std::nullopt;
+          }
+        })
         .define_method("[]", [this](const T& vector, Difference_T index) -> std::optional<Value_T>
+        {
+          index = normalizeIndex(vector.size(), index);
+          if (index < 0 || index >= (Difference_T)vector.size())
           {
-            index = normalizeIndex(vector.size(), index);
-            if (index < 0 || index >= (Difference_T)vector.size())
-            {
-              return std::nullopt;
-            }
-            else
-            {
-              return vector[index];
-            }
-          })
+            return std::nullopt;
+          }
+          else
+          {
+            return vector[index];
+          }
+        })
         .define_method("[]", [this](const T& vector, Difference_T start, Difference_T length) -> VALUE
+        {
+          start = normalizeIndex(vector.size(), start);
+          if (start < 0 || start >= (Difference_T)vector.size())
+          {
+            return rb_ary_new();
+          }
+          else
           {
-            start = normalizeIndex(vector.size(), start);
-            if (start < 0 || start >= (Difference_T)vector.size())
+            auto begin = vector.begin() + start;
+
+            // Ruby does not throw an exception when the length is too long
+            Difference_T size = (Difference_T)vector.size();
+            if (start + length > size)
             {
-              return rb_ary_new();
+              length = size - start;
             }
-            else
-            {
-              auto begin = vector.begin() + start;
-
-              // Ruby does not throw an exception when the length is too long
-              Difference_T size = (Difference_T)vector.size();
-              if (start + length > size)
-              {
-                length = size - start;
-              }
 
-              auto finish = vector.begin() + start + length;
-              T slice(begin, finish);
+            auto finish = vector.begin() + start + length;
+            T slice(begin, finish);
 
-              VALUE result = rb_ary_new();
-              std::for_each(slice.begin(), slice.end(), [&result](const Reference_T element)
-              {
-                VALUE value = detail::To_Ruby<Parameter_T>().convert(element);
-                rb_ary_push(result, value);
-              });
-
-              return result;
-            }
-          }, Return().setValue());
+            VALUE result = rb_ary_new();
+            std::for_each(slice.begin(), slice.end(), [&result](const Reference_T element)
+            {
+              VALUE value = detail::To_Ruby<Parameter_T>().convert(element);
+              rb_ary_push(result, value);
+            });
 
-          if constexpr (!std::is_same_v<Value_T, bool>)
-          {
-            define_buffer<Value_T>();
-            define_buffer<Value_T*>();
-            klass_.template define_method<Value_T*(T::*)()>("data", &T::data);
+            return result;
           }
+        }, Return().setValue());
+
+        if constexpr (!std::is_same_v<Value_T, bool>)
+        {
+          define_buffer<Value_T>();
+          klass_.template define_method<Value_T*(T::*)()>("data", &T::data);
+        }
 
-          rb_define_alias(klass_, "at", "[]");
+        rb_define_alias(klass_, "at", "[]");
       }
 
       // Methods that require Value_T to support operator==

data/rice/traits/attribute_traits.hpp

@@ -9,17 +9,17 @@ namespace Rice::detail
   template<typename Attribute_T>
   struct attribute_traits;
 
-  template<typename Attr_T>
-  struct attribute_traits<Attr_T*>
+  template<typename Attribute_T>
+  struct attribute_traits<Attribute_T*>
   {
-    using attr_type = Attr_T;
+    using attr_type = Attribute_T;
     using class_type = std::nullptr_t;
   };
 
-  template<typename Attr_T, typename Class_T>
-  struct attribute_traits<Attr_T Class_T::*> 
+  template<typename Attribute_T, typename Class_T>
+  struct attribute_traits<Attribute_T(Class_T::*)>
   {
-    using attr_type = Attr_T;
+    using attr_type = Attribute_T;
     using class_type = Class_T;
   };
 }

data/rice/traits/rice_traits.hpp

@@ -2,6 +2,7 @@
 #define Rice__detail__traits__hpp_
 
 #include <ostream>
+#include <tuple>
 #include <type_traits>
 #include <variant>
 #include <vector>
@@ -154,6 +155,17 @@ namespace Rice
           (callable(std::forward<decltype(args)>(args)), ...);
         }, std::forward<Tuple_T>(tuple));
     }
+
+    template<typename T, typename = void>
+    struct is_wrapped : std::true_type {};
+
+    template<typename T>
+    struct is_wrapped<T, std::enable_if_t<std::is_fundamental_v<detail::intrinsic_type<T>> ||
+                                          std::is_same_v<detail::intrinsic_type<T>, std::string>>
+                     >: std::false_type {};
+
+    template<typename T>
+    constexpr bool is_wrapped_v = is_wrapped<T>::value;
   } // detail
 } // Rice
 

data/test/test_Attribute.cpp

@@ -31,6 +31,13 @@ namespace
     NotAssignable& operator=(const NotAssignable&) = delete;
   };
 
+  class NotCopyable
+  {
+  public:
+    NotCopyable() = default;
+    NotCopyable(const NotCopyable& other) = delete;
+  };
+
   struct DataStruct
   {
     static inline float staticFloat = 1.0;
@@ -43,6 +50,7 @@ namespace
     const int constInt = 5;
     SomeClass someClass;
     NotAssignable notAssignable;
+    NotCopyable notCopyable;
 
     std::string inspect()
     {
@@ -138,12 +146,18 @@ TESTCASE(vector)
 
 TESTCASE(const_attribute)
 {
-  Class c = define_class<DataStruct>("DataStruct")
-    .define_constructor(Constructor<DataStruct>())
-    .define_attr("const_int", &DataStruct::constInt);
+  Data_Type<DataStruct> c = define_class<DataStruct>("DataStruct")
+    .define_constructor(Constructor<DataStruct>());
 
-  Data_Object<DataStruct> o = c.call("new");
+  ASSERT_EXCEPTION_CHECK(
+    std::exception,
+    c.define_attr("const_int", &DataStruct::constInt),
+    ASSERT_EQUAL(ex.what(), "Cannot define attribute writer for a const attribute: const_int")
+  );
 
+  c.define_attr("const_int", &DataStruct::constInt, AttrAccess::Read);
+  Data_Object<DataStruct> o = c.call("new");
+    
   if constexpr (!oldRuby)
   {
     ASSERT_EXCEPTION_CHECK(
@@ -154,15 +168,21 @@ TESTCASE(const_attribute)
   }
 }
 
-TESTCASE(not_copyable_attribute)
+TESTCASE(not_assignable)
 {
   Class notAssignableClass = define_class<NotAssignable>("NotAssignable")
     .define_constructor(Constructor<NotAssignable>());
     
-  Class c = define_class<DataStruct>("DataStruct")
-    .define_constructor(Constructor<DataStruct>())
-    .define_attr("not_assignable", &DataStruct::notAssignable);
+  Data_Type<DataStruct> c = define_class<DataStruct>("DataStruct")
+    .define_constructor(Constructor<DataStruct>());
 
+  ASSERT_EXCEPTION_CHECK(
+    std::exception,
+    c.define_attr("not_assignable", &DataStruct::notAssignable),
+    ASSERT_EQUAL(ex.what(), "Cannot define attribute writer for a non assignable attribute: not_assignable")
+  );
+
+  c.define_attr("not_assignable", &DataStruct::notAssignable, AttrAccess::Read);
   Data_Object<NotAssignable> notAssignable = notAssignableClass.call("new");
 
   Data_Object<DataStruct> o = c.call("new");
@@ -177,6 +197,35 @@ TESTCASE(not_copyable_attribute)
   }
 }
 
+TESTCASE(not_copyable)
+{
+  Class notCopyableClass = define_class<NotCopyable>("NotCopyable")
+    .define_constructor(Constructor<NotCopyable>());
+
+  Data_Type<DataStruct> c = define_class<DataStruct>("DataStruct")
+    .define_constructor(Constructor<DataStruct>());
+
+  ASSERT_EXCEPTION_CHECK(
+    std::exception,
+    c.define_attr("not_copyable", &DataStruct::notCopyable),
+    ASSERT_EQUAL(ex.what(), "Cannot define attribute writer for a non copy constructible attribute: not_copyable")
+  );
+
+  c.define_attr("not_copyable", &DataStruct::notCopyable, AttrAccess::Read);
+  Data_Object<NotCopyable> notCopyable = notCopyableClass.call("new");
+
+  Data_Object<DataStruct> o = c.call("new");
+
+  if constexpr (!oldRuby)
+  {
+    ASSERT_EXCEPTION_CHECK(
+      Exception,
+      o.call("not_assignable=", notCopyable),
+      ASSERT(std::string(ex.what()).find("undefined method `not_copyable='") == 0)
+    );
+  }
+}
+
 TESTCASE(static_attributes)
 {
   Class c = define_class<DataStruct>("DataStruct")

data/test/test_Buffer.cpp

@@ -1,4 +1,4 @@
-#include "unittest.hpp"
+#include "unittest.hpp"
 #include "embed_ruby.hpp"
 #include <rice/rice.hpp>
 
@@ -283,3 +283,58 @@ TESTCASE(update_buffer)
     ASSERT_EQUAL("index 1 outside of bounds: 0..1", ex.what())
   );
 }
+
+TESTCASE(to_s)
+{
+  define_buffer<unsigned char>();
+  Module m = define_module("Testing");
+
+  std::string code = R"(buffer = Rice::Buffer≺unsigned char≻.new([0, 127, 128, 255, 256, -128, -129, -255])
+                        buffer.to_s)";
+  String result = m.instance_eval(code);
+  ASSERT_EQUAL("Buffer<type: unsigned char*, size: 8>", result.c_str());
+
+  Buffer<unsigned char> buffer(nullptr);
+  result = buffer.toString();
+  ASSERT_EQUAL("Buffer<type: unsigned char*, size: 0>", result.c_str());
+}
+
+namespace
+{
+  class MyClass
+  {
+  public:
+    MyClass(int id) : id(id)
+    {
+    }
+
+    MyClass& operator=(const MyClass&) = delete;
+
+    int id;
+  };
+}
+
+TESTCASE(array_of_objects)
+{
+  define_buffer<MyClass*>();
+
+  define_class<MyClass>("MyClass").
+    define_constructor(Constructor<MyClass, int>()).
+    define_attr("id", &MyClass::id);
+
+  std::string code = R"(array = [MyClass.new(0), MyClass.new(1)]
+                        buffer = Rice::Buffer≺AnonymousNamespace꞉꞉MyClass∗≻.new(array)
+                        buffer[1].id)";
+
+  Module m = define_module("Testing");
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(1, detail::From_Ruby<int>().convert(result));
+
+  code = R"(array = [MyClass.new(0), MyClass.new(1)]
+            buffer = Rice::Buffer≺AnonymousNamespace꞉꞉MyClass∗≻.new(array)
+            buffer[1] = MyClass.new(2)
+            buffer[1].id)";
+
+  result = m.module_eval(code);
+  ASSERT_EQUAL(2, detail::From_Ruby<int>().convert(result));
+}

data/test/test_Data_Object.cpp

@@ -244,7 +244,7 @@ TESTCASE(data_object_update_buffer)
   Object result = m.module_eval(code);
   Data_Object<Buffer<MyDataType>> dataObject(result);
   Buffer<MyDataType>* buffer = dataObject.get();
-  MyDataType myDataType = buffer->get(2);
+  MyDataType myDataType = buffer->operator[](2);
   ASSERT_EQUAL(100, myDataType.x);
 }
 

data/test/test_From_Ruby.cpp

@@ -1,4 +1,4 @@
-#include "unittest.hpp"
+#include "unittest.hpp"
 #include "embed_ruby.hpp"
 #include <rice/rice.hpp>
 #include <rice/stl.hpp>
@@ -160,7 +160,7 @@ TESTCASE(char_pointer)
   ASSERT_EXCEPTION_CHECK(
     Exception,
     fromRuby.convert(rb_float_new(11.11)),
-    ASSERT_EQUAL("wrong argument type Float (expected Buffer≺char≻)", ex.what())
+    ASSERT_EQUAL("wrong argument type Float (expected Buffer≺char‚ void≻)", ex.what())
   );
 }
 
@@ -195,7 +195,7 @@ TESTCASE(signed_char_pointer)
   ASSERT_EXCEPTION_CHECK(
     Exception,
     fromRuby.convert(rb_float_new(11.11)),
-    ASSERT_EQUAL("wrong argument type Float (expected Buffer≺signed char≻)", ex.what())
+    ASSERT_EQUAL("wrong argument type Float (expected Buffer≺signed char‚ void≻)", ex.what())
   );
 }
 
@@ -218,7 +218,7 @@ TESTCASE(char_pointer_const)
   ASSERT_EXCEPTION_CHECK(
     Exception,
     detail::From_Ruby<char const*>().convert(rb_float_new(32.3)),
-    ASSERT_EQUAL("wrong argument type Float (expected Buffer≺char≻)", ex.what())
+    ASSERT_EQUAL("wrong argument type Float (expected Buffer≺char‚ void≻)", ex.what())
   );
 }
 
@@ -272,7 +272,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 Float (expected Buffer≺char≻)", ex.what())
+    ASSERT_EQUAL("wrong argument type Float (expected Buffer≺char‚ void≻)", ex.what())
   );
 }
 
@@ -434,7 +434,7 @@ TESTCASE(float_array_array)
   ASSERT_EXCEPTION_CHECK(
     Exception,
     m.module_eval(code),
-    ASSERT_EQUAL("wrong argument type Array (expected Buffer≺float∗≻)", ex.what())
+    ASSERT_EQUAL("wrong argument type Array (expected Buffer≺float∗‚ void≻)", ex.what())
   );
 }
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rice
 version: !ruby/object:Gem::Version
-  version: 4.6.0
+  version: 4.6.1
 platform: ruby
 authors:
 - Paul Brannan