rice 4.3.2 → 4.5.0

data/test/test_global_functions.cpp

@@ -11,6 +11,11 @@ SETUP(GlobalFunction)
   embed_ruby();
 }
 
+TEARDOWN(GlobalFunctions)
+{
+  rb_gc_start();
+}
+
 namespace {
 
   bool no_args()
@@ -18,9 +23,9 @@ namespace {
     return true;
   }
 
-  int int_arg(int arg)
+  int int_arg(int value)
   {
-    return 2 * arg;
+    return 2 * value;
   }
 }
 
@@ -52,6 +57,28 @@ TESTCASE(int_arg)
   ASSERT_EQUAL(20, detail::From_Ruby<int>().convert(result));
 }
 
+TESTCASE(int_kw_arg)
+{
+  define_global_function("method_with_kw_args_1", &int_arg, Arg("value"));
+  Module m = Module(rb_mKernel);
+  std::string code = R"(method_with_kw_args_1(value: 15))";
+  Object result = m.instance_eval(code);
+  ASSERT_EQUAL(30, detail::From_Ruby<int>().convert(result));
+}
+
+TESTCASE(int_kw_arg_invalid)
+{
+  define_global_function("method_with_kw_args_2", &int_arg, Arg("value"));
+  Module m = Module(rb_mKernel);
+  std::string code = R"(method_with_kw_args_2(wrong: 15))";
+
+  ASSERT_EXCEPTION_CHECK(
+    Exception,
+    m.instance_eval(code),
+    ASSERT_EQUAL("Unknown keyword: wrong", ex.what())
+  );
+}
+
 TESTCASE(int_arg_lambda)
 {
   define_global_function("method_with_args", [](int value)
@@ -85,7 +112,7 @@ namespace
 
 TESTCASE(default_arguments_for_define_global_function)
 {
-  define_global_function("foo", &defaults_method_one, Arg("arg1"), Arg("arg2") = (int)3, Arg("arg3") = (bool)true);
+  define_global_function("foo", &defaults_method_one, Arg("arg1"), Arg("arg2") = (int)3, Arg("arg3") = true);
   Module m(rb_mKernel);
 
   m.call("foo", 2);
@@ -107,7 +134,26 @@ TESTCASE(default_arguments_for_define_global_function)
   ASSERT(!defaults_method_one_arg3);
 }
 
-TESTCASE(default_arguments_for_define_global_function_and_returning)
+TESTCASE(default_arguments_kw)
+{
+  define_global_function("defaults_method_one_kw", &defaults_method_one, 
+    Arg("arg1"), Arg("arg2"), Arg("arg3") = true);
+  Module m = Module(rb_mKernel);
+
+  std::string code = R"(defaults_method_one_kw(4, arg2: 5))";
+  m.instance_eval(code);
+  ASSERT_EQUAL(4, defaults_method_one_arg1);
+  ASSERT_EQUAL(5, defaults_method_one_arg2);
+  ASSERT(defaults_method_one_arg3);
+
+  code = R"(defaults_method_one_kw(arg1: 9, arg2: 11, arg3: false))";
+  m.instance_eval(code);
+  ASSERT_EQUAL(9, defaults_method_one_arg1);
+  ASSERT_EQUAL(11, defaults_method_one_arg2);
+  ASSERT(!defaults_method_one_arg3);
+}
+
+TESTCASE(default_arguments_and_returning)
 {
   define_global_function("foo_ret", &defaults_returns, Arg("arg1"), Arg("arg2") = (int)3);
   Module m(rb_mKernel);
@@ -119,7 +165,8 @@ TESTCASE(default_arguments_for_define_global_function_and_returning)
   ASSERT_EQUAL(INT2NUM(50), o.value());
 }
 
-namespace {
+namespace
+{
   int the_one_default_arg = 0;
   void method_with_one_default_arg(int num = 4) {
     the_one_default_arg = num;
@@ -132,4 +179,4 @@ TESTCASE(single_default_argument)
   Module m(rb_mKernel);
   m.call("foo");
   ASSERT_EQUAL(4, the_one_default_arg);
-}
+}

data/test/unittest.cpp

@@ -3,6 +3,10 @@
 #include <map>
 #include "unittest.hpp"
 
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
 size_t assertions;
 
 namespace
@@ -98,6 +102,10 @@ char* findOption(char** begin, char** end, const std::string& option)
 
 int main(int argc, char** argv)
 {
+#ifdef _WIN32
+  SetConsoleOutputCP(CP_UTF8);
+#endif
+
   std::vector<Test_Suite> suites;
 
   char* moduleName = findOption(argv, argv + argc, "--suite");

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rice
 version: !ruby/object:Gem::Version
-  version: 4.3.2
+  version: 4.5.0
 platform: ruby
 authors:
 - Paul Brannan
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-18 00:00:00.000000000 Z
+date: 2025-02-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -76,52 +76,62 @@ files:
 - include/rice/rice.hpp
 - include/rice/stl.hpp
 - lib/mkmf-rice.rb
-- lib/version.rb
 - rice/Address_Registration_Guard.hpp
 - rice/Address_Registration_Guard.ipp
-- rice/Address_Registration_Guard_defn.hpp
 - rice/Arg.hpp
 - rice/Arg.ipp
+- rice/Callback.hpp
+- rice/Callback.ipp
 - rice/Constructor.hpp
+- rice/Constructor.ipp
 - rice/Data_Object.hpp
 - rice/Data_Object.ipp
-- rice/Data_Object_defn.hpp
 - rice/Data_Type.hpp
 - rice/Data_Type.ipp
-- rice/Data_Type_defn.hpp
 - rice/Director.hpp
 - rice/Enum.hpp
 - rice/Enum.ipp
 - rice/Exception.hpp
 - rice/Exception.ipp
-- rice/Exception_defn.hpp
-- rice/HandlerRegistration.hpp
-- rice/Identifier.hpp
-- rice/Identifier.ipp
+- rice/JumpException.hpp
+- rice/JumpException.ipp
+- rice/MemoryView.hpp
+- rice/MemoryView.ipp
 - rice/Return.hpp
 - rice/Return.ipp
-- rice/detail/ExceptionHandler.hpp
-- rice/detail/ExceptionHandler.ipp
-- rice/detail/ExceptionHandler_defn.hpp
+- rice/detail/DefaultHandler.hpp
+- rice/detail/DefaultHandler.ipp
 - 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
-- rice/detail/NativeAttribute.hpp
-- rice/detail/NativeAttribute.ipp
+- rice/detail/Native.hpp
+- rice/detail/Native.ipp
+- rice/detail/NativeAttributeGet.hpp
+- rice/detail/NativeAttributeGet.ipp
+- rice/detail/NativeAttributeSet.hpp
+- rice/detail/NativeAttributeSet.ipp
+- rice/detail/NativeCallbackFFI.hpp
+- rice/detail/NativeCallbackFFI.ipp
+- rice/detail/NativeCallbackSimple.hpp
+- rice/detail/NativeCallbackSimple.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/Proc.hpp
+- rice/detail/Proc.ipp
 - rice/detail/Registries.hpp
 - rice/detail/Registries.ipp
 - rice/detail/RubyFunction.hpp
 - rice/detail/RubyFunction.ipp
+- rice/detail/RubyType.hpp
+- rice/detail/RubyType.ipp
+- rice/detail/TupleIterator.hpp
 - rice/detail/Type.hpp
 - rice/detail/Type.ipp
 - rice/detail/TypeRegistry.hpp
@@ -133,11 +143,9 @@ files:
 - rice/detail/default_allocation_func.ipp
 - rice/detail/from_ruby.hpp
 - rice/detail/from_ruby.ipp
-- rice/detail/from_ruby_defn.hpp
 - rice/detail/ruby.hpp
 - rice/detail/to_ruby.hpp
 - rice/detail/to_ruby.ipp
-- rice/detail/to_ruby_defn.hpp
 - rice/forward_declares.ipp
 - rice/global_function.hpp
 - rice/global_function.ipp
@@ -172,6 +180,7 @@ files:
 - test/test_Array.cpp
 - test/test_Attribute.cpp
 - test/test_Builtin_Object.cpp
+- test/test_Callback.cpp
 - test/test_Class.cpp
 - test/test_Constructor.cpp
 - test/test_Data_Object.cpp
@@ -179,19 +188,24 @@ files:
 - test/test_Director.cpp
 - test/test_Enum.cpp
 - test/test_Exception.cpp
+- test/test_File.cpp
+- test/test_From_Ruby.cpp
 - test/test_Hash.cpp
 - test/test_Identifier.cpp
 - test/test_Inheritance.cpp
 - test/test_Iterator.cpp
-- test/test_Jump_Tag.cpp
+- test/test_JumpException.cpp
 - test/test_Keep_Alive.cpp
 - test/test_Keep_Alive_No_Wrapper.cpp
 - test/test_Memory_Management.cpp
 - test/test_Module.cpp
 - test/test_Native_Registry.cpp
 - test/test_Object.cpp
+- test/test_Overloads.cpp
 - test/test_Ownership.cpp
+- test/test_Proc.cpp
 - test/test_Self.cpp
+- test/test_Stl_Exception.cpp
 - test/test_Stl_Map.cpp
 - test/test_Stl_Optional.cpp
 - test/test_Stl_Pair.cpp
@@ -199,14 +213,17 @@ files:
 - test/test_Stl_SmartPointer.cpp
 - test/test_Stl_String.cpp
 - test/test_Stl_String_View.cpp
+- test/test_Stl_Type.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_Template.cpp
+- test/test_To_Ruby.cpp
 - test/test_Tracking.cpp
+- test/test_Type.cpp
 - test/test_global_functions.cpp
 - test/unittest.cpp
 - test/unittest.hpp

data/lib/version.rb

@@ -1,3 +0,0 @@
-module Rice
-  VERSION = "4.3.2"
-end

data/rice/Address_Registration_Guard_defn.hpp

@@ -1,79 +0,0 @@
-#ifndef Rice__Address_Registration_Guard_defn__hpp_
-#define Rice__Address_Registration_Guard_defn__hpp_
-
-#include "cpp_api/Object_defn.hpp"
-#include "detail/ruby.hpp"
-
-namespace Rice
-{
-  //! A guard to register a given address with the GC.
-  /*! Calls rb_gc_register_address upon construction and
-   *  rb_gc_unregister_address upon destruction.
-   *  For example:
-   *  \code
-   *    Class Foo
-   *    {
-   *    public:
-   *      Foo()
-   *        : string_(rb_str_new2())
-   *        , guard_(&string_);
-   *
-   *    private:
-   *      VALUE string_;
-   *      Address_Registration_Guard guard_;
-   *    };
-   *  \endcode
-   */
-  class Address_Registration_Guard
-  {
-  public:
-    //! Register an address with the GC.
-    /*  \param address The address to register with the GC.  The address
-     *  must point to a valid ruby object (RObject).
-     */
-    Address_Registration_Guard(VALUE* address);
-
-    //! Register an Object with the GC.
-    /*! \param object The Object to register with the GC.  The object must
-     *  not be destroyed before the Address_Registration_Guard is
-     *  destroyed.
-     */
-    Address_Registration_Guard(Object* object);
-
-    //! Unregister an address/Object with the GC.
-    /*! Destruct an Address_Registration_Guard.  The address registered
-     *  with the Address_Registration_Guard when it was constructed will
-     *  be unregistered from the GC.
-     */
-    ~Address_Registration_Guard();
-
-    // Disable copying
-    Address_Registration_Guard(Address_Registration_Guard const& other) = delete;
-    Address_Registration_Guard& operator=(Address_Registration_Guard const& other) = delete;
-
-    // Enable moving
-    Address_Registration_Guard(Address_Registration_Guard&& other);
-    Address_Registration_Guard& operator=(Address_Registration_Guard&& other);
-
-    //! Get the address that is registered with the GC.
-    VALUE* address() const;
-
-    /** Called during Ruby's exit process since we should not call
-     * rb_gc unregister_address there
-     */
-    static void disable();
-
-  private:
-    inline static bool enabled = true;
-    inline static bool exit_handler_registered = false;
-    static void registerExitHandler();
-
-  private:
-    void registerAddress() const;
-    void unregisterAddress();
-
-    VALUE* address_ = nullptr;
-  };
-} // namespace Rice
-
-#endif // Rice__Address_Registration_Guard_defn__hpp_

data/rice/Data_Object_defn.hpp

@@ -1,84 +0,0 @@
-#ifndef Rice__Data_Object_defn__hpp_
-#define Rice__Data_Object_defn__hpp_
-
-#include <optional>
-
-#include "detail/to_ruby.hpp"
-#include "detail/ruby.hpp"
-#include "cpp_api/Object_defn.hpp"
-
-/*! \file
- *  \brief Provides a helper class for wrapping and unwrapping C++
- *  objects as Ruby objects.
- */
-
-namespace Rice
-{
-  //! A smartpointer-like wrapper for Ruby data objects.
-  /*! A data object is a ruby object of type T_DATA, which is usually
-   *  created by using the Data_Wrap_Struct or Data_Make_Struct macro.
-   *  This class wraps creation of the data structure, providing a
-   *  type-safe object-oriented interface to the underlying C interface.
-   *  This class works in conjunction with the Data_Type class to ensure
-   *  type safety.
-   *
-   *  Example:
-   *  \code
-   *    class Foo { };
-   *    ...
-   *    Data_Type<Foo> rb_cFoo = define_class("Foo");
-   *    ...
-   *    // Wrap:
-   *    Data_Object<Foo> foo1(new Foo);
-   *
-   *    // Get value to return:
-   *    VALUE v = foo1.value()
-   *
-   *    // Unwrap:
-   *    Data_Object<Foo> foo2(v, rb_cFoo);
-   *  \endcode
-   */
-  template<typename T>
-  class Data_Object : public Object
-  {
-    static_assert(!std::is_pointer_v<T>);
-    static_assert(!std::is_reference_v<T>);
-    static_assert(!std::is_const_v<T>);
-    static_assert(!std::is_volatile_v<T>);
-
-  public:
-    static T* from_ruby(VALUE value);
-
-  public:
-    //! Wrap a C++ object.
-    /*! This constructor is analogous to calling Data_Wrap_Struct.  Be
-     *  careful not to call this function more than once for the same
-     *  pointer (in general, it should only be called for newly
-     *  constructed objects that need to be managed by Ruby's garbage
-     *  collector).
-     *  \param obj the object to wrap.
-     *  \param isOwner Should the Data_Object take ownership of the object?
-     *  \param klass the Ruby class to use for the newly created Ruby
-     *  object.
-     */
-    Data_Object(T* obj, bool isOwner = false, Class klass = Data_Type<T>::klass());
-    Data_Object(T& obj, bool isOwner = false, Class klass = Data_Type<T>::klass());
-
-    //! Unwrap a Ruby object.
-    /*! This constructor is analogous to calling Data_Get_Struct.  Uses
-     *  Data_Type<T>::klass as the class of the object.
-     *  \param value the Ruby object to unwrap.
-     */
-    Data_Object(Object value);
-
-    T& operator*() const; //!< Return a reference to obj_
-    T* operator->() const; //!< Return a pointer to obj_
-    T* get() const;        //!< Return a pointer to obj_
-
-  private:
-    static void check_ruby_type(VALUE value);
-  };
-} // namespace Rice
-
-#endif // Rice__Data_Object_defn__hpp_
-

data/rice/Data_Type_defn.hpp

@@ -1,190 +0,0 @@
-#ifndef Rice__Data_Type_defn__hpp_
-#define Rice__Data_Type_defn__hpp_
-
-#include "cpp_api/Class_defn.hpp"
-#include "detail/ruby.hpp"
-#include <set>
-
-namespace Rice
-{
-  //! A mechanism for binding ruby types to C++ types.
-  /*! This class binds run-time types (Ruby VALUEs) to compile-time types
-   *  (C++ types).  The binding can occur only once.
-   */
-  template<typename T>
-  class Data_Type : public Class
-  {
-    static_assert(std::is_same_v<detail::intrinsic_type<T>, T>);
-
-  public:
-    //! Default constructor which does not bind.
-    /*! No member functions must be called on this Data_Type except bind,
-     *  until the type is bound.
-     */
-    Data_Type();
-
-    //! Constructor which takes a Module.
-    /*! Binds the type to the given VALUE according to the rules given
-     *  above.
-     *  \param klass the module to which to bind.
-     */
-    Data_Type(Module const & v);
-
-    //! Destructor.
-    virtual ~Data_Type();
- 
-    //! Return the Ruby class.
-    /*! \return the ruby class to which the type is bound.
-     */
-    static Class klass();
-
-    //! Return the Ruby data type.
-    static rb_data_type_t* ruby_data_type();
-
-    //! Assignment operator which takes a Module
-    /*! \param klass must be the class to which this data type is already
-     *  bound.
-     *  \return *this
-     */
-    virtual Data_Type & operator=(Module const & klass);
-
-    /*! Creates a singleton method allocate and an instance method called
-     *  initialize which together create a new instance of the class.  The
-     *  allocate method allocates memory for the object reference and the
-     *  initialize method constructs the object.
-     *  \param constructor an object that has a static member function
-     *  construct() that constructs a new instance of T and sets the object's data
-     *  member to point to the new instance.  A helper class Constructor
-     *  is provided that does precisely this.
-     *  \param args a list of Arg instance used to define default parameters (optional)
-     *
-     *  For example:
-     *  \code
-     *    define_class<Foo>("Foo")
-     *      .define_constructor(Constructor<Foo>());
-     *  \endcode
-     */
-    template<typename Constructor_T, typename...Arg_Ts>
-    Data_Type<T> & define_constructor(Constructor_T constructor, Arg_Ts const& ...args);
-
-    //! Register a Director class for this class.
-    /*! For any class that uses Rice::Director to enable polymorphism
-     *  across the languages, you need to register that director proxy
-     *  class with this method. Not doing so will cause the resulting 
-     *  library to die at run time when it tries to convert the base
-     *  type into the Director proxy type.
-     *
-     *  This method takes no methodInfo, just needs the type of the
-     *  Director proxy class.
-     *
-     *  For example:
-     *  \code
-     *    class FooDirector : public Foo, public Rice::Director {
-     *      ...
-     *    };
-     *
-     *    define_class<Foo>("Foo")
-     *      .define_director<FooDirector>()
-     *      .define_constructor(Constructor<FooDirector, Rice::Object>());
-     *  \endcode
-     */
-    template<typename Director_T>
-    Data_Type<T>& define_director();
-
-    //! Determine if the type is bound.
-    /*! \return true if the object is bound, false otherwise.
-     */
-    static bool is_bound();
-    static void check_is_bound();
-
-    // This is only for testing - DO NOT USE!!!
-    static void unbind();
-
-    static bool is_descendant(VALUE value);
-  
-    //! Define an iterator.
-    /*! Essentially this is a conversion from a C++-style begin/end
-     *  iterator to a Ruby-style \#each iterator.
-     *  \param begin a member function pointer to a function that returns
-     *  an iterator to the beginning of the sequence.
-     *  \param end a member function pointer to a function that returns an
-     *  iterator to the end of the sequence.
-     *  \param name the name of the iterator.
-     *  \return *this
-     */
-
-    template<typename Iterator_Func_T>
-    Data_Type<T>& define_iterator(Iterator_Func_T begin, Iterator_Func_T end, std::string name = "each");
-
-    template <typename Attribute_T>
-    Data_Type<T>& define_attr(std::string name, Attribute_T attribute, AttrAccess access = AttrAccess::ReadWrite);
-  
-    template <typename Attribute_T>
-    Data_Type<T>& define_singleton_attr(std::string name, Attribute_T attribute, AttrAccess access = AttrAccess::ReadWrite);
-
-  #include "cpp_api/shared_methods.hpp"
-
-  protected:
-    //! Bind a Data_Type to a VALUE.
-    /*! Throws an exception if the Data_Type is already bound to a
-     *  different class.  Any existing instances of the Data_Type will be
-     *  bound after this function returns.
-     *  \param klass the ruby type to which to bind.
-     *  \return *this
-     */
-    template <typename Base_T = void>
-    static Data_Type bind(const Module& klass);
-
-    template<typename T_, typename Base_T_>
-    friend Rice::Data_Type<T_> define_class_under(Object module, char const * name);
-
-    template<typename T_, typename Base_T_>
-    friend Rice::Data_Type<T_> define_class(char const * name);
-
-    template<bool IsMethod, typename Function_T>
-    void wrap_native_call(VALUE klass, std::string name, Function_T&& function, MethodInfo* methodInfo);
-
-  private:
-    template<typename T_>
-    friend class Data_Type;
-
-    static inline VALUE klass_ = Qnil;
-
-    // Typed Data support
-    static inline rb_data_type_t* rb_data_type_ = nullptr;
-
-    typedef std::set<Data_Type<T> *> Instances;
-
-    static Instances & unbound_instances()
-    {
-      static Instances unbound_instances;
-      return unbound_instances;
-    }
-  };
-
-  //! Define a new data class in the namespace given by module.
-  /*! By default the class will inherit from Ruby's rb_cObject. This
-   *  can be overriden via the Base_T template parameter. Note that
-   *  Base_T must already have been registered.
-   *  \param T the C++ type of the wrapped class.
-   *  \param module the the Module in which to define the class.
-   *  \return the new class.
-   */
-  template<typename T, typename Base_T = void>
-  Data_Type<T> define_class_under(Object module, char const* name);
-
-  //! Define a new data class in the default namespace.
-  /*! By default the class will inherit from Ruby's rb_cObject. This
-   *  can be overriden via the Base_T template parameter. Note that
-   *  Base_T must already have been registered.
-   *  \param T the C++ type of the wrapped class.
-   *  \param module the the Module in which to define the class.
-   *  \return the new class.
-   */
-  template<typename T, typename Base_T = void>
-  Data_Type<T> define_class(char const* name);
-} // namespace Rice
-
-#include "Data_Type.ipp"
-
-#endif // Rice__Data_Type_defn__hpp_