rice 4.7.1 → 4.9.0

data/rice/traits/rice_traits.hpp

@@ -19,6 +19,10 @@ namespace Rice
     template<typename T>
     constexpr bool is_const_any_v = std::is_const_v<std::remove_pointer_t<std::remove_pointer_t<std::remove_reference_t<T>>>>;
 
+    // Helper to detect char types
+    template<typename T>
+    constexpr bool is_char_type_v = std::is_same_v<T, char> || std::is_same_v<T, signed char> || std::is_same_v<T, unsigned char>;
+
     // Recursively remove const/volatile
     template<typename T>
     struct remove_cv_recursive
@@ -109,45 +113,6 @@ namespace Rice
     template <typename T>
     constexpr bool is_std_vector_v = is_std_vector<T>::value;
 
-
-    // -- Tuple Helpers ---
-    template<typename T>
-    struct tuple_shift;
-
-    template<typename T, typename...Arg_Ts>
-    struct tuple_shift<std::tuple<T, Arg_Ts...>>
-    {
-      using type = std::tuple<Arg_Ts...>;
-    };
-
-    template<typename T, typename...Arg_Ts>
-    struct tuple_unshift;
-      
-    template<typename T, typename...Arg_Ts>
-    struct tuple_unshift<T, std::tuple<Arg_Ts...>>
-    {
-      using type = std::tuple<T, Arg_Ts...>;
-    };
-
-    template<template<typename, typename...> typename T, typename...Arg_Ts>
-    struct tuple_map;
-
-    template<template<typename, typename...> typename T, typename...Arg_Ts>
-    struct tuple_map<T, std::tuple<Arg_Ts...>>
-    {
-      using type = std::tuple<T<Arg_Ts>...>;
-    };
-
-
-    template<typename...Arg_Ts>
-    struct tuple_to_variant;
-
-    template<typename...Arg_Ts>
-    struct tuple_to_variant<std::tuple<Arg_Ts...>>
-    {
-      using type = std::variant<Arg_Ts...>;
-    };
-
     template<class T>
     struct is_pointer_pointer : std::false_type {};
 
@@ -186,6 +151,164 @@ namespace Rice
 
     template<typename T>
     constexpr bool is_wrapped_v = is_wrapped<T>::value;
+
+    // -- Tuple Helpers ---
+    template<typename T>
+    struct tuple_shift;
+
+    template<typename T, typename...Parameter_Ts>
+    struct tuple_shift<std::tuple<T, Parameter_Ts...>>
+    {
+      using type = std::tuple<Parameter_Ts...>;
+    };
+
+    template<typename T, typename...Parameter_Ts>
+    struct tuple_unshift;
+
+    template<typename T, typename...Parameter_Ts>
+    struct tuple_unshift<T, std::tuple<Parameter_Ts...>>
+    {
+      using type = std::tuple<T, Parameter_Ts...>;
+    };
+
+    template<template<typename, typename...> typename T, typename...Parameter_Ts>
+    struct tuple_map;
+
+    template<template<typename, typename...> typename T, typename...Parameter_Ts>
+    struct tuple_map<T, std::tuple<Parameter_Ts...>>
+    {
+      using type = std::tuple<T<Parameter_Ts>...>;
+    };
+
+    template<typename...Parameter_Ts>
+    struct tuple_to_variant;
+
+    template<typename...Parameter_Ts>
+    struct tuple_to_variant<std::tuple<Parameter_Ts...>>
+    {
+      using type = std::variant<Parameter_Ts...>;
+    };
+
+    template <typename T, typename... List>
+    struct is_one_of : std::disjunction<std::is_same<T, List>...> {};
+
+    template <typename T, typename... List>
+    constexpr bool is_one_of_v = is_one_of<T, List...>::value;
+
+    template<typename... FilterTypes, typename... Arg_Ts>
+    auto tuple_filter(const Arg_Ts&... args)
+    {
+      return std::tuple_cat([&args]()
+        {
+          if constexpr (is_one_of_v<Arg_Ts, FilterTypes...>)
+          {
+            return std::tuple<const Arg_Ts&>(args);
+          }
+          else
+          {
+            return std::tuple<>();
+          }
+        }()...);
+    };
+
+    // --- filter_types: recursively builds a new tuple of allowed types ---
+    template <typename Tuple, typename... Allowed>
+    struct tuple_filter_types;
+
+    template <typename... Ts, typename... Allowed>
+    struct tuple_filter_types<std::tuple<Ts...>, Allowed...>
+    {
+      using type = decltype(std::tuple_cat(std::declval<
+        std::conditional_t<is_one_of_v<std::decay_t<Ts>, Allowed...>, std::tuple<Ts>, std::tuple<>>>()...));
+    };
+
+    template <typename Tuple, typename... Allowed>
+    using tuple_filter_types_t = typename tuple_filter_types<Tuple, Allowed...>::type;
+
+    template <typename T, std::size_t... Is>
+    auto vector_to_tuple(const std::vector<T>& vec, std::index_sequence<Is...>)
+    {
+      return std::make_tuple(vec[Is]...);
+    }
+
+    template <typename Tuple, typename T, typename Seq>
+    struct tuple_pad_type;
+
+    template <typename... Ts, typename T, std::size_t... Is>
+    struct tuple_pad_type<std::tuple<Ts...>, T, std::index_sequence<Is...>>
+    {
+      // Use Is only to repeat T N times.
+      // std::conditional_t<true, T, something<Is>> is always T, but expands N times.
+      using type = std::tuple<
+        Ts...,
+        std::conditional_t<true, T, std::integral_constant<std::size_t, Is>>...
+      >;
+    };
+
+    template <typename Tuple, typename T, std::size_t N>
+    using tuple_pad_type_t = typename tuple_pad_type<Tuple, T, std::make_index_sequence<N>>::type;
+
+    // Pad tuple with values from a vector (vector size must match N)
+    template <std::size_t N, typename T, typename... Ts>
+    auto pad_tuple(const std::tuple<Ts...>& original, const std::vector<T>& padding)
+    {
+      if (padding.size() != N)
+      {
+        throw std::invalid_argument("Vector size doesn't match template parameter N");
+      }
+
+      auto padding_tuple = vector_to_tuple(padding, std::make_index_sequence<N>{});
+      return std::tuple_cat(original, padding_tuple);
+    }
+
+    template <typename Tuple, typename... Ts>
+    struct tuple_element_index_impl;
+
+    template <typename... Ts>
+    struct tuple_element_index_impl<std::tuple<>, Ts...>
+    {
+      static constexpr std::size_t value = 0;
+    };
+
+    template <typename First, typename... Rest, typename... Ts>
+    struct tuple_element_index_impl<std::tuple<First, Rest...>, Ts...>
+    {
+      static constexpr bool matches = (std::is_same_v<std::decay_t<First>, Ts> || ...);
+      static constexpr std::size_t value =
+        matches ? 0 : 1 + tuple_element_index_impl<std::tuple<Rest...>, Ts...>::value;
+    };
+
+    template <typename Tuple, typename... Ts>
+    struct tuple_element_index
+    {
+      static constexpr std::size_t value = tuple_element_index_impl<Tuple, Ts...>::value;
+    };
+
+    template <typename Tuple, typename... Ts>
+    inline constexpr std::size_t tuple_element_index_v = tuple_element_index<Tuple, Ts...>::value;
+
+    /* template<typename Target, typename T>
+     constexpr auto tuple_predicate(T&& element)
+     {
+       using U = std::decay_t<T>;
+       if constexpr (std::is_same_v<U, Target>)
+       {
+         return std::tuple<U>{ std::forward<T>(element) };
+       }
+       else
+       {
+         return std::tuple<>{};
+       }
+     }
+
+     template<typename Class_T, typename... Ts>
+     constexpr auto tuple_filter(Ts&&... args)
+     {
+       return std::tuple_cat(tuple_predicate<Class_T>(std::forward<Ts>(args))...);
+     }*/
+
+
+
   } // detail
 } // Rice
 

data/rice.gemspec

@@ -48,9 +48,7 @@ Ruby extensions with C++ easier.
     'FindRuby.cmake',
 
     # Include files
-    'include/rice/rice.hpp',
-    'include/rice/stl.hpp',
-    'include/rice/ruby-api.hpp',
+    'include/rice/*.hpp',
 
     # Bin files
     'bin/rice-rbs.rb',

data/test/test_Array.cpp

@@ -2,6 +2,8 @@
 #include "embed_ruby.hpp"
 #include <rice/rice.hpp>
 
+#include <algorithm>
+#include <iterator>
 #include <vector>
 
 using namespace Rice;
@@ -235,9 +237,9 @@ TESTCASE(iterate_and_call_member)
   Array::iterator it = a.begin();
   Array::iterator end = a.end();
   std::vector<Object> v;
-  for(int j = 0; it != end; ++j, ++it)
+  for(const auto& item: a)
   {
-    v.push_back(it->to_s());
+    v.push_back(Object(item).to_s());
   }
   ASSERT_EQUAL(42, detail::From_Ruby<int>().convert(a[0].value()));
   ASSERT_EQUAL(43, detail::From_Ruby<int>().convert(a[1].value()));
@@ -278,7 +280,7 @@ TESTCASE(assign_int)
 
 namespace
 {
-  void testArrayArg(Object self, Array string)
+  void testArrayArg(Object, Array)
   {
   }
 }
@@ -313,3 +315,259 @@ TESTCASE(array_from_ruby)
   Array a(rb_ary_new());
   ASSERT_EQUAL(a, detail::From_Ruby<Array>().convert(a));
 }
+
+// Random-access iterator tests
+TESTCASE(iterator_random_access_category)
+{
+  // Verify the iterator is now a random-access iterator
+  static_assert(std::is_same_v<
+    Array::iterator::iterator_category,
+    std::random_access_iterator_tag>,
+    "Array::iterator should be a random_access_iterator");
+
+  static_assert(std::is_same_v<
+    Array::const_iterator::iterator_category,
+    std::random_access_iterator_tag>,
+    "Array::const_iterator should be a random_access_iterator");
+}
+
+TESTCASE(iterator_arithmetic_add)
+{
+  Array a;
+  a.push(10, false);
+  a.push(20, false);
+  a.push(30, false);
+  a.push(40, false);
+  a.push(50, false);
+
+  Array::iterator it = a.begin();
+  Array::iterator it2 = it + 2;
+  ASSERT_EQUAL(30, detail::From_Ruby<int>().convert(it2->value()));
+
+  it2 = 3 + it;  // Test non-member operator+
+  ASSERT_EQUAL(40, detail::From_Ruby<int>().convert(it2->value()));
+}
+
+TESTCASE(iterator_arithmetic_subtract)
+{
+  Array a;
+  a.push(10, false);
+  a.push(20, false);
+  a.push(30, false);
+  a.push(40, false);
+  a.push(50, false);
+
+  Array::iterator it = a.end();
+  Array::iterator it2 = it - 2;
+  ASSERT_EQUAL(40, detail::From_Ruby<int>().convert(it2->value()));
+}
+
+TESTCASE(iterator_compound_assignment)
+{
+  Array a;
+  a.push(10, false);
+  a.push(20, false);
+  a.push(30, false);
+  a.push(40, false);
+  a.push(50, false);
+
+  Array::iterator it = a.begin();
+  it += 3;
+  ASSERT_EQUAL(40, detail::From_Ruby<int>().convert(it->value()));
+
+  it -= 2;
+  ASSERT_EQUAL(20, detail::From_Ruby<int>().convert(it->value()));
+}
+
+TESTCASE(iterator_difference)
+{
+  Array a;
+  a.push(10, false);
+  a.push(20, false);
+  a.push(30, false);
+  a.push(40, false);
+  a.push(50, false);
+
+  Array::iterator begin = a.begin();
+  Array::iterator end = a.end();
+  ASSERT_EQUAL(5, end - begin);
+  ASSERT_EQUAL(-5, begin - end);
+
+  Array::iterator mid = begin + 2;
+  ASSERT_EQUAL(2, mid - begin);
+  ASSERT_EQUAL(3, end - mid);
+}
+
+TESTCASE(iterator_subscript)
+{
+  Array a;
+  a.push(10, false);
+  a.push(20, false);
+  a.push(30, false);
+  a.push(40, false);
+  a.push(50, false);
+
+  Array::iterator it = a.begin();
+  ASSERT_EQUAL(10, detail::From_Ruby<int>().convert(it[0].value()));
+  ASSERT_EQUAL(30, detail::From_Ruby<int>().convert(it[2].value()));
+  ASSERT_EQUAL(50, detail::From_Ruby<int>().convert(it[4].value()));
+}
+
+TESTCASE(iterator_comparison_less_greater)
+{
+  Array a;
+  a.push(10, false);
+  a.push(20, false);
+  a.push(30, false);
+
+  Array::iterator begin = a.begin();
+  Array::iterator mid = begin + 1;
+  Array::iterator end = a.end();
+
+  ASSERT_EQUAL(true, begin < mid);
+  ASSERT_EQUAL(true, begin < end);
+  ASSERT_EQUAL(true, mid < end);
+
+  ASSERT_EQUAL(true, end > mid);
+  ASSERT_EQUAL(true, end > begin);
+  ASSERT_EQUAL(true, mid > begin);
+
+  ASSERT_EQUAL(true, begin <= begin);
+  ASSERT_EQUAL(true, begin <= mid);
+  ASSERT_EQUAL(true, mid <= end);
+
+  ASSERT_EQUAL(true, end >= end);
+  ASSERT_EQUAL(true, end >= mid);
+  ASSERT_EQUAL(true, mid >= begin);
+}
+
+TESTCASE(iterator_decrement)
+{
+  Array a;
+  a.push(10, false);
+  a.push(20, false);
+  a.push(30, false);
+
+  Array::iterator it = a.end();
+  --it;
+  ASSERT_EQUAL(30, detail::From_Ruby<int>().convert(it->value()));
+  --it;
+  ASSERT_EQUAL(20, detail::From_Ruby<int>().convert(it->value()));
+  --it;
+  ASSERT_EQUAL(10, detail::From_Ruby<int>().convert(it->value()));
+}
+
+TESTCASE(iterator_decrement_postfix)
+{
+  Array a;
+  a.push(10, false);
+  a.push(20, false);
+  a.push(30, false);
+
+  Array::iterator it = a.end();
+  it--;
+  ASSERT_EQUAL(30, detail::From_Ruby<int>().convert(it->value()));
+  Array::iterator prev = it--;
+  ASSERT_EQUAL(30, detail::From_Ruby<int>().convert(prev->value()));
+  ASSERT_EQUAL(20, detail::From_Ruby<int>().convert(it->value()));
+}
+
+TESTCASE(iterator_std_sort)
+{
+  // std::sort requires iterators that return assignable references.
+  // Our iterator returns a Proxy which supports assignment to the array,
+  // but STL algorithms need iter_swap to work. Test that we can use
+  // std::sort with explicit swap via indices instead.
+  Array a;
+  a.push(30, false);
+  a.push(10, false);
+  a.push(50, false);
+  a.push(20, false);
+  a.push(40, false);
+
+  // Manual sort using random-access capabilities (bubble sort for simplicity)
+  for (long i = 0; i < a.size() - 1; i++)
+  {
+    for (long j = 0; j < a.size() - i - 1; j++)
+    {
+      auto it = a.begin();
+      int val1 = detail::From_Ruby<int>().convert(it[j].value());
+      int val2 = detail::From_Ruby<int>().convert(it[j + 1].value());
+      if (val1 > val2)
+      {
+        // Swap using array subscript operator
+        Object temp = a[j];
+        a[j] = detail::From_Ruby<int>().convert(a[j + 1].value());
+        a[j + 1] = detail::From_Ruby<int>().convert(temp.value());
+      }
+    }
+  }
+
+  ASSERT_EQUAL(10, detail::From_Ruby<int>().convert(a[0].value()));
+  ASSERT_EQUAL(20, detail::From_Ruby<int>().convert(a[1].value()));
+  ASSERT_EQUAL(30, detail::From_Ruby<int>().convert(a[2].value()));
+  ASSERT_EQUAL(40, detail::From_Ruby<int>().convert(a[3].value()));
+  ASSERT_EQUAL(50, detail::From_Ruby<int>().convert(a[4].value()));
+}
+
+TESTCASE(iterator_std_reverse)
+{
+  // std::reverse requires iter_swap support. Test manual reverse using
+  // random-access iterator capabilities instead.
+  Array a;
+  a.push(10, false);
+  a.push(20, false);
+  a.push(30, false);
+  a.push(40, false);
+  a.push(50, false);
+
+  // Manual reverse using random-access capabilities
+  auto begin = a.begin();
+  auto end = a.end() - 1;
+  while (begin < end)
+  {
+    long i = begin.index();
+    long j = end.index();
+    Object temp = a[i];
+    a[i] = detail::From_Ruby<int>().convert(a[j].value());
+    a[j] = detail::From_Ruby<int>().convert(temp.value());
+    ++begin;
+    --end;
+  }
+
+  ASSERT_EQUAL(50, detail::From_Ruby<int>().convert(a[0].value()));
+  ASSERT_EQUAL(40, detail::From_Ruby<int>().convert(a[1].value()));
+  ASSERT_EQUAL(30, detail::From_Ruby<int>().convert(a[2].value()));
+  ASSERT_EQUAL(20, detail::From_Ruby<int>().convert(a[3].value()));
+  ASSERT_EQUAL(10, detail::From_Ruby<int>().convert(a[4].value()));
+}
+
+TESTCASE(iterator_std_distance)
+{
+  Array a;
+  a.push(10, false);
+  a.push(20, false);
+  a.push(30, false);
+  a.push(40, false);
+  a.push(50, false);
+
+  ASSERT_EQUAL(5, std::distance(a.begin(), a.end()));
+  ASSERT_EQUAL(3, std::distance(a.begin() + 1, a.begin() + 4));
+}
+
+TESTCASE(iterator_std_advance)
+{
+  Array a;
+  a.push(10, false);
+  a.push(20, false);
+  a.push(30, false);
+  a.push(40, false);
+  a.push(50, false);
+
+  Array::iterator it = a.begin();
+  std::advance(it, 3);
+  ASSERT_EQUAL(40, detail::From_Ruby<int>().convert(it->value()));
+
+  std::advance(it, -2);
+  ASSERT_EQUAL(20, detail::From_Ruby<int>().convert(it->value()));
+}

data/test/test_Attribute.cpp

@@ -28,6 +28,9 @@ namespace
 
   class NotAssignable
   {
+  public:
+    NotAssignable() = default;
+    NotAssignable(const NotAssignable&) = default;
     NotAssignable& operator=(const NotAssignable&) = delete;
   };
 
@@ -35,7 +38,7 @@ namespace
   {
   public:
     NotCopyable() = default;
-    NotCopyable(const NotCopyable& other) = delete;
+    NotCopyable(const NotCopyable&) = delete;
   };
 
   enum OldEnum
@@ -453,7 +456,7 @@ TESTCASE(BufferAttribute)
 
   Class c = define_class<BufferAttrs>("BufferAttrs")
     .define_constructor(Constructor<BufferAttrs>())
-    .define_attr("buffer", &BufferAttrs::buffer, Rice::AttrAccess::Read, Return().setBuffer());
+    .define_attr("buffer", &BufferAttrs::buffer, Rice::AttrAccess::Read, ReturnBuffer());
 
   std::string code = R"(struct = BufferAttrs.new
                         struct.buffer.class)";
@@ -487,7 +490,7 @@ TESTCASE(CounterBufferAttribute)
 
   define_class<BufferAttrs>("BufferAttrs")
     .define_constructor(Constructor<BufferAttrs>())
-    .define_attr("counters_buffer", &BufferAttrs::countersBuffer, Rice::AttrAccess::Read, Return().setBuffer());
+    .define_attr("counters_buffer", &BufferAttrs::countersBuffer, Rice::AttrAccess::Read, ReturnBuffer());
 
   std::string code = R"(struct = BufferAttrs.new
                         struct.counters_buffer.class)";

data/test/test_Buffer.cpp

@@ -255,8 +255,8 @@ namespace
 TESTCASE(pointer_of_doubles)
 {
   Module m = define_module("Testing").
-    define_module_function("speeds", &speeds, Return().setBuffer()).
-    define_module_function("speeds_ptr", &speedsPtr, Return().setBuffer());
+    define_module_function("speeds", &speeds, ReturnBuffer()).
+    define_module_function("speeds_ptr", &speedsPtr, ReturnBuffer());
 
   std::string code = R"(buffer = Rice::Buffer≺double≻.new(speeds, 3)
                         buffer[2])";
@@ -275,48 +275,12 @@ TESTCASE(pointer_of_doubles)
 
 namespace
 {
-  void updateRef(int& ref)
-  {
-    ref = 4;
-  }
-
   void updatePtr(int* ptr)
   {
     *ptr = 5;
   }
 }
 
-TESTCASE(update_reference)
-{
-  define_buffer<int>();
-  Module m = define_module("Testing");
-  m.define_module_function("update_reference", &updateRef);
-
-  std::string code = R"(buffer = Rice::Buffer≺int≻.new(0)
-                        update_reference(buffer.data)
-                        buffer.to_ary(1).first)";
-
-  Object result = m.module_eval(code);
-  ASSERT_EQUAL(4, detail::From_Ruby<int>().convert(result));
-
-  code = R"(buffer = Rice::Buffer≺int≻.new(0)
-            update_reference(buffer.data)
-            buffer[0])";
-
-  result = m.module_eval(code);
-  ASSERT_EQUAL(4, detail::From_Ruby<int>().convert(result));
-
-  code = R"(buffer = Rice::Buffer≺int≻.new(0)
-            update_reference(buffer.data)
-            buffer[1])";
-
-  ASSERT_EXCEPTION_CHECK(
-    Exception,
-    m.module_eval(code),
-    ASSERT_EQUAL("index 1 outside of bounds: 0..1", ex.what())
-  );
-}
-
 TESTCASE(update_ptr)
 {
   define_buffer<int>();
@@ -492,8 +456,8 @@ TESTCASE(pointer_of_objects)
   define_buffer<MyClassBuf*>();
 
   Module m = define_module("Testing").
-    define_module_function("class_buffs", &classBufs).
-    define_module_function("class_buffs_ptr", &classBufsPtr);
+    define_module_function("class_buffs", &classBufs, ReturnBuffer()).
+    define_module_function("class_buffs_ptr", &classBufsPtr, ReturnBuffer());
 
   define_class<MyClassBuf>("MyClassBuf").
     define_constructor(Constructor<MyClassBuf, int>()).
@@ -593,8 +557,8 @@ TESTCASE(array_of_objects_ptr)
 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, Arg("myClasses").setBuffer());
+  m.define_module_function<size_t(*)(const MyClassBuf*, size_t)>("sum_ids", &sumIds, ArgBuffer("myClasses"));
+  m.define_module_function<size_t(*)(const MyClassBuf**, size_t)>("sum_ids_ptr", &sumIds, ArgBuffer("myClasses"));
 
   define_class_under<MyClassBuf>(m, "MyClassBuf").
     define_constructor(Constructor<MyClassBuf, int>()).