Merge pull request #309 from ruby-rice/dev

Dev

Author: cfis

CHANGELOG.md

@@ -1,13 +1,13 @@
-## 4.6.2 (2025-07-29)
+## 4.6.2 (2025-07-31)
 Updates:
 * Refactor Native wrappers - functions, methods, attributes and procs - to enable introspection API
-* Add a new Ruby Introspection API that exposes Rice internals to Ruby
-* Using the new API, add support for generating RBS files
+* Add a new Introspection API that exposes Rice internals to Ruby
+* Using the new API, add support for generating RBS files from extensions
 * Don't create attribute writers for const attributes
 * Support attribute setters for Enums
 * Support wrapping std::vector<std::unique_ptr<T>>
-* Update Array#push to not always copy C++ values. This lays the foundation for extracting references and pointers and from tuples, variants and optionals.
-* Add most basic support for creating std::filesystem::path instances
+* Update Array#push to not always copy C++ instances. This lays the foundation for extracting references and pointers and from tuples, variants and optionals.
+* Add very basic support for creating std::filesystem::path instances
 * Remove toy samples and test libraries. These are replaced by a new gem that wraps the BitMapPlusPlus library (https://github.com/baderouaich/BitmapPlusPlus)
 * Add support for std::runtime_error since some libraries use that as a base exception class (thus when Rice wraps custom exceptions it also needs to wrap the base class)
 

Rakefile

@@ -84,7 +84,7 @@ FileUtils.mkdir_p(include_dir) #unless File.exists?('include')
 desc "Update rice header files"
 task :headers do
   FileUtils.rm_rf(File.join(include_dir, "rice", "*"))
-  path = File.join(__dir__, 'lib', 'make_rice_headers.rb')
+  path = File.join(__dir__, 'lib', 'rice', 'make_rice_headers.rb')
   # Execute make_rice_headers.rb
   run_command(Gem.ruby, path)
 end

bin/rice_rbs.rb renamed to bin/rice-rbs.rb

@@ -69,22 +69,22 @@ Next, we need to write C++ code that converts the ``std::deque<int>`` to a Ruby
     class To_Ruby<std::deque<int>>
     {
     public:
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
       VALUE convert(const std::deque<int>& deque)
       {
-        // Notice we wrap Ruby API calls with protect in case Ruby throws an exception.
-        // If you do not  use protect and Ruby throws an exception then your program 
-        // *will* crash.
-        VALUE result = protect(rb_ary_new2, deque.size());
+        Array result;
 
         for (int element : deque)
         {
-          // Convert the C++ int to a Ruby integer
-          VALUE value = To_Ruby<int>::convert(element, takeOwnership);
-          // Now add it to the Ruby array
-          detail::protect(rb_ary_push, result, value));
+          result.push(element, true);
         }
         return result;
       }
+    private:
+      Arg* arg_ = nullptr;
     };
   }
 
@@ -106,6 +106,10 @@ Last, if we want to convert a Ruby array to a  ``std::deque<int>``, then we need
     class From_Ruby<std::deque<int>>
     {
     public:
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
       Convertible is_convertible(VALUE value)
       {
         switch (rb_type(value))
@@ -120,27 +124,22 @@ Last, if we want to convert a Ruby array to a  ``std::deque<int>``, then we need
 
       std::deque<int> convert(VALUE value)
       {
-        // Make sure array is really an array - if not this call will
-        // throw a Ruby exception so we need to protect it
-        detail::protect(rb_check_type, array, (int)T_ARRAY);
-
-        long size = protect(rb_array_len, value);
-        std::deque<int> result(size);
+        Array array(value);
+        std::deque<int> result(array.size());
 
         for (long i=0; i<size; i++)
         {
-          // Get the array element
-          VALUE value = protect(rb_ary_entry, value, i);
-
           // Convert the Ruby int to a C++ int
-          int element = From_Ruby<int>::convert(value);
+          int element = From_Ruby<int>::convert(array[i]);
 
           // Add it to our deque
           result[i] = element;
         }
 
         return result;
       }
+    private:
+      Arg* arg_ = nullptr;
     };
   }
 
@@ -164,8 +163,6 @@ Expanding on our example above:
       class From_Ruby<std::deque<int>>
       {
       public:
-        From_Ruby() = default;
-
         explicit From_Ruby(Arg* arg) : arg_(arg)
         {
         }

doc/bindings/type_conversions.rst

@@ -8,17 +8,17 @@ Rice exposes its internals to Ruby via an introspection API. This API is used by
 
 Enabling
 --------
-The introspection API is an opt-in feature and therefore must be enabled. To do this requires adding the ``<rice/ruby_api.hpp>`` header file to your extension and then calling ``Init_Ruby_Api``:
+The introspection API is an opt-in feature and therefore must be enabled. To do this requires adding the ``<rice/api.hpp>`` header file to your extension and then calling ``Init_Rice_Api``:
 
 .. code-block:: cpp
 
-  #include <rice/ruby_api.hpp>
+  #include <rice/api.hpp>
 
   extern "C"
   void Init_My_Exgtension()
   {
     // Enable Introspection API
-    Init_Ruby_Api();
+    Init_Rice_Api();
 
     <Add Rice Binding Code>
   }

doc/introspection_api/overview.rst

@@ -8,13 +8,13 @@ Rice of course knows a lot about your extension's types! Starting with Rice 4.7,
 
 Generating RBS Files
 --------------------
-Use the ``rice_rbs`` script in the bin folder to generate RBS files for your extension.
+Use the ``rice-rbs`` script in the bin folder to generate RBS files for your extension.
 
 To run it:
 
 .. code-block:: bash
 
-  rice_rbs [options] <rice_extension_library>
+  rice-rbs [options] <rice_extension_library>
 
   Options:
     -o, --output=path                Output directory

doc/packaging/rbs.rst

@@ -1,10 +1,10 @@
-#ifndef Rice__Ruby_Api_hpp_
-#define Rice__Ruby_Api_hpp_
+#ifndef Rice__Api_hpp_
+#define Rice__Api_hpp_
 
 
 // =========   NativeRegistry.hpp   =========
-#ifndef Rice_Ruby_Api_Native_Registry_hpp
-#define Rice_Ruby_Api_Native_Registry_hpp
+#ifndef Rice_Api_Native_Registry_hpp
+#define Rice_Api_Native_Registry_hpp
 
 extern "C"
 void Init_Native_Registry();
@@ -35,8 +35,8 @@ inline void Init_Native_Registry()
 }
 
 // =========   TypeRegistry.hpp   =========
-#ifndef Rice_Ruby_Api_Type_Registry_hpp
-#define Rice_Ruby_Api_Type_Registry_hpp
+#ifndef Rice_Api_Type_Registry_hpp
+#define Rice_Api_Type_Registry_hpp
 
 extern "C"
 void Init_Type_Registry();
@@ -56,8 +56,8 @@ void Init_Type_Registry()
 }
 
 // =========   Registries.hpp   =========
-#ifndef Rice_Ruby_Api_Registries_hpp
-#define Rice_Ruby_Api_Registries_hpp
+#ifndef Rice_Api_Registries_hpp
+#define Rice_Api_Registries_hpp
 
 void Init_Registries();
 
@@ -72,14 +72,13 @@ inline void Init_Registries()
 
   define_class_under<detail::Registries>(rb_mRice, "Registries").
     define_singleton_attr("instance", &detail::Registries::instance, AttrAccess::Read).
-    define_attr("instances", &detail::Registries::instances, AttrAccess::Read).
     define_attr("natives", &detail::Registries::natives, AttrAccess::Read).
     define_attr("types", &detail::Registries::types, AttrAccess::Read);
 }
 
 // =========   Arg.hpp   =========
-#ifndef Rice_Ruby_Api_Arg_hpp
-#define Rice_Ruby_Api_Arg_hpp
+#ifndef Rice_Api_Arg_hpp
+#define Rice_Api_Arg_hpp
 
 extern "C"
 void Init_Arg();
@@ -98,8 +97,8 @@ inline void Init_Arg()
 }
 
 // =========   Parameter.hpp   =========
-#ifndef Rice_Ruby_Api_Parameter_hpp
-#define Rice_Ruby_Api_Parameter_hpp
+#ifndef Rice_Api_Parameter_hpp
+#define Rice_Api_Parameter_hpp
 
 extern "C"
 void Init_Parameter();
@@ -115,12 +114,13 @@ inline void Init_Parameter()
 
   define_class_under<detail::ParameterAbstract>(rb_mRice, "Parameter").
     define_attr("arg", &detail::ParameterAbstract::arg).
-    define_method("klass", &detail::ParameterAbstract::rubyTypeName);
+    define_method("klass", &detail::ParameterAbstract::rubyKlass, Return().setValue()).
+    define_method("cpp_klass", &detail::ParameterAbstract::cppTypeName);
 }
 
 // =========   Native.hpp   =========
-#ifndef Rice_Ruby_Api_Native_Function_hpp
-#define Rice_Ruby_Api_Native_Function_hpp
+#ifndef Rice_Api_Native_Function_hpp
+#define Rice_Api_Native_Function_hpp
 
 extern "C"
 void Init_Native();
@@ -147,7 +147,7 @@ inline void Init_Native()
   define_class_under<detail::Native>(rb_mRice, "Native").
     define_method("name", &detail::Native::name).
     define_method("kind", &detail::Native::kind).
-    define_method("return_type", &detail::Native::rubyReturnType).
+    define_method("return_klass", &detail::Native::returnKlass).
     define_method("parameters", &detail::Native::parameters).
     define_method("to_s", [](detail::Native& self) -> std::string
       {
@@ -182,7 +182,7 @@ inline void Init_Native()
 }
 
 extern "C"
-inline void Init_Ruby_Api()
+inline void Init_Rice_Api()
 {
   Init_Registries();
   Init_Native_Registry();
@@ -191,5 +191,4 @@ inline void Init_Ruby_Api()
   Init_Parameter();
   Init_Native();
 }
-
 #endif