rice 4.8.0 → 4.9.1

data/lib/rice/doc/rice.rb

@@ -1,49 +1,50 @@
 module Rice
-	module Doc
-		class Rice
-			ROOT = "https://ruby-rice.github.io/4.x"
-
-			CLASS_DOCS = {
-				/^Rice::Buffer/ => "ruby_api/buffer",
-				/^Rice::Pointer/ => "ruby_api/pointer"
-			}
-
-			def class_url(klass)
-				CLASS_DOCS.each do |pattern, path|
-					if klass.name.match?(pattern)
-						return "#{ROOT}/#{path}"
-					end
-				end
-				nil
-			end
-
-			def module_url(klass)
-				nil
-			end
-
-			def union_url(klass)
-				nil
-			end
-
-			def enum_url(klass)
-				nil
-			end
-
-			def enum_value_url(klass, enum_value)
-				nil
-			end
-
-			def singleton_method_url(klass, native)
-				nil
-			end
-
-			def method_url(klass, native)
-				class_url(klass)
-			end
-
-			def attribute_url(klass, native)
-				nil
-			end
-		end
-	end
+  module Doc
+    class Rice
+      ROOT = "https://ruby-rice.github.io/4.x"
+
+      CLASS_DOCS = {
+        /^Rice::Buffer/ => "ruby_api/buffer",
+        /^Rice::Pointer/ => "ruby_api/pointer",
+        /^Rice::Reference/ => "ruby_api/reference"
+      }
+
+      def class_url(klass)
+        CLASS_DOCS.each do |pattern, path|
+          if klass.name.match?(pattern)
+            return "#{ROOT}/#{path}"
+          end
+        end
+        nil
+      end
+
+      def module_url(klass)
+        nil
+      end
+
+      def union_url(klass)
+        nil
+      end
+
+      def enum_url(klass)
+        nil
+      end
+
+      def enum_value_url(klass, enum_value)
+        nil
+      end
+
+      def singleton_method_url(klass, native)
+        nil
+      end
+
+      def method_url(klass, native)
+        class_url(klass)
+      end
+
+      def attribute_url(klass, native)
+        nil
+      end
+    end
+  end
 end

data/lib/rice/doc/ruby.rb

@@ -1,37 +1,37 @@
 module Rice
-	module Doc
-		class Ruby
-			ROOT = "https://docs.ruby-lang.org/en/master"
+  module Doc
+    class Ruby
+      ROOT = "https://docs.ruby-lang.org/en/master"
 
-			def initialize
-			end
+      def initialize
+      end
 
-			def class_url(klass)
-				name = klass.name.split('::').last
-				name[0].upcase! # Can't use capitalize because it lowercases other letters which breaks links like NilClass
-				"#{ROOT}/#{name}.html"
-			end
+      def class_url(klass)
+        name = klass.name.split('::').last
+        name[0].upcase! # Can't use capitalize because it lowercases other letters which breaks links like NilClass
+        "#{ROOT}/#{name}.html"
+      end
 
-			def module_url(klass)
-			end
+      def module_url(klass)
+      end
 
-			def union_url(klass)
-			end
+      def union_url(klass)
+      end
 
-			def enum_url(klass)
-			end
+      def enum_url(klass)
+      end
 
-			def enum_value_url(klass, enum_value)
-			end
+      def enum_value_url(klass, enum_value)
+      end
 
-			def singleton_method_url(klass, native)
-			end
+      def singleton_method_url(klass, native)
+      end
 
-			def method_url(klass, native)
-			end
+      def method_url(klass, native)
+      end
 
-			def attribute_url(klass, native)
-			end
-		end
-	end
+      def attribute_url(klass, native)
+      end
+    end
+  end
 end

data/lib/rice/native.rb

@@ -1,18 +1,18 @@
 module Rice
-	class Native
-		include Comparable
+  class Native
+    include Comparable
 
-		def <=>(other)
-			case
-				when self.name == other.name
-					self.parameters.size <=> other.parameters.size
-				when self.name == "initialize"
-					-1
-				when self.name == "initialize"
-					1
-				else
-					self.name <=> other.name
-			end
-		end
-	end
+    def <=>(other)
+      case
+        when self.name == other.name
+          self.parameters.size <=> other.parameters.size
+        when self.name == "initialize"
+          -1
+        when self.name == "initialize"
+          1
+        else
+          self.name <=> other.name
+      end
+    end
+  end
 end

data/lib/rice/native_registry.rb

@@ -1,21 +1,16 @@
 module Rice
-	class NativeRegistry
-		def native_attributes(klass)
-			self.native_by_kind(klass, [Rice::NativeKind::AttributeReader, Rice::NativeKind::AttributeWriter])
-		end
+  class NativeRegistry
+    def native_attributes(klass)
+      self.lookup_by_kind(klass, Rice::NativeKind::AttributeReader) +
+        self.lookup_by_kind(klass, Rice::NativeKind::AttributeWriter)
+    end
 
-		def native_methods(klass)
-			self.native_by_kind(klass, [Rice::NativeKind::Method])
-		end
+    def native_methods(klass)
+      self.lookup_by_kind(klass, Rice::NativeKind::Method)
+    end
 
-		def native_functions(klass)
-			self.native_by_kind(klass, [Rice::NativeKind::Function])
-		end
-
-		def native_by_kind(klass, kinds)
-			self.lookup(klass).find_all do |native|
-				kinds.include?(native.kind)
-			end
-		end
-	end
+    def native_functions(klass)
+      self.lookup_by_kind(klass, Rice::NativeKind::Function)
+    end
+  end
 end

data/lib/rice/parameter.rb

@@ -1,7 +1,7 @@
 module Rice
-	class Parameter
-		def to_s
-			"Parameter<#{self.arg.name}: #{self.klass.name}>"
-		end
-	end
+  class Parameter
+    def to_s
+      "Parameter<#{self.arg.name}: #{self.klass.name}>"
+    end
+  end
 end

data/lib/rice/rbs.rb

@@ -2,87 +2,87 @@ require 'erb'
 require 'fileutils'
 
 module Rice
-	class Rbs
-		attr_reader :extension, :output
+  class Rbs
+    attr_reader :extension, :output
 
-		def initialize(extension, output)
-			@extension = extension
-			@output = output
-		end
+    def initialize(extension, output)
+      @extension = extension
+      @output = output
+    end
 
-		def generate
-			STDOUT << "Writing rbs files to #{@output}" << "\n"
-			require self.extension
-			types = Registries.instance.types
-			types.klasses.each do |klass|
-				process_class(klass)
-			end
-		end
+    def generate
+      STDOUT << "Writing rbs files to #{@output}" << "\n"
 
-		def process_class(klass)
-			if ['Rice', 'Std'].include?(klass.name.split('::').first)
-				return
-			end
+      # Add the extension directory the path in case it ships with extra libraries
+      ENV["PATH"] = "#{File.dirname(self.extension)}#{File::PATH_SEPARATOR}#{ENV["PATH"]}"
+      require self.extension
 
-			STDOUT << "  " << klass << "\n"
+      types = Registries.instance.types
+      types.klasses.each do |klass|
+        process_class(klass)
+      end
+    end
 
-			native_attributes = Registries.instance.natives.native_attributes(klass).sort.group_by(&:name)
-			native_functions = Registries.instance.natives.native_functions(klass).sort.group_by(&:name)
-			native_methods = Registries.instance.natives.native_methods(klass).sort.group_by(&:name)
-			content = render_template("class", :klass => klass,
-													      :native_attributes => native_attributes,
-    													  :native_functions => native_functions,
-		    											  :native_methods => native_methods)
-			write_file(klass, content)
-		end
+    def process_class(klass)
+      STDOUT << "  " << klass << "\n"
 
-		def write_file(klass, content)
-			parts = klass.name.split("::")
-			file_name = "#{parts.pop}.rbs"
-			dir = File.join(self.output, *parts)
-			FileUtils.mkdir_p(dir)
+      native_attributes = Registries.instance.natives.native_attributes(klass).sort.group_by(&:name)
+      native_functions = Registries.instance.natives.native_functions(klass).sort.group_by(&:name)
+      native_methods = Registries.instance.natives.native_methods(klass).sort.group_by(&:name)
+      content = render_template("class", :klass => klass,
+                                :native_attributes => native_attributes,
+                                :native_functions => native_functions,
+                                :native_methods => native_methods)
+      write_file(klass, content)
+    end
 
-			path = File.join(dir, file_name)
-			File.write(path, content, mode: "wb")
-		end
+    def write_file(klass, content)
+      parts = klass.name.split("::")
+      file_name = "#{parts.pop}.rbs"
+      dir = File.join(self.output, *parts)
+      FileUtils.mkdir_p(dir)
 
-		def attribute_sig(native_attributes)
-			attr_type = if native_attributes.size == 2
-									 "attr_accessor"
-								 elsif native_attributes.first.kind == Rice::NativeKind::AttributeReader
-									 "attr_reader"
-								 else
-									 "attr_writer"
-								 end
-			"#{attr_type} #{native_attributes.first.name}: #{native_attributes.first.return_klass}"
-		end
+      path = File.join(dir, file_name)
+      File.write(path, content, mode: "wb")
+    end
 
-		def method_sigs(native_methods, indent = 0)
-			join_string = "\n" + (" " * indent) + "| "
-			a = native_methods.map do |native_method|
-				method_sig(native_method)
-			end
-			a.join(join_string)
-		end
+    def attribute_sig(native_attributes)
+      attr_type = if native_attributes.size == 2
+                   "attr_accessor"
+                 elsif native_attributes.first.kind == Rice::NativeKind::AttributeReader
+                   "attr_reader"
+                 else
+                   "attr_writer"
+                 end
+      "#{attr_type} #{native_attributes.first.name}: #{native_attributes.first.return_klass}"
+    end
 
-		def method_sig(native)
-			params = native.parameters.map do |parameter|
-				"#{parameter.arg.name}: #{parameter.klass}"
-			end.join(", ")
-			"(#{params}) -> #{native.return_klass}"
-		end
+    def method_sigs(native_methods, indent = 0)
+      join_string = "\n" + (" " * indent) + "| "
+      a = native_methods.map do |native_method|
+        method_sig(native_method)
+      end
+      a.join(join_string)
+    end
 
-		def render_template(template, local_variables = {})
-			template = ERB.new(self.template, :trim_mode => '-')
-			b = self.binding
-			local_variables.each do |key, value|
-				b.local_variable_set(key, value)
-			end
-			template.result(b)
-		end
+    def method_sig(native)
+      params = native.parameters.map do |parameter|
+        "#{parameter.arg.name}: #{parameter.klass}"
+      end.join(", ")
+      "(#{params}) -> #{native.return_klass}"
+    end
 
-		def template
-			<<~EOS
+    def render_template(template, local_variables = {})
+      template = ERB.new(self.template, :trim_mode => '-')
+      b = self.binding
+      local_variables.each do |key, value|
+        b.local_variable_set(key, value)
+      end
+      template.result(b)
+    end
+
+    def template
+      <<~EOS
         module <%= klass.name.split("::")[0..-2].join("::") %>
           class <%= klass.name.split("::").last %>
           <%- native_functions.each do |name, functions| -%>
@@ -98,7 +98,7 @@ module Rice
           <%- end -%>
           end
         end
-			EOS
-		end
-	end
+      EOS
+    end
+  end
 end

data/lib/rice/version.rb

@@ -1,3 +1,3 @@
 module Rice
-  VERSION = "4.8.0"
+  VERSION = "4.9.1"
 end

data/lib/rubygems/builder.rb

@@ -1,11 +1,11 @@
 class Gem::Ext::Builder
-	alias :builder_for_original :builder_for
-	def builder_for(extension)
-		case extension
-			when /CMakeLists.txt/ then
-				Gem::Ext::CmakeBuilder.new
-			else
-				builder_for_original(extension)
-		end
-	end
+  alias :builder_for_original :builder_for
+  def builder_for(extension)
+    case extension
+      when /CMakeLists.txt/ then
+        Gem::Ext::CmakeBuilder.new
+      else
+        builder_for_original(extension)
+    end
+  end
 end

data/lib/rubygems_plugin.rb

@@ -1,12 +1,12 @@
 # For older versions of RubyGems replace the default CMakeBuilder with a
 # more modern one
 if Gem.rubygems_version < Gem::Version.new('4.0')
-	Gem.pre_install do |installer|
-		extensions = installer.package&.spec&.extensions
-		if extensions && extensions.grep(/CMakeLists/)
-			require_relative 'rubygems/builder'
-			require_relative 'rubygems/cmake_builder'
-		end
-		true
-	end
+  Gem.pre_install do |installer|
+    extensions = installer.package&.spec&.extensions
+    if extensions && extensions.grep(/CMakeLists/)
+      require_relative 'rubygems/builder'
+      require_relative 'rubygems/cmake_builder'
+    end
+    true
+  end
 end

data/rice/Data_Type.ipp

@@ -5,17 +5,22 @@ namespace Rice
   template<typename T>
   inline void ruby_mark_internal(detail::WrapperBase* wrapper)
   {
-    // Tell the wrapper to mark the objects its keeping alive
-    wrapper->ruby_mark();
-
-    // Get the underlying data and call custom mark function (if any)
-    T* data = static_cast<T*>(wrapper->get());
-    ruby_mark<T>(data);
+    detail::cpp_protect([&]
+    {
+      // Tell the wrapper to mark the objects its keeping alive
+      wrapper->ruby_mark();
+
+      // Get the underlying data and call custom mark function (if any)
+      // Use the wrapper's stored rb_data_type to avoid type mismatch
+      T* data = static_cast<T*>(wrapper->get(Data_Type<T>::ruby_data_type()));
+      ruby_mark<T>(data);
+    });
   }
 
   template<typename T>
   inline void ruby_free_internal(detail::WrapperBase* wrapper)
   {
+    // Destructors are noexcept so we cannot use cpp_protect here
     delete wrapper;
   }
 
@@ -380,7 +385,7 @@ namespace Rice
       }
       else
       {
-        detail::NativeAttributeSet<Attribute_T>::define(klass, name, std::forward<Attribute_T>(attribute));
+        detail::NativeAttributeSet<Attribute_T>::define(klass, name, std::forward<Attribute_T>(attribute), args...);
       }
     }
 

data/rice/cpp_api/Class.hpp

@@ -37,6 +37,11 @@ namespace Rice
      */
     const std::string base_name() const;
 
+    //! Return the superclass of this class
+    /*! \return Class.
+     */
+    Class superclass() const;
+
 #include "shared_methods.hpp"
   };
 

data/rice/cpp_api/Class.ipp

@@ -33,6 +33,11 @@ namespace Rice
     return result;
   }
 
+  inline Class Class::superclass() const
+  {
+    return detail::protect(rb_class_superclass, this->value());
+  }
+
   inline Class define_class_under(Object parent, Identifier id, const Class& superclass)
   {
     VALUE klass = detail::protect(rb_define_class_id_under, parent.value(), id, superclass.value());

data/rice/cpp_api/Object.hpp

@@ -9,6 +9,7 @@
 namespace Rice
 {
   class Class;
+  class Module;
   class String;
   class Array;
 
@@ -116,6 +117,11 @@ namespace Rice
      */
     bool is_a(Object klass) const;
 
+    //! Extend the object with a module.
+    /*! \param mod the module to extend with.
+     */
+    void extend(Module const& mod);
+
     //! Determine if the objects responds to a method.
     /*! \param id the name of the method
      *  \return true if the objects responds to the method, false

data/rice/cpp_api/Object.ipp

@@ -99,6 +99,11 @@ namespace Rice
     return RB_TEST(result);
   }
 
+  inline void Object::extend(Module const& mod)
+  {
+    detail::protect(rb_extend_object, this->value(), mod.value());
+  }
+
   inline bool Object::respond_to(Identifier id) const
   {
     return bool(rb_respond_to(this->value(), id.id()));

data/rice/detail/Forwards.hpp

@@ -0,0 +1,18 @@
+#ifndef Rice__detail__Forwards__hpp_
+#define Rice__detail__Forwards__hpp_
+
+namespace Rice::detail
+{
+  // Setup method forwarding from a wrapper class to its wrapped type using Ruby's Forwardable.
+  // This allows calling methods on the wrapper that get delegated to the wrapped object via
+  // a "get" method that returns the wrapped object.
+  //
+  // Parameters:
+  //   wrapper_klass - The Ruby class to add forwarding to (e.g., SharedPtr_MyClass)
+  //   wrapped_klass - The Ruby class whose methods should be forwarded (e.g., MyClass)
+  void define_forwarding(VALUE wrapper_klass, VALUE wrapped_klass);
+}
+
+#include "Forwards.ipp"
+
+#endif // Rice__detail__Forwards__hpp_

data/rice/detail/Forwards.ipp

@@ -0,0 +1,60 @@
+namespace Rice::detail
+{
+  inline void define_forwarding(VALUE wrapper_klass, VALUE wrapped_klass)
+  {
+    protect(rb_require, "forwardable");
+    Object forwardable = Object(rb_cObject).const_get("Forwardable");
+    Object(wrapper_klass).extend(forwardable.value());
+
+    // Get wrapper class's method names to avoid conflicts
+    std::set<std::string> wrapperMethodSet;
+    for (Native* native : Registries::instance.natives.lookup(wrapper_klass, NativeKind::Method))
+    {
+      wrapperMethodSet.insert(native->name());
+    }
+    for (Native* native : Registries::instance.natives.lookup(wrapper_klass, NativeKind::AttributeReader))
+    {
+      wrapperMethodSet.insert(native->name());
+    }
+    for (Native* native : Registries::instance.natives.lookup(wrapper_klass, NativeKind::AttributeWriter))
+    {
+      wrapperMethodSet.insert(native->name() + "=");
+    }
+
+    // Get wrapped class's method names from the registry, including ancestor classes
+    std::set<std::string> wrappedMethodSet;
+    Class klass(wrapped_klass);
+    while (klass.value() != rb_cObject && klass.value() != Qnil)
+    {
+      for (Native* native : Registries::instance.natives.lookup(klass.value(), NativeKind::Method))
+      {
+        wrappedMethodSet.insert(native->name());
+      }
+      for (Native* native : Registries::instance.natives.lookup(klass.value(), NativeKind::AttributeReader))
+      {
+        wrappedMethodSet.insert(native->name());
+      }
+      for (Native* native : Registries::instance.natives.lookup(klass.value(), NativeKind::AttributeWriter))
+      {
+        wrappedMethodSet.insert(native->name() + "=");
+      }
+
+      klass = klass.superclass();
+    }
+
+    // Build the arguments array for def_delegators: [:get, :method1, :method2, ...]
+    // Skip methods that are already defined on the wrapper class
+    Array args;
+    args.push(Symbol("get"));
+    for (const std::string& method : wrappedMethodSet)
+    {
+      if (wrapperMethodSet.find(method) == wrapperMethodSet.end())
+      {
+        args.push(Symbol(method));
+      }
+    }
+
+    // Call def_delegators(*args)
+    Object(wrapper_klass).vcall("def_delegators", args);
+  }
+}

data/rice/detail/Native.ipp

@@ -176,16 +176,14 @@ namespace Rice::detail
       Arg* arg = parameters_[i]->arg();
       if (arg->isKeepAlive())
       {
-        static WrapperBase* selfWrapper = getWrapper(self);
-        selfWrapper->addKeepAlive(rubyValues[i].value());
+        WrapperBase::addKeepAlive(self, rubyValues[i].value());
       }
     }
 
     // Check return value
     if (this->returnInfo_->isKeepAlive())
     {
-      WrapperBase* returnWrapper = getWrapper(returnValue);
-      returnWrapper->addKeepAlive(self);
+      WrapperBase::addKeepAlive(returnValue, self);
     }
   }