Merge pull request #171 from sue445/generator_helper_to_go_util

Refactor ruby_h_to_go

Author: sue445

_tools/ruby_h_to_go/lib/ruby_h_to_go.rb

@@ -4,15 +4,15 @@
 
 require_relative "ruby_header_parser"
 
-require_relative "ruby_h_to_go/generator_helper"
-require_relative "ruby_h_to_go/argument_definition"
-require_relative "ruby_h_to_go/cli"
-require_relative "ruby_h_to_go/enum_definition"
-require_relative "ruby_h_to_go/function_definition"
-require_relative "ruby_h_to_go/struct_definition"
-require_relative "ruby_h_to_go/type_definition"
-require_relative "ruby_h_to_go/typeref_definition"
-
 # Generate Go binding from ruby.h
 module RubyHToGo
+  autoload :ArgumentDefinition, "ruby_h_to_go/argument_definition"
+  autoload :Cli,                "ruby_h_to_go/cli"
+  autoload :GoUtil,             "ruby_h_to_go/go_util"
+  autoload :EnumDefinition,     "ruby_h_to_go/enum_definition"
+  autoload :FunctionDefinition, "ruby_h_to_go/function_definition"
+  autoload :StructDefinition,   "ruby_h_to_go/struct_definition"
+  autoload :TypeDefinition,     "ruby_h_to_go/type_definition"
+  autoload :TypeHelper,         "ruby_h_to_go/type_helper"
+  autoload :TyperefDefinition,  "ruby_h_to_go/typeref_definition"
 end

_tools/ruby_h_to_go/lib/ruby_h_to_go/argument_definition.rb

@@ -7,7 +7,7 @@ class ArgumentDefinition
 
     def_delegators :@definition, :==, :type, :type=, :name, :name=, :pointer, :pointer=, :pointer?, :length, :length=
 
-    include GeneratorHelper
+    include TypeHelper
 
     # @param definition [RubyHeaderParser::ArgumentDefinition]
     # @param header_dir [String]
@@ -35,25 +35,25 @@ def go_name
 
     # @return [String]
     def go_function_arg
-      "#{go_name} #{ruby_c_type_to_go_type(type, pointer:, pointer_length: length, pos: :arg)}"
+      "#{go_name} #{ruby_c_type_to_go_type(pointer:, pointer_length: length, pos: :arg)}"
     end
 
     # @return [String]
     def cast_to_cgo
       case pointer
       when :array
-        return "toCArray[#{ruby_c_type_to_go_type(type)}, #{cast_to_cgo_type(type)}](#{go_name})"
+        return "toCArray[#{ruby_c_type_to_go_type}, #{cast_to_cgo_type}](#{go_name})"
       when :ref_array
-        return "toCArray[*#{ruby_c_type_to_go_type(type)}, *#{cast_to_cgo_type(type)}](#{go_name})"
+        return "toCArray[*#{ruby_c_type_to_go_type}, *#{cast_to_cgo_type}](#{go_name})"
       when :sref
         return go_name if type == "void" && length == 2
 
-        return "(#{"*" * length}#{cast_to_cgo_type(type)})(unsafe.Pointer(#{go_name}))"
+        return "(#{"*" * length}#{cast_to_cgo_type})(unsafe.Pointer(#{go_name}))"
       when :in_ref
-        return "(*#{cast_to_cgo_type(type)})(#{go_name})"
+        return "(*#{cast_to_cgo_type})(#{go_name})"
       end
 
-      "#{cast_to_cgo_type(type)}(#{go_name})"
+      "#{cast_to_cgo_type}(#{go_name})"
     end
 
     # @param char_var_count [Integer]
@@ -75,10 +75,10 @@ def generate_go_arguments(char_var_count:, chars_var_count:)
           [go_name, [], []]
 
         else
-          c_var_name = "c#{snake_to_camel(go_name)}"
+          c_var_name = "c#{GoUtil.snake_to_camel(go_name)}"
 
-          before_call_function_line = "var #{c_var_name} #{cast_to_cgo_type(type)}"
-          after_call_function_line = "*#{go_name} = #{ruby_c_type_to_go_type(type, pos: :arg)}(#{c_var_name})"
+          before_call_function_line = "var #{c_var_name} #{cast_to_cgo_type}"
+          after_call_function_line = "*#{go_name} = #{ruby_c_type_to_go_type(pos: :arg)}(#{c_var_name})"
 
           ["&#{c_var_name}", [before_call_function_line], [after_call_function_line]]
         end
@@ -105,7 +105,7 @@ def generate_go_arguments(char_var_count:, chars_var_count:)
     def generate_go_arguments_for_char_pointer(char_var_count)
       # self is string
       if char_var_count >= 2
-        chars_var_name = "char#{snake_to_camel(go_name)}"
+        chars_var_name = "char#{GoUtil.snake_to_camel(go_name)}"
         clean_var_name = "cleanChar#{go_name}"
       else
         chars_var_name = "char"
@@ -129,7 +129,7 @@ def generate_go_arguments_for_char_pointer(char_var_count)
     #   - after_call_function_lines [Array<String>]
     def generate_go_arguments_for_str_array(chars_var_count)
       if chars_var_count >= 2
-        chars_var_name = "chars#{snake_to_camel(go_name)}"
+        chars_var_name = "chars#{GoUtil.snake_to_camel(go_name)}"
         clean_var_name = "cleanChars#{go_name}"
       else
         chars_var_name = "chars"

_tools/ruby_h_to_go/lib/ruby_h_to_go/enum_definition.rb

@@ -7,8 +7,6 @@ class EnumDefinition
 
     def_delegators :@definition, :==, :name, :name=, :values, :values=
 
-    include GeneratorHelper
-
     # @param definition [RubyHeaderParser::EnumDefinition]
     def initialize(definition:)
       @definition = definition
@@ -19,7 +17,7 @@ def initialize(definition:)
     def write_go_file(dist_dir)
       go_file_path = File.join(dist_dir, "enum_generated.go")
 
-      generate_initial_go_file(go_file_path)
+      GoUtil.generate_initial_go_file(go_file_path)
 
       File.open(go_file_path, "a") do |f|
         f.write(generate_go_content)
@@ -28,7 +26,7 @@ def write_go_file(dist_dir)
 
     # @return [String]
     def generate_go_content
-      go_type_name = snake_to_camel(name)
+      go_type_name = GoUtil.snake_to_camel(name)
 
       go_enum_lines = [
         "// #{go_type_name} is a type for passing `C.#{name}` in and out of package",

_tools/ruby_h_to_go/lib/ruby_h_to_go/function_definition.rb

@@ -7,8 +7,6 @@ class FunctionDefinition
 
     def_delegators :@definition, :==, :name, :name=, :definition, :definition=
 
-    include GeneratorHelper
-
     # @param definition [RubyHeaderParser::FunctionDefinition]
     def initialize(definition:)
       @definition = definition
@@ -29,7 +27,7 @@ def args
     def write_go_file(dist_dir)
       go_file_path = File.join(dist_dir, "function_generated.go")
 
-      generate_initial_go_file(go_file_path)
+      GoUtil.generate_initial_go_file(go_file_path)
 
       File.open(go_file_path, "a") do |f|
         f.write(generate_go_content)
@@ -93,7 +91,7 @@ def generate_go_content
     def go_function_name
       return name if name.match?(/^[A-Z0-9_]+$/)
 
-      snake_to_camel(name)
+      GoUtil.snake_to_camel(name)
     end
   end
 end

_tools/ruby_h_to_go/lib/ruby_h_to_go/generator_helper.rb renamed to _tools/ruby_h_to_go/lib/ruby_h_to_go/go_util.rb

@@ -2,18 +2,18 @@
 
 module RubyHToGo
   # helper methods for generating go code
-  module GeneratorHelper
+  module GoUtil
     # @param str [String]
     # @return [String]
-    def snake_to_camel(str)
+    def self.snake_to_camel(str)
       return str if %w[VALUE ID].include?(str)
 
       str.split("_").map(&:capitalize).join.gsub(/(?<=\d)([a-z])/) { _1.upcase } # rubocop:disable Style/SymbolProc
     end
 
     # Generate initial go file whether not exists
     # @param go_file_path [String]
-    def generate_initial_go_file(go_file_path)
+    def self.generate_initial_go_file(go_file_path)
       return if File.exist?(go_file_path)
 
       File.binwrite(go_file_path, <<~GO)
@@ -53,7 +53,7 @@ def generate_initial_go_file(go_file_path)
     # @param pointer [Symbol,nil] pointer hint (:ref, :array, :ref_array, :function, :sref, :str_array, :in_ref, :raw)
     # @param pointer_length [Integer]
     # @return [String]
-    def ruby_c_type_to_go_type(typename, pos: nil, pointer: nil, pointer_length: 0)
+    def self.ruby_c_type_to_go_type(typename, pos: nil, pointer: nil, pointer_length: 0)
       return ruby_pointer_c_type_to_go_type(typename, pos:, pointer:, pointer_length:) if pointer
 
       return C_TYPE_TO_GO_TYPE[typename] if C_TYPE_TO_GO_TYPE[typename]
@@ -87,21 +87,19 @@ def ruby_c_type_to_go_type(typename, pos: nil, pointer: nil, pointer_length: 0)
     # Cast C type to cgo type. (Used in wrapper function)
     # @param typename [String]
     # @return [String]
-    def cast_to_cgo_type(typename)
+    def self.cast_to_cgo_type(typename)
       return C_TYPE_TO_CGO_TYPE[typename] if C_TYPE_TO_CGO_TYPE[typename]
 
       "C.#{typename}"
     end
 
-    private
-
     # Convert pointer C type to Go type. (used in wrapper function args and return type etc)
     # @param typename [String]
     # @param pos [Symbol,nil] :arg, :typeref, :return
     # @param pointer [Symbol,nil] pointer hint (:ref, :array, :ref_array, :function, :sref, :str_array, :in_ref, :raw)
     # @param pointer_length [Integer]
     # @return [String]
-    def ruby_pointer_c_type_to_go_type(typename, pos:, pointer:, pointer_length:)
+    def self.ruby_pointer_c_type_to_go_type(typename, pos:, pointer:, pointer_length:)
       go_type_name =
         if typename == "int" && %i[return typeref].include?(pos)
           "Int"
@@ -139,5 +137,7 @@ def ruby_pointer_c_type_to_go_type(typename, pos:, pointer:, pointer_length:)
 
       "*#{go_type_name}"
     end
+
+    private_class_method :ruby_pointer_c_type_to_go_type
   end
 end

_tools/ruby_h_to_go/lib/ruby_h_to_go/struct_definition.rb

@@ -7,8 +7,6 @@ class StructDefinition
 
     def_delegators :@definition, :==, :name, :name=
 
-    include GeneratorHelper
-
     # @param definition [RubyHeaderParser::StructDefinition]
     def initialize(definition:)
       @definition = definition
@@ -19,7 +17,7 @@ def initialize(definition:)
     def write_go_file(dist_dir)
       go_file_path = File.join(dist_dir, "struct_generated.go")
 
-      generate_initial_go_file(go_file_path)
+      GoUtil.generate_initial_go_file(go_file_path)
 
       File.open(go_file_path, "a") do |f|
         f.write(generate_go_content)
@@ -28,7 +26,7 @@ def write_go_file(dist_dir)
 
     # @return [String]
     def generate_go_content
-      go_type_name = snake_to_camel(name)
+      go_type_name = GoUtil.snake_to_camel(name)
 
       <<~GO
         // #{go_type_name} is a type for passing `C.#{name}` in and out of package

_tools/ruby_h_to_go/lib/ruby_h_to_go/type_definition.rb

@@ -7,8 +7,6 @@ class TypeDefinition
 
     def_delegators :@definition, :==, :name, :name=
 
-    include GeneratorHelper
-
     # @param definition [RubyHeaderParser::TypeDefinition]
     def initialize(definition:)
       @definition = definition
@@ -19,7 +17,7 @@ def initialize(definition:)
     def write_go_file(dist_dir)
       go_file_path = File.join(dist_dir, "type_generated.go")
 
-      generate_initial_go_file(go_file_path)
+      GoUtil.generate_initial_go_file(go_file_path)
 
       File.open(go_file_path, "a") do |f|
         f.write(generate_go_content)
@@ -28,7 +26,7 @@ def write_go_file(dist_dir)
 
     # @return [String]
     def generate_go_content
-      go_type_name = snake_to_camel(name)
+      go_type_name = GoUtil.snake_to_camel(name)
 
       <<~GO
         // #{go_type_name} is a type for passing `C.#{name}` in and out of package

_tools/ruby_h_to_go/lib/ruby_h_to_go/type_helper.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RubyHToGo
+  # type attribute helper
+  module TypeHelper
+    # @param pos [Symbol,nil] :arg, :typeref, :return
+    # @param pointer [Symbol,nil] pointer hint (:ref, :array, :ref_array, :function, :sref, :str_array, :in_ref, :raw)
+    # @param pointer_length [Integer]
+    # @return [String]
+    def ruby_c_type_to_go_type(pos: nil, pointer: nil, pointer_length: 0)
+      GoUtil.ruby_c_type_to_go_type(type, pos:, pointer:, pointer_length:)
+    end
+
+    # Cast C type to cgo type. (Used in wrapper function)
+    # @return [String]
+    def cast_to_cgo_type
+      GoUtil.cast_to_cgo_type(type)
+    end
+  end
+end

_tools/ruby_h_to_go/lib/ruby_h_to_go/typeref_definition.rb

@@ -7,7 +7,7 @@ class TyperefDefinition
 
     def_delegators :@definition, :==, :type, :type=, :pointer, :pointer=, :pointer?
 
-    include GeneratorHelper
+    include TypeHelper
 
     # @param definition [RubyHeaderParser::TyperefDefinition]
     def initialize(definition:)
@@ -18,14 +18,14 @@ def initialize(definition:)
     def go_function_typeref
       return "" if type == "void" && !pointer?
 
-      ruby_c_type_to_go_type(type, pos: :typeref, pointer:)
+      ruby_c_type_to_go_type(pos: :typeref, pointer:)
     end
 
     # @return [String]
     def cast_func_for_function_return
       return "" if type == "void" && !pointer?
 
-      cast_func = ruby_c_type_to_go_type(type, pos: :return, pointer:)
+      cast_func = ruby_c_type_to_go_type(pos: :return, pointer:)
       return "(#{cast_func})" if cast_func.start_with?("*")
 
       cast_func

_tools/ruby_h_to_go/lib/ruby_header_parser.rb

@@ -2,16 +2,15 @@
 
 require "yaml"
 
-require_relative "ruby_header_parser/argument_definition"
-require_relative "ruby_header_parser/data"
-require_relative "ruby_header_parser/enum_definition"
-require_relative "ruby_header_parser/function_definition"
-require_relative "ruby_header_parser/parser"
-require_relative "ruby_header_parser/struct_definition"
-require_relative "ruby_header_parser/type_definition"
-require_relative "ruby_header_parser/typeref_definition"
-require_relative "ruby_header_parser/util"
-
 # Parser for ruby.h
 module RubyHeaderParser
+  autoload :ArgumentDefinition, "ruby_header_parser/argument_definition"
+  autoload :Data,               "ruby_header_parser/data"
+  autoload :EnumDefinition,     "ruby_header_parser/enum_definition"
+  autoload :FunctionDefinition, "ruby_header_parser/function_definition"
+  autoload :Parser,             "ruby_header_parser/parser"
+  autoload :StructDefinition,   "ruby_header_parser/struct_definition"
+  autoload :TypeDefinition,     "ruby_header_parser/type_definition"
+  autoload :TyperefDefinition,  "ruby_header_parser/typeref_definition"
+  autoload :Util,               "ruby_header_parser/util"
 end