rice 4.9.0 → 4.9.1

data/lib/rice/doc/rice.rb

@@ -1,50 +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",
-				/^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
+  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,16 +1,16 @@
 module Rice
-	class NativeRegistry
-		def native_attributes(klass)
-			self.lookup_by_kind(klass, Rice::NativeKind::AttributeReader) +
-				self.lookup_by_kind(klass, 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.lookup_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.lookup_by_kind(klass, Rice::NativeKind::Function)
-		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"
+    def generate
+      STDOUT << "Writing rbs files to #{@output}" << "\n"
 
-			# 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
+      # 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
 
-			types = Registries.instance.types
-			types.klasses.each do |klass|
-				process_class(klass)
-			end
-		end
+      types = Registries.instance.types
+      types.klasses.each do |klass|
+        process_class(klass)
+      end
+    end
 
-		def process_class(klass)
-			STDOUT << "  " << klass << "\n"
+    def process_class(klass)
+      STDOUT << "  " << klass << "\n"
 
-			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
+      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 write_file(klass, content)
-			parts = klass.name.split("::")
-			file_name = "#{parts.pop}.rbs"
-			dir = File.join(self.output, *parts)
-			FileUtils.mkdir_p(dir)
+    def write_file(klass, content)
+      parts = klass.name.split("::")
+      file_name = "#{parts.pop}.rbs"
+      dir = File.join(self.output, *parts)
+      FileUtils.mkdir_p(dir)
 
-			path = File.join(dir, file_name)
-			File.write(path, content, mode: "wb")
-		end
+      path = File.join(dir, file_name)
+      File.write(path, content, mode: "wb")
+    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 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_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 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 method_sig(native)
-			params = native.parameters.map do |parameter|
-				"#{parameter.arg.name}: #{parameter.klass}"
-			end.join(", ")
-			"(#{params}) -> #{native.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 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 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
+    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.9.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

@@ -385,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/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);
     }
   }
 

data/rice/detail/NativeAttributeGet.ipp

@@ -23,7 +23,7 @@ namespace Rice::detail
     // matches or calls function pointer. Instead Ruby can call the static call method defined on
     // this class (&NativeAttribute_T::get).
     Identifier identifier(name);
-    detail::Registries::instance.natives.add(klass, identifier.id(), native);
+    detail::Registries::instance.natives.replace(klass, identifier.id(), native);
   }
 
   template<typename Attribute_T>

data/rice/detail/NativeAttributeSet.hpp

@@ -15,8 +15,9 @@ namespace Rice
       using Receiver_T = typename attribute_traits<Attribute_T>::class_type;
 
     public:
-      // Register attribute getter/setter with Ruby
-      static void define(VALUE klass, std::string name, Attribute_T attribute);
+      // Register attribute setter with Ruby
+      template<typename...Arg_Ts>
+      static void define(VALUE klass, std::string name, Attribute_T attribute, Arg_Ts&...args);
 
     public:
       // Disallow creating/copying/moving
@@ -34,11 +35,12 @@ namespace Rice
       VALUE returnKlass() override;
 
     protected:
-      NativeAttributeSet(VALUE klass, std::string name, Attribute_T attr);
+      NativeAttributeSet(VALUE klass, std::string name, Attribute_T attr, std::unique_ptr<Parameter<T_Unqualified>> parameter);
 
     private:
       VALUE klass_;
       Attribute_T attribute_;
+      std::unique_ptr<Parameter<T_Unqualified>> parameter_;
     };
   } // detail
 } // Rice

data/rice/detail/NativeAttributeSet.ipp

@@ -5,28 +5,46 @@
 namespace Rice::detail
 {
   template<typename Attribute_T>
-  void NativeAttributeSet<Attribute_T>::define(VALUE klass, std::string name, Attribute_T attribute)
+  template<typename...Arg_Ts>
+  void NativeAttributeSet<Attribute_T>::define(VALUE klass, std::string name, Attribute_T attribute, Arg_Ts&...args)
   {
-    // Create a NativeAttributeSet that Ruby will call to read/write C++ variables
-    NativeAttribute_T* nativeAttribute = new NativeAttribute_T(klass, name, std::forward<Attribute_T>(attribute));
+    // Extract Arg from Arg_Ts if present, otherwise create default
+    using Arg_Tuple = std::tuple<Arg_Ts...>;
+    constexpr std::size_t index = tuple_element_index_v<Arg_Tuple, Arg, ArgBuffer>;
+
+    std::unique_ptr<Arg> arg;
+    if constexpr (index < std::tuple_size_v<Arg_Tuple>)
+    {
+      using Arg_T_Local = std::decay_t<std::tuple_element_t<index, Arg_Tuple>>;
+      const Arg_T_Local& argInfo = std::get<index>(std::forward_as_tuple(std::forward<Arg_Ts>(args)...));
+      arg = std::make_unique<Arg_T_Local>(argInfo);
+    }
+    else
+    {
+      arg = std::make_unique<Arg>("value");
+    }
+
+    // Create the parameter
+    auto parameter = std::make_unique<Parameter<T_Unqualified>>(std::move(arg));
+
+    // Create a NativeAttributeSet that Ruby will call to write C++ variables
+    NativeAttribute_T* nativeAttribute = new NativeAttribute_T(klass, name, std::forward<Attribute_T>(attribute), std::move(parameter));
     std::unique_ptr<Native> native(nativeAttribute);
 
     // Define the write method name
     std::string setter = name + "=";
 
-    // Tell Ruby to invoke the static method write to get the attribute value
+    // Tell Ruby to invoke the static method resolve to set the attribute value
     detail::protect(rb_define_method, klass, setter.c_str(), (RUBY_METHOD_FUNC)&Native::resolve, -1);
 
-    // Add to native registry. Since attributes cannot be overridden, there is no need to set the
-    // matches or calls function pointer. Instead Ruby can call the static call method defined on
-    // this class (&NativeAttribute_T::set).
+    // Add to native registry
     Identifier identifier(setter);
-    detail::Registries::instance.natives.add(klass, identifier.id(), native);
+    detail::Registries::instance.natives.replace(klass, identifier.id(), native);
   }
 
   template<typename Attribute_T>
-  NativeAttributeSet<Attribute_T>::NativeAttributeSet(VALUE klass, std::string name, Attribute_T attribute)
-    : Native(name), klass_(klass), attribute_(attribute)
+  NativeAttributeSet<Attribute_T>::NativeAttributeSet(VALUE klass, std::string name, Attribute_T attribute, std::unique_ptr<Parameter<T_Unqualified>> parameter)
+    : Native(name), klass_(klass), attribute_(attribute), parameter_(std::move(parameter))
   {
   }
 
@@ -47,25 +65,25 @@ namespace Rice::detail
       throw std::runtime_error("Incorrect number of parameters for setting attribute. Attribute: " + this->name_);
     }
 
+    // Get the Ruby value and convert to native
     VALUE value = values.begin()->second;
+    std::optional<VALUE> valueOpt(value);
+    T_Unqualified nativeValue = this->parameter_->convertToNative(valueOpt);
 
     if constexpr (!std::is_null_pointer_v<Receiver_T>)
     {
       Receiver_T* nativeSelf = From_Ruby<Receiver_T*>().convert(self);
-
-      // Deal with pointers to pointes, see Parameter::convertToNative commment
-      if constexpr (is_pointer_pointer_v<Attr_T> && !std::is_convertible_v<remove_cv_recursive_t<Attr_T>, Attr_T>)
-      {
-        nativeSelf->*attribute_ = (Attr_T)From_Ruby<T_Unqualified>().convert(value);
-      }
-      else
-      {
-        nativeSelf->*attribute_ = From_Ruby<T_Unqualified>().convert(value);
-      }
+      nativeSelf->*attribute_ = (Attr_T)nativeValue;
     }
     else
     {
-      *attribute_ = From_Ruby<T_Unqualified>().convert(value);
+      *attribute_ = nativeValue;
+    }
+
+    // Check if we need to prevent the value from being garbage collected
+    if (this->parameter_->arg()->isKeepAlive())
+    {
+      WrapperBase::addKeepAlive(self, value);
     }
 
     return value;
@@ -86,17 +104,7 @@ namespace Rice::detail
   template<typename Attribute_T>
   inline VALUE NativeAttributeSet<Attribute_T>::returnKlass()
   {
-    // Check if an array is being returned
-    bool isBuffer = dynamic_cast<ReturnBuffer*>(this->returnInfo_.get()) ? true : false;
-    if (isBuffer)
-    {
-      TypeMapper<Pointer<detail::remove_cv_recursive_t<std::remove_pointer_t<Attr_T>>>> typeMapper;
-      return typeMapper.rubyKlass();
-    }
-    else
-    {
-      TypeMapper<Attr_T> typeMapper;
-      return typeMapper.rubyKlass();
-    }
+    TypeMapper<Attr_T> typeMapper;
+    return typeMapper.rubyKlass();
   }
 }