rice 4.3.3 → 4.6.0

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,160 @@
+#ifndef Rice__detail__traits__hpp_
+#define Rice__detail__traits__hpp_
+
+#include <ostream>
+#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));
+    }
+  } // 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

@@ -7,20 +7,26 @@ void embed_ruby()
 
   if (!initialized__)
   {
+    RUBY_INIT_STACK;
+
     int argc = 0;
     char* argv = nullptr;
     char** pArgv = &argv;
 
     ruby_sysinit(&argc, &pArgv);
+
     ruby_init();
     ruby_init_loadpath();
 
-#if RUBY_API_VERSION_MAJOR == 3 && RUBY_API_VERSION_MINOR >= 3
+#if RUBY_API_VERSION_MAJOR == 3 && RUBY_API_VERSION_MINOR >= 1
     // Force the prelude / builtins
     const char* opts[] = { "ruby", "-e;" };
     ruby_options(2, (char**)opts);
 #endif
 
     initialized__ = true;
+
+    // Initialize Rice
+    Rice::init();
   }
 }

data/test/extconf.rb

@@ -2,6 +2,8 @@ require 'bundler/setup'
 require 'mkmf-rice'
 require 'rbconfig'
 
+abort "libffi not found" unless have_libffi
+
 # Totally hack mkmf to make a unittest executable instead of a shared library
 target_exe = "unittest#{RbConfig::CONFIG['EXEEXT']}"
 $cleanfiles << target_exe

data/test/test_Address_Registration_Guard.cpp

@@ -11,6 +11,11 @@ SETUP(Address_Registration_Guard)
   embed_ruby();
 }
 
+TEARDOWN(Address_Registration_Guard)
+{
+  rb_gc_start();
+}
+
 TESTCASE(register_address)
 {
   VALUE v = Qnil;

data/test/test_Array.cpp

@@ -24,13 +24,24 @@ SETUP(Array)
   embed_ruby();
 }
 
-TESTCASE(default_construct)
+TEARDOWN(Array)
+{
+  rb_gc_start();
+}
+
+TESTCASE(construct_default)
 {
   Array a;
   ASSERT_EQUAL(T_ARRAY, rb_type(a));
   ASSERT_EQUAL(0, RARRAY_LEN(a.value()));
 }
 
+TESTCASE(construct_capacity)
+{
+  Array a((long)10);
+  ASSERT_EQUAL(0, RARRAY_LEN(a.value()));
+}
+
 TESTCASE(construct_from_vector_of_int)
 {
   std::vector<int> v;
@@ -265,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);
 }