rice 4.7.1 → 4.8.0

data/lib/rice/doc/config.rb

@@ -0,0 +1,70 @@
+require 'yaml'
+
+module Rice
+	module Doc
+		class Config
+			attr_reader :extension, :output, :resolvers
+
+			def initialize(config_path)
+				config = YAML.load_file(config_path)
+				base_dir = File.dirname(config_path)
+				@extension = File.expand_path(config['extension'], base_dir)
+				@output = File.expand_path(config['output'], base_dir)
+				@resolvers = build_resolvers(config['namespaces'] || {})
+			end
+
+			private
+
+			def build_resolvers(namespace_configs)
+				# Always include Ruby resolver for core types
+				result = { nil => Ruby.new }
+
+				namespace_configs.each do |namespace, config|
+					key = namespace == 'default' ? nil : namespace
+					result[key] = build_resolver(config)
+				end
+				result
+			end
+
+			def build_resolver(config)
+				resolver = config['resolver']
+				case resolver
+				when 'cppreference'
+					build_cppreference_resolver(config)
+				when 'doxygen'
+					build_doxygen_resolver(config)
+				when 'rice'
+					build_rice_resolver(config)
+				else
+					raise "Unknown resolver: #{resolver}"
+				end
+			end
+
+			def build_cppreference_resolver(config)
+				CppReference.new
+			end
+
+			def build_doxygen_resolver(config)
+				root = config['root']
+				tagfile = config['tagfile']
+				type_mappings = build_type_mappings(config['type_mappings'] || [])
+				method_mappings = config['method_mappings'] || {}
+				Doxygen.new(root, tagfile, type_mappings, method_mappings)
+			end
+
+			def build_rice_resolver(config)
+				Rice.new
+			end
+
+			def build_type_mappings(mappings)
+				result = {}
+				mappings.each do |mapping|
+					pattern = Regexp.new(mapping['pattern'], Regexp::IGNORECASE)
+					replacement = mapping['replacement'] || ''
+					result[pattern] = replacement
+				end
+				result
+			end
+		end
+	end
+end

data/lib/rice/doc/cpp_reference.rb

@@ -91,8 +91,6 @@ module Rice
 				node = class_node(klass)
 				if node
 					path = node.attributes["link"]
-					name = cpp_name(klass)
-					parts = name.split("::")
 					"#{ROOT}/#{path}"
 				end
 			end
@@ -105,7 +103,6 @@ module Rice
 			end
 
 			def module_url(klass)
-				a = 1
 			end
 
 			def method_url(klass, native)
@@ -155,7 +152,7 @@ module Rice
 				link = member_node.attributes["link"]
 				if member_node && link && link != "."
 					"#{class_base(klass)}/#{member_node.attributes['link']}.html"
-  			elsif member_node && link && link == "."
+				elsif member_node && link && link == "."
 	  			"#{class_base(klass)}.html"
 				elsif member_node
 					"#{class_base(klass)}/#{member_node.attributes['name']}.html"

data/lib/rice/doc/mkdocs.rb

@@ -35,6 +35,46 @@ module Rice
 						write_class(klass)
 					end
 				end
+
+				create_indexes
+			end
+
+			def create_indexes
+				# Find all directories (including output root)
+				directories = Dir.glob(File.join(@output, '**', '*')).select { |f| File.directory?(f) }
+				directories.unshift(@output)
+
+				directories.each do |dir|
+					entries = []
+					has_index = File.exist?(File.join(dir, 'index.md'))
+
+					# Get all .md files in this directory (excluding index.md)
+					Dir.glob(File.join(dir, '*.md')).each do |file|
+						basename = File.basename(file)
+						entries << basename unless basename == 'index.md'
+					end
+
+					# Get all subdirectories
+					Dir.glob(File.join(dir, '*')).each do |path|
+						if File.directory?(path)
+							entries << File.basename(path)
+						end
+					end
+
+					# Sort alphabetically
+					entries.sort!
+
+					# Prepend index.md if it exists
+					entries.unshift('index.md') if has_index
+
+					pages_path = File.join(dir, '.pages')
+					File.open(pages_path, 'w') do |file|
+						file << "nav:\n"
+						entries.each do |entry|
+							file << "  - #{entry}\n"
+						end
+					end
+				end
 			end
 
 			def output_path(klass)
@@ -127,7 +167,6 @@ module Rice
 
 			def parameters_sig(klass, native)
 				native.parameters.map do |parameter|
-					resolver = resolver(parameter.klass)
 					url = type_url(parameter.klass)
 					if url
 						"#{parameter.arg.name}: [#{parameter.klass}](#{url})"
@@ -138,7 +177,6 @@ module Rice
 			end
 
 			def return_sig(klass, native)
-				resolver = resolver(native.return_klass)
 				url = type_url(native.return_klass)
 				if url
 					"[#{native.return_klass}](#{url})"
@@ -166,10 +204,16 @@ module Rice
 
 				name = ESCAPE_METHODS[native.name] || native.name
 
-				if url
-					"[#{name}](#{url})(#{parameters_sig(klass, native)}) -> #{return_sig(klass, native)}"
+				parameters_string = if native.parameters.empty?
+															""
+														else
+															"(#{parameters_sig(klass, native)})"
+														end
+
+  			if url
+					"[#{name}](#{url})#{parameters_string} -> #{return_sig(klass, native)}"
 				else
-					"#{name}(#{parameters_sig(klass, native)}) -> #{return_sig(klass, native)}"
+					"#{name}#{parameters_string} -> #{return_sig(klass, native)}"
 				end
 			end
 
@@ -187,7 +231,6 @@ module Rice
 				attribute_resolver = resolver(klass)
 				attribute_url = attribute_resolver&.attribute_url(klass, native_attribute)
 
-				type_resolver = resolver(native_attribute.return_klass)
 				type_url = type_url(native_attribute.return_klass)
 
 				if attribute_url
@@ -198,24 +241,23 @@ module Rice
 			end
 
 			def write_module(a_module)
-				native_singleton_functions = Registries.instance.natives.native_singleton_functions(a_module).sort.group_by(&:name)
+				native_singleton_functions = Registries.instance.natives.native_functions(a_module.singleton_class).sort.group_by(&:name)
+				return if native_singleton_functions.empty?
 
 				path = output_path(a_module)
 				File.open(path, 'w') do |file|
 					file << "#" << a_module.name << "\n"
-					unless native_singleton_functions.empty?
-						file << "## Singleton Methods" << "\n"
-						native_singleton_functions.each do |name, natives|
-							file << method_sigs(a_module, natives, false) << "\n\n"
-						end
-						file << "\n"
+ 				  file << "## Singleton Methods" << "\n"
+					native_singleton_functions.each do |name, natives|
+						file << method_sigs(a_module, natives, false) << "\n\n"
 					end
-				end
+					file << "\n"
+ 					end
 			end
 
 			def write_class(klass)
 				native_attributes = Registries.instance.natives.native_attributes(klass).sort.group_by(&:name)
-				native_singleton_functions = Registries.instance.natives.native_singleton_functions(klass).sort.group_by(&:name)
+				native_singleton_functions = Registries.instance.natives.native_functions(klass.singleton_class).sort.group_by(&:name)
 				native_methods = Registries.instance.natives.native_methods(klass).sort.group_by(&:name)
 
 				path = output_path(klass)
@@ -232,7 +274,7 @@ module Rice
 					end
 
 					# Constructors
-					constructors = native_methods["initialize"]
+					constructors = native_methods.delete("initialize")
 					if constructors
 						file << "## Constructors" << "\n"
 						constructors.each do |constructor|
@@ -254,7 +296,6 @@ module Rice
 					unless native_methods.empty?
 						file << "## Methods" << "\n"
 						native_methods.each do |name, natives|
-							next if name == "initialize"
 							file << method_sigs(klass, natives, false) << "\n\n"
 						end
 						file << "\n"
@@ -263,8 +304,6 @@ module Rice
 			end
 
 			def write_enum(klass)
-				klass_name = klass.name.split('::').last
-
 				path = output_path(klass)
 				File.open(path, 'w') do |file|
 					file << enum_sig(klass) << "\n"
@@ -276,7 +315,6 @@ module Rice
 			end
 
 			def write_union(klass)
-				klass_name = klass.name.split('::').last
 				native_attributes = Registries.instance.natives.native_attributes(klass).sort.group_by(&:name)
 
 				path = output_path(klass)

data/lib/rice/doc/rice.rb

@@ -1,28 +1,48 @@
 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

data/lib/rice/doc.rb

@@ -3,3 +3,4 @@ require_relative 'doc/doxygen'
 require_relative 'doc/rice'
 require_relative 'doc/ruby'
 require_relative 'doc/mkdocs'
+require_relative 'doc/config'

data/lib/rice/make_rice_headers.rb

@@ -56,6 +56,13 @@ end
 def combine_headers(filename)
   stream = StringIO.new
 
+  stream << "// This file is part of [rice](https://github.com/ruby-rice/rice).\n"
+  stream << "//\n"
+  load_file("COPYING").each_line do |line|
+    stream << (line.strip.size.zero? ? "//\n" : "// #{line}")
+  end
+  stream << "\n"
+
   load_file("rice/#{filename}").each_line do |line|
     if matches = line.match(RICE_INCLUDE_REGEX)
       path = File.join("rice", matches[1])

data/lib/rice/native_registry.rb

@@ -8,8 +8,8 @@ module Rice
 			self.native_by_kind(klass, [Rice::NativeKind::Method])
 		end
 
-		def native_singleton_functions(klass)
-			self.native_by_kind(klass.singleton_class, [Rice::NativeKind::Function])
+		def native_functions(klass)
+			self.native_by_kind(klass, [Rice::NativeKind::Function])
 		end
 
 		def native_by_kind(klass, kinds)

data/lib/rice/rbs.rb

@@ -54,7 +54,7 @@ module Rice
 								 else
 									 "attr_writer"
 								 end
-			"#{attr_type} #{native_attributes.first.name}: #{native_attributes.first.return_type}"
+			"#{attr_type} #{native_attributes.first.name}: #{native_attributes.first.return_klass}"
 		end
 
 		def method_sigs(native_methods, indent = 0)
@@ -69,7 +69,7 @@ module Rice
 			params = native.parameters.map do |parameter|
 				"#{parameter.arg.name}: #{parameter.klass}"
 			end.join(", ")
-			"(#{params}) -> #{native.return_type}"
+			"(#{params}) -> #{native.return_klass}"
 		end
 
 		def render_template(template, local_variables = {})

data/lib/rice/version.rb

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

data/lib/rubygems_plugin.rb

@@ -1,9 +1,12 @@
-# Create RubyGems hook so we can replace the default CMakeBuilder with our own version
-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
+# 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
+end

data/rice/Arg.hpp

@@ -70,6 +70,12 @@ namespace Rice
     //! Returns if the argument should be treated as a value
     bool isValue() const;
 
+    //! Specifies if the argument should capture a block
+    virtual Arg& setBlock();
+
+    //! Returns if the argument should capture a block
+    bool isBlock() const;
+
     //! Specifies if the argument is opaque and Rice should not convert it from Ruby to C++ or vice versa.
     //! This is useful for callbacks and user provided data paramameters.
     virtual Arg& setOpaque();
@@ -81,23 +87,23 @@ namespace Rice
     virtual Arg& takeOwnership();
     bool isOwner();
 
-    //! Is the parameter a buffer
-    virtual Arg& setBuffer();
-    bool isBuffer();
-
   public:
     std::string name;
-    int32_t position = -1;
 
   private:
     //! Our saved default value
     std::any defaultValue_;
     bool isValue_ = false;
+    bool isBlock_ = false;
     bool isKeepAlive_ = false;
     bool isOwner_ = false;
     bool isOpaque_ = false;
-    bool isBuffer_ = false;
+  };
 
+  class ArgBuffer : public Arg
+  {
+  public:
+    ArgBuffer(std::string name);
   };
 } // Rice
 

data/rice/Arg.ipp

@@ -48,6 +48,18 @@ namespace Rice
     return isValue_;
   }
 
+  inline Arg& Arg::setBlock()
+  {
+    isBlock_ = true;
+    isValue_ = true;
+    return *this;
+  }
+
+  inline bool Arg::isBlock() const
+  {
+    return isBlock_;
+  }
+
   inline Arg& Arg::setOpaque()
   {
     isOpaque_ = true;
@@ -70,14 +82,9 @@ namespace Rice
     return this->isOwner_;
   }
 
-  inline Arg& Arg::setBuffer()
+  inline ArgBuffer::ArgBuffer(std::string name) : Arg(name)
   {
-    this->isBuffer_ = true;
-    return *this;
   }
 
-  inline bool Arg::isBuffer()
-  {
-    return this->isBuffer_;
-  }
+
 } // Rice