rice 4.8.0 → 4.9.1

data/lib/rice/doc/config.rb

@@ -1,70 +1,70 @@
 require 'yaml'
 
 module Rice
-	module Doc
-		class Config
-			attr_reader :extension, :output, :resolvers
+  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
+      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
+      private
 
-			def build_resolvers(namespace_configs)
-				# Always include Ruby resolver for core types
-				result = { nil => Ruby.new }
+      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
+        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_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_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_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_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
+      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

@@ -2,162 +2,162 @@ require 'open-uri'
 require 'libxml-ruby'
 
 module Rice
-	module Doc
-		class CppReference
-			ROOT = "https://en.cppreference.com/w"
-			INDEX = "https://raw.githubusercontent.com/p12tic/cppreference-doc/refs/heads/master/index-functions-cpp.xml"
-			#INDEX = "c:/Users/cfis/Downloads/index-functions-cpp.xml"
-
-			OPERATORS = {"assign" => "operator=",
-									 "assign_plus" => "operator+=",
-									 "assign_minus" => "operator-=",
-									 "assign_multiply" => "operator*=",
-									 "assign_divide" => "operator/=",
-									 "call" => "operator()",
-									 "decrement" => "operator--",
-									 "dereference" => "operator*",
-									 "increment" => "operator++",
-									 "==" => "operator==",
-									 "!=" => "operator!=",
-									 "+" => "operator+",
-									 "-" => "operator-",
-									 "*" => "operator*",
-									 "/" => "operator/",
-									 "&" => "operator&",
-									 "|" => "operator|",
-									 "<" => "operator<",
-									 ">" => "operator>",
-									 "<=" => "operator<=",
-									 "<<" => "operator<<",
-									 "[]" => "operator[]",
-									 "[]=" => "operator[]"}
-
-			def initialize
-				@type_mappings = {/^enum\s*/i => '',
-													/^union\s*/i => '',
-													/<.*>/ => ''}
-
-				@method_mappings = {'std::exception' => {'message' => 'what'},
-														'std::map' => {'delete' => 'erase',
- 																					 'include?' => 'find'},
-														'std::multimap' => {'delete' => 'erase',
-																								'include?' => 'find'},
-														'std::runtime_error' => {'message' => 'what'},
-														'std::unorderedmap' => {'delete' => 'erase',
-																					 					'include?' => 'find'},
-														'std::vector' => {'delete_at' => 'erase',
-																							'first' => 'front',
-																							'last' => 'back',
-																							'pop' => 'pop_back',
-																							'push' => 'push_back'}}
-
-														@cache = Hash.new
-				data = URI.open(INDEX).read
-				parser = LibXML::XML::Parser.string(data)
-				@doc = parser.parse
-			end
-
-			def camelize(content, capitalize = true)
-				result = content.gsub(/(?:_)(.)/) do |matched|
-					$1.capitalize
-				end
-
-				result[0] = capitalize ? result[0].upcase : result[0].downcase
-				result
-			end
-
-			def cpp_name(klass)
-				result = klass.cpp_class
-				@type_mappings.each do |key, value|
-					result = result.gsub(key, value)
-				end
-				result
-			end
-
-			def get_node(klass, xpath)
-				node = @cache[klass]
-				if node.nil? && !@cache.has_key?(klass)
-					node = @cache[klass] = @doc.find_first(xpath)
-				end
-				node
-			end
-
-			def class_node(klass)
-				xpath = "//class[@name='#{cpp_name(klass)}']"
-				get_node(klass, xpath)
-			end
-
-			def class_base(klass)
-				node = class_node(klass)
-				if node
-					path = node.attributes["link"]
-					"#{ROOT}/#{path}"
-				end
-			end
-
-			def class_url(klass)
-				node = class_node(klass)
-				if node
-					"#{class_base(klass)}.html"
-				end
-			end
-
-			def module_url(klass)
-			end
-
-			def method_url(klass, native)
-				node = class_node(klass)
-				if node
-					ruby_name = native.name
-					method_names = Array.new
-					if ruby_name == "initialize" || ruby_name == "initialize_copy"
-						return "#{class_base(klass)}.html"
-					elsif native_name = OPERATORS[ruby_name]
-						method_names << native_name
-					elsif native_name = @method_mappings.dig(cpp_name(klass), ruby_name)
-						method_names << native_name
-					elsif ruby_name.match(/\?$/)
-						native_name = ruby_name.gsub(/\?$/, "")
-						method_names << camelize(native_name, false)
-						method_names << camelize(native_name, true)
-						method_names << "is#{camelize(native_name, true)}"
-					else
-						method_names << ruby_name
-						method_names << camelize(ruby_name, false)
-						method_names << camelize(ruby_name, true)
-					end
-
-					pattern = method_names.map do |method_name|
-						"@name='#{method_name}'"
-					end.join(" or ")
-
-					xpath = "function[#{pattern}]"
-					member_node = node&.find_first(xpath)
-					if member_node && member_node.attributes["link"]
-  					"#{class_base(klass)}/#{member_node.attributes['link']}.html"
-					elsif member_node
-						"#{class_base(klass)}/#{member_node.attributes['name']}.html"
-					end
-				end
-			end
-
-			def attribute_url(klass, native)
-				node = class_node(klass)
-
-				# Find the member node
-				attribute_name = camelize(native.name, false)
-
-				xpath = "variable[@name='#{attribute_name}']"
-				member_node = node&.find_first(xpath)
-				link = member_node.attributes["link"]
-				if member_node && link && link != "."
-					"#{class_base(klass)}/#{member_node.attributes['link']}.html"
-				elsif member_node && link && link == "."
-	  			"#{class_base(klass)}.html"
-				elsif member_node
-					"#{class_base(klass)}/#{member_node.attributes['name']}.html"
-				end
-			end
-		end
-	end
+  module Doc
+    class CppReference
+      ROOT = "https://en.cppreference.com/w"
+      INDEX = "https://raw.githubusercontent.com/p12tic/cppreference-doc/refs/heads/master/index-functions-cpp.xml"
+      #INDEX = "c:/Users/cfis/Downloads/index-functions-cpp.xml"
+
+      OPERATORS = {"assign" => "operator=",
+                   "assign_plus" => "operator+=",
+                   "assign_minus" => "operator-=",
+                   "assign_multiply" => "operator*=",
+                   "assign_divide" => "operator/=",
+                   "call" => "operator()",
+                   "decrement" => "operator--",
+                   "dereference" => "operator*",
+                   "increment" => "operator++",
+                   "==" => "operator==",
+                   "!=" => "operator!=",
+                   "+" => "operator+",
+                   "-" => "operator-",
+                   "*" => "operator*",
+                   "/" => "operator/",
+                   "&" => "operator&",
+                   "|" => "operator|",
+                   "<" => "operator<",
+                   ">" => "operator>",
+                   "<=" => "operator<=",
+                   "<<" => "operator<<",
+                   "[]" => "operator[]",
+                   "[]=" => "operator[]"}
+
+      def initialize
+        @type_mappings = {/^enum\s*/i => '',
+                          /^union\s*/i => '',
+                          /<.*>/ => ''}
+
+        @method_mappings = {'std::exception' => {'message' => 'what'},
+                            'std::map' => {'delete' => 'erase',
+                                            'include?' => 'find'},
+                            'std::multimap' => {'delete' => 'erase',
+                                                'include?' => 'find'},
+                            'std::runtime_error' => {'message' => 'what'},
+                            'std::unorderedmap' => {'delete' => 'erase',
+                                                     'include?' => 'find'},
+                            'std::vector' => {'delete_at' => 'erase',
+                                              'first' => 'front',
+                                              'last' => 'back',
+                                              'pop' => 'pop_back',
+                                              'push' => 'push_back'}}
+
+                            @cache = Hash.new
+        data = URI.open(INDEX).read
+        parser = LibXML::XML::Parser.string(data)
+        @doc = parser.parse
+      end
+
+      def camelize(content, capitalize = true)
+        result = content.gsub(/(?:_)(.)/) do |matched|
+          $1.capitalize
+        end
+
+        result[0] = capitalize ? result[0].upcase : result[0].downcase
+        result
+      end
+
+      def cpp_name(klass)
+        result = klass.cpp_class
+        @type_mappings.each do |key, value|
+          result = result.gsub(key, value)
+        end
+        result
+      end
+
+      def get_node(klass, xpath)
+        node = @cache[klass]
+        if node.nil? && !@cache.has_key?(klass)
+          node = @cache[klass] = @doc.find_first(xpath)
+        end
+        node
+      end
+
+      def class_node(klass)
+        xpath = "//class[@name='#{cpp_name(klass)}']"
+        get_node(klass, xpath)
+      end
+
+      def class_base(klass)
+        node = class_node(klass)
+        if node
+          path = node.attributes["link"]
+          "#{ROOT}/#{path}"
+        end
+      end
+
+      def class_url(klass)
+        node = class_node(klass)
+        if node
+          "#{class_base(klass)}.html"
+        end
+      end
+
+      def module_url(klass)
+      end
+
+      def method_url(klass, native)
+        node = class_node(klass)
+        if node
+          ruby_name = native.name
+          method_names = Array.new
+          if ruby_name == "initialize" || ruby_name == "initialize_copy"
+            return "#{class_base(klass)}.html"
+          elsif native_name = OPERATORS[ruby_name]
+            method_names << native_name
+          elsif native_name = @method_mappings.dig(cpp_name(klass), ruby_name)
+            method_names << native_name
+          elsif ruby_name.match(/\?$/)
+            native_name = ruby_name.gsub(/\?$/, "")
+            method_names << camelize(native_name, false)
+            method_names << camelize(native_name, true)
+            method_names << "is#{camelize(native_name, true)}"
+          else
+            method_names << ruby_name
+            method_names << camelize(ruby_name, false)
+            method_names << camelize(ruby_name, true)
+          end
+
+          pattern = method_names.map do |method_name|
+            "@name='#{method_name}'"
+          end.join(" or ")
+
+          xpath = "function[#{pattern}]"
+          member_node = node&.find_first(xpath)
+          if member_node && member_node.attributes["link"]
+            "#{class_base(klass)}/#{member_node.attributes['link']}.html"
+          elsif member_node
+            "#{class_base(klass)}/#{member_node.attributes['name']}.html"
+          end
+        end
+      end
+
+      def attribute_url(klass, native)
+        node = class_node(klass)
+
+        # Find the member node
+        attribute_name = camelize(native.name, false)
+
+        xpath = "variable[@name='#{attribute_name}']"
+        member_node = node&.find_first(xpath)
+        link = member_node.attributes["link"]
+        if member_node && link && link != "."
+          "#{class_base(klass)}/#{member_node.attributes['link']}.html"
+        elsif member_node && link && link == "."
+          "#{class_base(klass)}.html"
+        elsif member_node
+          "#{class_base(klass)}/#{member_node.attributes['name']}.html"
+        end
+      end
+    end
+  end
 end