rice 4.5.0 → 4.6.1

data/rice/traits/function_traits.hpp

@@ -0,0 +1,95 @@
+#ifndef Rice__detail__function_traits__hpp_
+#define Rice__detail__function_traits__hpp_
+
+#include <tuple>
+
+namespace Rice::detail
+{
+  // Base class
+  template<typename Function_T>
+  struct function_traits;
+
+  template<typename Return_T, typename Class_T, typename...Arg_Ts>
+  struct function_traits<Return_T(Class_T, Arg_Ts...)>
+  {
+    using arg_types = std::tuple<Arg_Ts...>;
+
+    static constexpr std::size_t arity = sizeof...(Arg_Ts);
+
+    template<std::size_t N>
+    using nth_arg = typename std::tuple_element<N, arg_types>::type;
+
+    using return_type = Return_T;
+    using class_type = Class_T;
+  };
+
+  // Functors and lambdas with operator()
+  template<typename Function_T>
+  struct function_traits : public function_traits<decltype(&Function_T::operator())>
+  {
+  private:
+    using functor_t = function_traits<decltype(&Function_T::operator())>;
+
+  public:
+    using arg_types = typename functor_t::arg_types;
+    static constexpr std::size_t arity = functor_t::arity - 1;
+    using class_type = std::nullptr_t;
+  };
+
+  // C functions and static member functions passed by pointer
+  template<typename Return_T, typename ...Arg_Ts>
+  struct function_traits<Return_T(*)(Arg_Ts...)> : public function_traits<Return_T(std::nullptr_t, Arg_Ts...)>
+  {
+    using Function_T = Return_T(*)(Arg_Ts...);
+  };
+  
+  // C functions passed by pointer that take one or more defined parameter than a variable 
+  // number of parameters (the second ...)
+  template<typename Return_T, typename ...Arg_Ts>
+  struct function_traits<Return_T(*)(Arg_Ts..., ...)> : public function_traits<Return_T(std::nullptr_t, Arg_Ts...)>
+  {
+  };
+
+  // C Functions or static member functions passed by reference
+  template<typename Return_T, typename ...Arg_Ts>
+  struct function_traits<Return_T(&)(Arg_Ts...)> : public function_traits<Return_T(std::nullptr_t, Arg_Ts...)>
+  {
+  };
+
+  // Member Functions on C++ classes
+  template<typename Return_T, typename Class_T, typename...Arg_Ts>
+  struct function_traits<Return_T(Class_T::*)(Arg_Ts...)> : public function_traits<Return_T(Class_T*, Arg_Ts...)>
+  {
+  };
+
+  // const member Functions on C++ classes
+  template<typename Return_T, typename Class_T, typename...Arg_Ts>
+  struct function_traits<Return_T(Class_T::*)(Arg_Ts...) const> : public function_traits<Return_T(Class_T*, Arg_Ts...)>
+  {
+  };
+
+  // noexcept member Functions on C++ classes
+  template<typename Return_T, typename Class_T, typename...Arg_Ts>
+  struct function_traits<Return_T(Class_T::*)(Arg_Ts...) noexcept> : public function_traits<Return_T(Class_T*, Arg_Ts...)>
+  {
+  };
+
+
+  // const noexcept member Functions on C++ classes
+  template<typename Return_T, typename Class_T, typename...Arg_Ts>
+  struct function_traits<Return_T(Class_T::*)(Arg_Ts...) const noexcept> : public function_traits<Return_T(Class_T*, Arg_Ts...)>
+  {
+  };
+
+  /*// Functors and lambdas
+  template<class Function_T>
+  struct function_traits<Function_T&> : public function_traits<Function_T>
+  {
+  };
+
+  template<class Function_T>
+  struct function_traits<Function_T&&> : public function_traits<Function_T>
+  {
+  };*/
+}
+#endif // Rice__detail__function_traits__hpp_

data/rice/traits/method_traits.hpp

@@ -0,0 +1,47 @@
+#ifndef Rice__detail__method_traits__hpp_
+#define Rice__detail__method_traits__hpp_
+
+#include <tuple>
+
+namespace Rice::detail
+{
+  // Declare struct
+  template<typename Function_T, bool IsMethod, typename = void>
+  struct method_traits;
+
+  // Functions that do not have a self parameter:
+  //   doSomething(int a)
+  template<typename Function_T, bool IsMethod>
+  struct method_traits<Function_T, IsMethod, std::enable_if_t<!IsMethod>>
+  {
+    using Return_T = typename function_traits<Function_T>::return_type;
+    using Class_T = std::nullptr_t;
+    using Arg_Ts = typename function_traits<Function_T>::arg_types;
+    static constexpr std::size_t arity = std::tuple_size_v<Arg_Ts>;
+  };
+
+  /* Functions that have a self parameter and thus we treat them as free standing
+    "methods" versus member functions. 
+    
+       doSomething(VALUE self, int a) */
+  template<typename Function_T, bool IsMethod>
+  struct method_traits<Function_T, IsMethod, std::enable_if_t<IsMethod && std::is_same_v<typename function_traits<Function_T>::class_type, std::nullptr_t>>>
+  {
+    using Return_T = typename function_traits<Function_T>::return_type;
+    using Class_T = typename function_traits<Function_T>::template nth_arg<0>;
+    using Arg_Ts = typename tuple_shift<typename function_traits<Function_T>::arg_types>::type;
+    static constexpr std::size_t arity = std::tuple_size_v<Arg_Ts>;
+  };
+
+  // Member functions that have an implied self parameter of an object instance
+  //   foo.doSomething(int a)
+  template<typename Function_T, bool IsMethod>
+  struct method_traits<Function_T, IsMethod, std::enable_if_t<IsMethod && !std::is_same_v<typename function_traits<Function_T>::class_type, std::nullptr_t>>>
+  {
+    using Return_T = typename function_traits<Function_T>::return_type;
+    using Class_T = typename function_traits<Function_T>::class_type;
+    using Arg_Ts = typename function_traits<Function_T>::arg_types;
+    static constexpr std::size_t arity = std::tuple_size_v<Arg_Ts>;
+  };
+}
+#endif // Rice__detail__method_traits__hpp_

data/rice/traits/rice_traits.hpp

@@ -0,0 +1,172 @@
+#ifndef Rice__detail__traits__hpp_
+#define Rice__detail__traits__hpp_
+
+#include <ostream>
+#include <tuple>
+#include <type_traits>
+#include <variant>
+#include <vector>
+
+namespace Rice
+{
+  namespace detail
+  {
+    // Get the base_type of T - without pointer, reference, const or volatile. We call remove_pointer_t twice 
+    // for T**
+    template<typename T>
+    using intrinsic_type = typename std::remove_cv_t<std::remove_pointer_t<std::remove_pointer_t<std::remove_reference_t<T>>>>;
+
+    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>>>>;
+
+    // Recursively remove const/volatile
+    template<typename T>
+    struct remove_cv_recursive
+    {
+      using type = T;
+    };
+
+    template<typename T>
+    struct remove_cv_recursive<T const volatile>
+    {
+      using type = typename remove_cv_recursive<T>::type;
+    };
+
+    template<typename T>
+    struct remove_cv_recursive<T volatile>
+    {
+      using type = typename remove_cv_recursive<T>::type;
+    };
+
+    template<typename T>
+    struct remove_cv_recursive<T const>
+    {
+      using type = typename remove_cv_recursive<T>::type;
+    };
+
+    template<typename T>
+    struct remove_cv_recursive<T&>
+    {
+      using type = typename remove_cv_recursive<T>::type&;
+    };
+
+   /* template<typename T>
+    struct remove_cv_recursive<T&&>
+    {
+      using type = typename remove_cv_recursive<T>::type&&;
+    };*/
+
+    template<typename T>
+    struct remove_cv_recursive<T*>
+    {
+      using type = typename remove_cv_recursive<T>::type*;
+    };
+
+    template<typename T>
+    using remove_cv_recursive_t = typename remove_cv_recursive<T>::type;
+
+    // Does the Type work with ostreams? This is used to implement #to_s
+    template<typename T, typename = void>
+    struct is_ostreamable : std::false_type {};
+
+    template<typename T>
+    struct is_ostreamable<T, std::void_t<decltype(std::declval<std::ostream&>() << std::declval<const T>())>> : std::true_type {};
+
+    template<typename T>
+    constexpr bool is_ostreamable_v = is_ostreamable<T>::value;
+
+    // Is the type comparable?
+    template<typename T, typename SFINAE = void>
+    struct is_comparable : std::false_type {};
+
+    template<typename T>
+    struct is_comparable<T, std::void_t<
+      // Does the class implement operator== and does it return a boolean value?
+      decltype(std::declval<T>() == std::declval<T>() && true)
+      >> : std::true_type {};
+
+    template<typename T>
+    constexpr bool is_comparable_v = is_comparable<T>::value;
+
+    template <typename U, typename V>
+    struct is_comparable<std::pair<U, V>>
+    {
+      static const bool value = is_comparable_v<U> && is_comparable_v<V>;
+    };
+
+    template <typename T>
+    struct is_comparable<std::vector<T>>
+    {
+      static const bool value = is_comparable_v<T>;
+    };
+
+    // -- 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<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<remove_cv_recursive_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 {};
+
+    template<class T>
+    struct is_pointer_pointer<T**> : std::true_type {};
+
+    template<class T>
+    struct is_pointer_pointer<T** const> : std::true_type {};
+
+    template<class T>
+    struct is_pointer_pointer<T* const * const> : std::true_type {};
+
+    template<class T>
+    struct is_pointer_pointer<const T* const* const> : std::true_type {};
+
+    template<class T>
+    constexpr bool is_pointer_pointer_v = is_pointer_pointer<T>::value;
+
+    // See https://www.cppstories.com/2022/tuple-iteration-apply/
+    template <typename Tuple_T, typename Function_T>
+    void for_each_tuple(Tuple_T&& tuple, Function_T&& callable)
+    {
+      std::apply([&callable](auto&& ...args)
+        {
+          (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
+
+#endif // Rice__detail__traits__hpp_

data/rice.gemspec

@@ -0,0 +1,85 @@
+$:.unshift File.expand_path(File.dirname(__FILE__))
+require 'lib/rice/version'
+
+$spec = Gem::Specification.new do |s|
+  s.name = 'rice'
+  s.version = Rice::VERSION
+  s.license = "MIT"
+  s.summary = 'Ruby Interface for C++ Extensions'
+  s.homepage = 'https://github.com/ruby-rice/rice'
+  s.authors = ['Paul Brannan', 'Jason Roelofs', 'Charlie Savage']
+  s.email = ['curlypaul924@gmail.com', 'jasongroelofs@gmail.com', 'cfis@savagexi.com']
+
+  s.description = <<-END
+Rice is a C++ interface to Ruby's C API. It provides a type-safe and
+exception-safe interface in order to make embedding Ruby and writing
+Ruby extensions with C++ easier.
+  END
+
+  s.metadata = {
+    "bug_tracker_uri"   => "https://github.com/ruby-rice/rice/issues",
+    "changelog_uri"     => "https://github.com/ruby-rice/rice/blob/master/CHANGELOG.md",
+    "documentation_uri" => "https://ruby-rice.github.io",
+    "source_code_uri"   => "https://github.com/ruby-rice/rice",
+  }
+
+  s.test_files = Dir['test/ruby/*.rb']
+  s.extra_rdoc_files = ['README.md']
+  s.require_paths = ['lib']
+
+  s.files = Dir[
+    # Documentation
+    'CHANGELOG.md',
+    'CONTRIBUTORS.md',
+    'COPYING',
+    'README.md',
+
+    # Ruby files
+    'Gemfile',
+    'Rakefile',
+    'rice.gemspec',
+
+    # CMake Files
+    'CMakeLists.txt',
+    'CMakePresets.json',
+    'FindRuby.cmake',
+
+    # rice.hpp
+    'include/rice/rice.hpp',
+    'include/rice/stl.hpp',
+
+    # Source files
+    'rice/**/*.?pp',
+
+    # Ruby files
+    'lib/**/*.rb',
+
+    # Samples
+    'sample/enum/extconf.rb',
+    'sample/enum/*.?pp',
+    'sample/enum/*.rb',
+    'sample/map/extconf.rb',
+    'sample/map/*.?pp',
+    'sample/map/*.rb',
+    'sample/inheritance/extconf.rb',
+    'sample/inheritance/*.?pp',
+    'sample/inheritance/*.rb',
+    'sample/callbacks/extconf.rb',
+    'sample/callbacks/*.?pp',
+    'sample/callbacks/*.rb',
+
+    # Test source files
+    'test/*.?pp',
+    'test/extconf.rb',
+    'test/ext/t1/extconf.rb',
+    'test/ext/t1/*.*pp',
+    'test/ext/t2/extconf.rb',
+    'test/ext/t2/*.*pp'
+  ]
+
+  s.required_ruby_version = ">= 3.1"
+
+  s.add_development_dependency "bundler"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "minitest"
+end

data/test/embed_ruby.cpp

@@ -25,5 +25,8 @@ void embed_ruby()
 #endif
 
     initialized__ = true;
+
+    // Initialize Rice
+    Rice::init();
   }
 }

data/test/ruby/test_multiple_extensions_same_class.rb

@@ -1,14 +1,14 @@
-$: << File.join(__dir__, '..', 'ext')
-
-require 'minitest'
-require 'minitest/autorun'
-
-class MultipleExtensionsSameClassTest < Minitest::Test
-  def test_multiple_extensions_same_class
-    require 't1/t1'
-    require 't2/t2'
-
-    foo = Foo.new
-    assert_equal 42, foo.foo
-  end
-end
+$: << File.join(__dir__, '..', 'ext')
+
+require 'minitest'
+require 'minitest/autorun'
+
+class MultipleExtensionsSameClassTest < Minitest::Test
+  def test_multiple_extensions_same_class
+    require 't1/t1'
+    require 't2/t2'
+
+    foo = Foo.new
+    assert_equal 42, foo.foo
+  end
+end

data/test/test_Array.cpp

@@ -276,12 +276,15 @@ TESTCASE(assign_int)
  * Issue 59 - Copy constructor compilation problem.
  */
 
-namespace {
-  void testArrayArg(Object self, Array string) {
+namespace
+{
+  void testArrayArg(Object self, Array string)
+  {
   }
 }
 
-TESTCASE(use_array_in_wrapped_function) {
+TESTCASE(use_array_in_wrapped_function)
+{
   define_global_function("test_array_arg", &testArrayArg);
 }
 

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()
     {
@@ -53,6 +61,21 @@ namespace
   bool globalBool = true;
   const DataStruct* globalStruct = new DataStruct();
 
+  class VecStruct
+  {
+  public:
+    std::vector<double> vector;
+
+    VecStruct(std::vector<double> aVector) : vector(aVector)
+    {
+    }
+
+    size_t vecSize()
+    {
+      return this->vector.size();
+    }
+  };
+
 } // namespace
 
 TESTCASE(attributes)
@@ -102,15 +125,39 @@ TESTCASE(attributes)
   ASSERT_EQUAL("Set a string", detail::From_Ruby<std::string>().convert(result.value()));
 }
 
+TESTCASE(vector)
+{
+  // See https ://github.com/ruby-rice/rice/issues/283
+  Module m = define_module("Testing");
+
+  define_class<VecStruct>("VecStruct")
+    .define_constructor(Constructor<VecStruct, std::vector<double>>())
+    .define_attr("vector", &VecStruct::vector, Rice::AttrAccess::Read)
+    .define_method("vector_size", &VecStruct::vecSize);
+
+  std::string code = R"(struct = VecStruct.new([1, 2])
+                        # Access the attribute
+                        array =  struct.vector.to_a
+                        struct.vector_size)";
+
+  Object result = m.module_eval(code);
+  ASSERT_EQUAL(2, detail::From_Ruby<int>().convert(result));
+}
+
 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");
-  const DataStruct* dataStruct = o.get();
+  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(
@@ -121,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");
@@ -144,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")