rice 4.0.3 → 4.1.0

data/test/test_Tracking.cpp

@@ -0,0 +1,239 @@
+#include "unittest.hpp"
+#include "embed_ruby.hpp"
+
+#include <rice/rice.hpp>
+
+using namespace Rice;
+
+TESTSUITE(Tracking);
+
+namespace
+{
+  class MyClass
+  {
+  };
+
+  class Factory
+  {
+  public:
+    static void reset()
+    {
+      delete Factory::instance_;
+      Factory::instance_ = nullptr;
+    }
+
+  public:
+    Factory* factory()
+    {
+      return this;
+    }
+
+    MyClass* transferPointer()
+    {
+      return new MyClass();
+    }
+
+    MyClass* keepPointer()
+    {
+      return this->instance();
+    }
+
+    MyClass& keepReference()
+    {
+      return *this->instance();
+    }
+
+    MyClass value()
+    {
+      return MyClass();
+    }
+
+    MyClass moveValue()
+    {
+      return std::move(MyClass());
+    }
+
+    MyClass* instance()
+    {
+      if (!instance_)
+      {
+        instance_ = new MyClass();
+      }
+      return instance_;
+    }
+
+  public:
+    static inline MyClass* instance_ = nullptr;
+  };
+}
+
+SETUP(Tracking)
+{
+  embed_ruby();
+
+  define_class<MyClass>("MyClass");
+
+  define_class<Factory>("Factory").
+    define_constructor(Constructor<Factory>()).
+    define_method("factory", &Factory::factory).
+    define_method("value", &Factory::value).
+    define_method("move_value", &Factory::moveValue).
+    define_method("transfer_pointer", &Factory::transferPointer, Return().takeOwnership()).
+    define_method("keep_pointer", &Factory::keepPointer).
+    define_method("copy_reference", &Factory::keepReference, Return().takeOwnership()).
+    define_method("keep_reference", &Factory::keepReference);
+}
+
+TEARDOWN(Tracking)
+{
+  detail::Registries::instance.instances.isEnabled = true;
+}
+
+TESTCASE(TransferPointer)
+{
+  detail::Registries::instance.instances.isEnabled = true;
+  Factory::reset();
+
+  Module m = define_module("TestingModule");
+  Object factory = m.module_eval("Factory.new");
+
+  Data_Object<MyClass> my_class1 = factory.call("transfer_pointer");
+  Data_Object<MyClass> my_class2 = factory.call("transfer_pointer");
+
+  ASSERT(!my_class1.is_equal(my_class2));
+  ASSERT_NOT_EQUAL(my_class1.get(), my_class2.get());
+}
+
+TESTCASE(KeepPointer)
+{
+  detail::Registries::instance.instances.isEnabled = true;
+  Factory::reset();
+
+  Module m = define_module("TestingModule");
+
+  Object factory = m.module_eval("Factory.new");
+
+  Data_Object<MyClass> my_class1 = factory.call("keep_pointer");
+  Data_Object<MyClass> my_class2 = factory.call("keep_pointer");
+
+  ASSERT(my_class1.is_equal(my_class2));
+  ASSERT_EQUAL(my_class1.get(), my_class2.get());
+}
+
+TESTCASE(KeepPointerWithoutTracking)
+{
+  detail::Registries::instance.instances.isEnabled = false;
+  Factory::reset();
+
+  Module m = define_module("TestingModule");
+
+  Object factory = m.module_eval("Factory.new");
+
+  Data_Object<MyClass> my_class1 = factory.call("keep_pointer");
+  Data_Object<MyClass> my_class2 = factory.call("keep_pointer");
+
+  ASSERT(!my_class1.is_equal(my_class2));
+  ASSERT_EQUAL(my_class1.get(), my_class2.get());
+}
+
+TESTCASE(KeepReference)
+{
+  detail::Registries::instance.instances.isEnabled = true;
+  Factory::reset();
+
+  Module m = define_module("TestingModule");
+
+  Object factory = m.module_eval("Factory.new");
+
+  Data_Object<MyClass> my_class1 = factory.call("keep_reference");
+  Data_Object<MyClass> my_class2 = factory.call("keep_reference");
+
+  ASSERT(my_class1.is_equal(my_class2));
+  ASSERT_EQUAL(my_class1.get(), my_class2.get());
+}
+
+TESTCASE(KeepReferenceWithoutTracking)
+{
+  detail::Registries::instance.instances.isEnabled = false;
+  Factory::reset();
+
+  Module m = define_module("TestingModule");
+
+  Object factory = m.module_eval("Factory.new");
+
+  Data_Object<MyClass> my_class1 = factory.call("keep_reference");
+  Data_Object<MyClass> my_class2 = factory.call("keep_reference");
+
+  ASSERT(!my_class1.is_equal(my_class2));
+  ASSERT_EQUAL(my_class1.get(), my_class2.get());
+}
+
+TESTCASE(CopyReference)
+{
+  detail::Registries::instance.instances.isEnabled = true;
+  Factory::reset();
+
+  Module m = define_module("TestingModule");
+  Object factory = m.module_eval("Factory.new");
+
+  Data_Object<MyClass> my_class1 = factory.call("copy_reference");
+  Data_Object<MyClass> my_class2 = factory.call("copy_reference");
+
+  ASSERT(!my_class1.is_equal(my_class2));
+  ASSERT_NOT_EQUAL(my_class1.get(), my_class2.get());
+}
+
+TESTCASE(TransferValue)
+{
+  detail::Registries::instance.instances.isEnabled = true;
+  Factory::reset();
+
+  Module m = define_module("TestingModule");
+  Object factory = m.module_eval("Factory.new");
+
+  Data_Object<MyClass> my_class1 = factory.call("value");
+  Data_Object<MyClass> my_class2 = factory.call("value");
+
+  ASSERT(!my_class1.is_equal(my_class2));
+  ASSERT_NOT_EQUAL(my_class1.get(), my_class2.get());
+}
+
+TESTCASE(MoveValue)
+{
+  detail::Registries::instance.instances.isEnabled = true;
+  Factory::reset();
+
+  Module m = define_module("TestingModule");
+  Object factory = m.module_eval("Factory.new");
+
+  Data_Object<MyClass> my_class1 = factory.call("move_value");
+  Data_Object<MyClass> my_class2 = factory.call("move_value");
+
+  ASSERT(!my_class1.is_equal(my_class2));
+  ASSERT_NOT_EQUAL(my_class1.get(), my_class2.get());
+}
+
+TESTCASE(RubyObjectGced)
+{
+  detail::Registries::instance.instances.isEnabled = true;
+  Factory::reset();
+
+  Module m = define_module("TestingModule");
+  Object factory = m.module_eval("Factory.new");
+
+  {
+    // Track the C++ object returned by keepPointer
+    Data_Object<MyClass> my_class1 = factory.call("keep_pointer");
+    rb_gc_start();
+  }
+
+  // Make my_class1 invalid
+  rb_gc_start();
+
+  // Get the object again - this should *not* return the previous value
+  Data_Object<MyClass> my_class2 = factory.call("keep_pointer");
+
+  // Call a method on the ruby object
+  String className = my_class2.class_name();
+  ASSERT_EQUAL(std::string("MyClass"), className.str());
+}

data/test/unittest.hpp

@@ -214,6 +214,12 @@ inline bool is_not_equal(T const & t, U const & u)
 
 extern size_t assertions;
 
+template<typename S, typename T, typename = void>
+struct is_streamable: std::false_type {};
+
+template<typename S, typename T>
+struct is_streamable<S, T, std::void_t<decltype(std::declval<S&>()<<std::declval<T>())>>: std::true_type {};
+
 template<typename T, typename U>
 void assert_equal(
     T const & t,
@@ -226,10 +232,13 @@ void assert_equal(
   if(!is_equal(t, u))
   {
     std::stringstream strm;
-    strm << "Assertion failed: "
-      << s_t << " != " << s_u
-      << " (" << t << " != " << u << ")"
-      << " at " << file << ":" << line;
+    strm << "Assertion failed: ";
+
+    if constexpr (is_streamable<std::stringstream, T>::value && is_streamable<std::stringstream, U>::value)
+    {
+      strm << s_t << " != " << s_u;
+    }
+    strm << " at " << file << ":" << line;
     throw Assertion_Failed(strm.str());
   }
 }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rice
 version: !ruby/object:Gem::Version
-  version: 4.0.3
+  version: 4.1.0
 platform: ruby
 authors:
 - Paul Brannan
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-15 00:00:00.000000000 Z
+date: 2023-04-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -95,15 +95,18 @@ files:
 - rice/Exception.hpp
 - rice/Exception.ipp
 - rice/Exception_defn.hpp
+- rice/HandlerRegistration.hpp
 - rice/Identifier.hpp
 - rice/Identifier.ipp
 - rice/Return.hpp
 - rice/Return.ipp
-- rice/detail/Exception_Handler.hpp
-- rice/detail/Exception_Handler.ipp
-- rice/detail/Exception_Handler_defn.hpp
-- rice/detail/Iterator.hpp
-- rice/detail/Iterator.ipp
+- rice/detail/ExceptionHandler.hpp
+- rice/detail/ExceptionHandler.ipp
+- rice/detail/ExceptionHandler_defn.hpp
+- rice/detail/HandlerRegistry.hpp
+- rice/detail/HandlerRegistry.ipp
+- rice/detail/InstanceRegistry.hpp
+- rice/detail/InstanceRegistry.ipp
 - rice/detail/Jump_Tag.hpp
 - rice/detail/MethodInfo.hpp
 - rice/detail/MethodInfo.ipp
@@ -111,6 +114,12 @@ files:
 - rice/detail/NativeAttribute.ipp
 - rice/detail/NativeFunction.hpp
 - rice/detail/NativeFunction.ipp
+- rice/detail/NativeIterator.hpp
+- rice/detail/NativeIterator.ipp
+- rice/detail/NativeRegistry.hpp
+- rice/detail/NativeRegistry.ipp
+- rice/detail/Registries.hpp
+- rice/detail/Registries.ipp
 - rice/detail/RubyFunction.hpp
 - rice/detail/RubyFunction.ipp
 - rice/detail/Type.hpp
@@ -119,15 +128,12 @@ files:
 - rice/detail/TypeRegistry.ipp
 - rice/detail/Wrapper.hpp
 - rice/detail/Wrapper.ipp
+- rice/detail/cpp_protect.hpp
 - rice/detail/default_allocation_func.hpp
 - rice/detail/default_allocation_func.ipp
 - rice/detail/from_ruby.hpp
 - rice/detail/from_ruby.ipp
 - rice/detail/from_ruby_defn.hpp
-- rice/detail/function_traits.hpp
-- rice/detail/method_data.hpp
-- rice/detail/method_data.ipp
-- rice/detail/rice_traits.hpp
 - rice/detail/ruby.hpp
 - rice/detail/to_ruby.hpp
 - rice/detail/to_ruby.ipp
@@ -137,7 +143,6 @@ files:
 - rice/global_function.ipp
 - rice/rice.hpp
 - rice/ruby_mark.hpp
-- rice/ruby_try_catch.hpp
 - rice/stl.hpp
 - sample/callbacks/extconf.rb
 - sample/callbacks/sample_callbacks.cpp
@@ -185,15 +190,20 @@ files:
 - test/test_Object.cpp
 - test/test_Ownership.cpp
 - test/test_Self.cpp
+- test/test_Stl_Map.cpp
 - test/test_Stl_Optional.cpp
 - test/test_Stl_Pair.cpp
+- test/test_Stl_Reference_Wrapper.cpp
 - test/test_Stl_SmartPointer.cpp
 - test/test_Stl_String.cpp
+- test/test_Stl_Unordered_Map.cpp
+- test/test_Stl_Variant.cpp
 - test/test_Stl_Vector.cpp
 - test/test_String.cpp
 - test/test_Struct.cpp
 - test/test_Symbol.cpp
 - test/test_To_From_Ruby.cpp
+- test/test_Tracking.cpp
 - test/test_global_functions.cpp
 - test/unittest.cpp
 - test/unittest.hpp
@@ -220,7 +230,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.32
+rubygems_version: 3.4.12
 signing_key:
 specification_version: 4
 summary: Ruby Interface for C++ Extensions

data/rice/detail/Exception_Handler.hpp

@@ -1,8 +0,0 @@
-#ifndef Rice__detail__Exception_Handler__hpp_
-#define Rice__detail__Exception_Handler__hpp_
-
-#include "Exception_Handler_defn.hpp"
-#include "Exception_Handler.ipp"
-
-#endif // Rice__detail__Exception_Handler__hpp_
-

data/rice/detail/Exception_Handler.ipp

@@ -1,28 +0,0 @@
-namespace Rice::detail
-{
-  inline VALUE Rice::detail::Default_Exception_Handler::handle_exception() const
-  {
-    throw;
-  }
-
-  template <typename Exception_T, typename Functor_T>
-  inline Rice::detail::Functor_Exception_Handler<Exception_T, Functor_T>::
-    Functor_Exception_Handler(Functor_T handler, std::shared_ptr<Exception_Handler> next_exception_handler)
-    : handler_(handler), next_exception_handler_(next_exception_handler)
-  {
-  }
-
-  template <typename Exception_T, typename Functor_T>
-  inline VALUE Rice::detail::Functor_Exception_Handler<Exception_T, Functor_T>::handle_exception() const
-  {
-    try
-    {
-      return this->next_exception_handler_->handle_exception();
-    }
-    catch (Exception_T const& ex)
-    {
-      handler_(ex);
-      throw;
-    }
-  }
-}

data/rice/detail/Iterator.hpp

@@ -1,23 +0,0 @@
-#ifndef Rice_Iterator__hpp_
-#define Rice_Iterator__hpp_
-
-namespace Rice::detail
-{
-  template<typename T, typename Iterator_T>
-  class Iterator
-  {
-  public:
-    static VALUE call(VALUE self);
-
-  public:
-    Iterator(Iterator_T(T::* begin)(), Iterator_T(T::* end)());
-    virtual ~Iterator() = default;
-    VALUE operator()(VALUE self);
-
-  private:
-    Iterator_T(T::* begin_)();
-    Iterator_T(T::* end_)();
-  };
-}
-
-#endif // Rice_Iterator__hpp_

data/rice/detail/Iterator.ipp

@@ -1,47 +0,0 @@
-#ifndef Rice_Iterator__ipp_
-#define Rice_Iterator__ipp_
-
-#include <iterator>
-#include <functional>
-
-#include "../Data_Object_defn.hpp"
-#include "method_data.hpp"
-
-namespace Rice::detail
-{
-  template <typename T, typename Iterator_T>
-  inline Iterator<T, Iterator_T>::
-    Iterator(Iterator_T(T::* begin)(), Iterator_T(T::* end)()) :
-    begin_(begin), end_(end)
-  {
-  }
-
-  template<typename T, typename Iterator_T>
-  inline VALUE Iterator<T, Iterator_T>::
-  call(VALUE self)
-  {
-    using Iter_T = Iterator<T, Iterator_T>;
-    Iter_T* iterator = detail::MethodData::data<Iter_T*>();
-    return iterator->operator()(self);
-  }
-
-  template<typename T, typename Iterator_T>
-  inline VALUE Iterator<T, Iterator_T>::
-  operator()(VALUE self)
-  {
-    using Value_T = typename std::iterator_traits<Iterator_T>::value_type;
-
-    Data_Object<T> obj(self);
-    Iterator_T it = std::invoke(this->begin_, *obj);
-    Iterator_T end = std::invoke(this->end_, *obj);
-
-    for (; it != end; ++it)
-    {
-      protect(rb_yield, detail::To_Ruby<Value_T>().convert(*it));
-    }
-
-    return self;
-  }
-}
-
-#endif // Rice_Iterator__ipp_

data/rice/detail/function_traits.hpp

@@ -1,124 +0,0 @@
-#ifndef Rice__detail__function_traits__hpp_
-#define Rice__detail__function_traits__hpp_
-
-#include <tuple>
-
-namespace Rice::detail
-{
-  // --------------   Function Traits --------------
-  // Base class
-  template<typename Function_T>
-  struct function_traits;
-
-  // Base definition that support functors and lambdas
-  template<class Function_T>
-  struct function_traits
-  {
-  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;
-
-    template<std::size_t N>
-    using nth_arg = typename std::tuple_element<N, typename functor_t::arg_types>::type;
-
-    using return_type = typename functor_t::return_type;
-    using class_type = std::nullptr_t;
-  };
-
-  // Specialization for functions, member functions and static member functions
-  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;
-  };
-
-  // Free functions and static member functions passed by pointer or 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...)>
-  {
-  };
-  
-  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
-  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...)>
-  {
-  };
-
-  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...)>
-  {
-  };
-
-  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...)>
-  {
-  };
-
-  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>
-  {
-  };
-
-  // --------------   Method Traits --------------
-  // Declare struct
-  template<typename Function_T, bool IsMethod, typename = void>
-  struct method_traits;
-
-  // Functions that do not have a self parameter
-  template<typename Function_T, bool IsMethod>
-  struct method_traits<Function_T, IsMethod, std::enable_if_t<!IsMethod>>
-  {
-    using Self_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 do have a self parameter (thus we call them methods)
-  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 Self_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
-  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 Self_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__function_traits__hpp_

data/rice/detail/method_data.hpp

@@ -1,29 +0,0 @@
-#ifndef Rice__detail__method_data__hpp
-#define Rice__detail__method_data__hpp
-
-#include <unordered_map>
-#include <any>
-
-#include "ruby.hpp"
-
-namespace Rice::detail
-{
-  class MethodData
-  {
-  public:
-    // Defines a new Ruby method and stores the Rice metadata about it
-    template<typename Function_T>
-    static void define_method(VALUE klass, ID id, Function_T func, int arity, std::any data);
-
-    // Returns the Rice data for the currently active Ruby method
-    template <typename Return_T>
-    static Return_T data();
-
-  private:
-    static size_t key(VALUE klass, ID id);
-    inline static std::unordered_map<size_t, std::any> methodWrappers_ = {};
-  };
-} 
-#include "method_data.ipp"
-
-#endif // Rice__detail__method_data__hpp