Merge pull request #172 from sue445/feature/remove_AbcSize

Remove Metrics/AbcSize in .rubocop_todo.yml

Author: sue445

.rubocop.yml

@@ -34,6 +34,9 @@ Lint/BinaryOperatorWithIdenticalOperands:
   Exclude:
     - "**/*_spec.rb" # for rspec-parameterized
 
+Metrics/AbcSize:
+  Max: 20
+
 Metrics/BlockLength:
   Exclude:
     - "*.gemspec"

.rubocop_todo.yml

@@ -6,11 +6,6 @@
 # Note that changes in the inspected code, or installation of new
 # versions of RuboCop, may require this file to be generated again.
 
-# Offense count: 8
-# Configuration parameters: AllowedMethods, AllowedPatterns, CountRepeatedAttributes.
-Metrics/AbcSize:
-  Max: 46
-
 # Offense count: 17
 # Configuration parameters: CountComments, CountAsOne, AllowedMethods, AllowedPatterns.
 Metrics/MethodLength:

_tools/ruby_h_to_go/lib/ruby_h_to_go/function_definition.rb

@@ -36,24 +36,46 @@ def write_go_file(dist_dir)
 
     # @return [String]
     def generate_go_content
-      go_function_args = args.map(&:go_function_arg)
+      go_function_lines = generate_function_header_lines
 
-      go_function_typeref = typeref.go_function_typeref
+      casted_go_args, before_call_function_lines, after_call_function_lines = analyze_args
 
-      go_function_lines = [
+      call_c_method = "C.#{name}(#{casted_go_args.join(", ")})"
+
+      append_function_body(call_c_method:, go_function_lines:, before_call_function_lines:, after_call_function_lines:)
+
+      go_function_lines.append("}", "", "")
+
+      go_function_lines.join("\n")
+    end
+
+    # @return [String]
+    def go_function_name
+      return name if name.match?(/^[A-Z0-9_]+$/)
+
+      GoUtil.snake_to_camel(name)
+    end
+
+    private
+
+    # @return [Array<String>]
+    def generate_function_header_lines
+      [
         "// #{go_function_name} calls `#{name}` in C",
         "//",
         "// Original definition is following",
         "//",
         "//\t#{definition}",
+        "func #{go_function_name}(#{args.map(&:go_function_arg).join(", ")}) #{typeref.go_function_typeref} {",
       ]
+    end
 
-      go_function_lines << "func #{go_function_name}(#{go_function_args.join(", ")}) #{go_function_typeref} {"
-
+    # @return [Array<Array<String>, Array<String>, Array<String>>]
+    #   - casted_go_args [Array<String>]
+    #   - before_call_function_lines [Array<String>]
+    #   - after_call_function_lines [Array<String>]
+    def analyze_args
       casted_go_args = []
-      char_var_count = args.count { |c_arg| c_arg.type == "char" && c_arg.pointer == :ref }
-      chars_var_count = args.count { |c_arg| c_arg.type == "char" && c_arg.pointer == :str_array }
-
       before_call_function_lines = []
       after_call_function_lines = []
 
@@ -65,9 +87,27 @@ def generate_go_content
         after_call_function_lines.push(*after_lines)
       end
 
-      call_c_method = "C.#{name}(#{casted_go_args.join(", ")})"
+      [casted_go_args, before_call_function_lines, after_call_function_lines]
+    end
 
+    # @return [Integer]
+    def char_var_count
+      args.count { |c_arg| c_arg.type == "char" && c_arg.pointer == :ref }
+    end
+
+    # @return [Integer]
+    def chars_var_count
+      args.count { |c_arg| c_arg.type == "char" && c_arg.pointer == :str_array }
+    end
+
+    # @param go_function_lines [Array<String>]
+    # @param call_c_method [String]
+    # @param before_call_function_lines [Array<String>]
+    # @param after_call_function_lines [Array<String>]
+    def append_function_body(go_function_lines:, call_c_method:, before_call_function_lines:,
+                             after_call_function_lines:)
       go_function_lines.push(*before_call_function_lines)
+
       cast_func = typeref.cast_func_for_function_return
       if cast_func == ""
         go_function_lines << call_c_method
@@ -79,19 +119,6 @@ def generate_go_content
         go_function_lines.push(*after_call_function_lines)
         go_function_lines << "return ret"
       end
-
-      go_function_lines << "}"
-      go_function_lines << ""
-      go_function_lines << ""
-
-      go_function_lines.join("\n")
-    end
-
-    # @return [String]
-    def go_function_name
-      return name if name.match?(/^[A-Z0-9_]+$/)
-
-      GoUtil.snake_to_camel(name)
     end
   end
 end

_tools/ruby_h_to_go/lib/ruby_header_parser/parser.rb

@@ -104,33 +104,42 @@ def extract_enum_definitions
     def __extract_function_definitions(c_kinds:, kind:, is_parse_multiline_definition:)
       stdout = execute_ctags("--c-kinds=#{c_kinds} --fields=+nS --extras=+q")
 
-      stdout.each_line.with_object([]) do |line, definitions|
-        parts = line.split("\t")
+      stdout.each_line.map do |line|
+        generate_function_definition_from_line(line:, kind:, is_parse_multiline_definition:)
+      end.compact.uniq(&:name)
+    end
 
-        function_name = parts[0]
-        filepath = parts[1]
+    # @param line [String]
+    # @param kind [String]
+    # @param is_parse_multiline_definition [Boolean]
+    #
+    # @param [Array<RubyHeaderParser::FunctionDefinition>, nil]
+    def generate_function_definition_from_line(line:, kind:, is_parse_multiline_definition:)
+      parts = line.split("\t")
 
-        next unless data.should_generate_function?(function_name)
+      function_name = parts[0]
+      filepath = parts[1]
 
-        next unless parts[3] == kind
+      return nil unless data.should_generate_function?(function_name)
 
-        line_num = Util.find_field(parts, "line").to_i
-        definition = parse_function_definition(filepath:, pattern: parts[2], line_num:, is_parse_multiline_definition:)
+      return nil unless parts[3] == kind
 
-        args = parse_definition_args(function_name, Util.find_field(parts, "signature"))
+      line_num = Util.find_field(parts, "line").to_i
+      definition = parse_function_definition(filepath:, pattern: parts[2], line_num:, is_parse_multiline_definition:)
 
-        # Exclude functions with variable-length arguments
-        next if args&.last&.type == "..."
+      args = parse_definition_args(function_name, Util.find_field(parts, "signature"))
 
-        typeref_field = Util.find_field(parts, "typeref:typename")
+      # Exclude functions with variable-length arguments
+      return nil if args&.last&.type == "..."
 
-        definitions << FunctionDefinition.new(
-          definition:,
-          name:       function_name,
-          typeref:    create_typeref(definition:, function_name:, typeref_field:, filepath:, line_num:),
-          args:,
-        )
-      end.uniq(&:name)
+      typeref_field = Util.find_field(parts, "typeref:typename")
+
+      FunctionDefinition.new(
+        definition:,
+        name:       function_name,
+        typeref:    create_typeref(definition:, function_name:, typeref_field:, filepath:, line_num:),
+        args:,
+      )
     end
 
     # @param args [String]
@@ -272,45 +281,75 @@ def generate_argument_definition(function_name:, arg:, arg_pos:)
         parts.delete_at(pointer_index)
       end
 
-      pointer = nil
-      length = 0
+      type, pointer, length = analyze_argument_type(function_name:, arg_pos:, parts:)
 
-      if parts[-1] =~ /\[([0-9]+)?\]$/
-        parts[-1].gsub!(/\[([0-9]+)?\]$/, "")
-        length = ::Regexp.last_match(1).to_i
-        pointer = :array
-      end
-
-      unless parts[-1] =~ /^[0-9a-zA-Z_]+$/
-        # last elements isn't dummy argument
-        parts << "arg#{arg_pos}"
-      end
+      ArgumentDefinition.new(
+        name:    parts[-1],
+        type:,
+        pointer:,
+        length:,
+      )
+    end
 
+    # @param function_name [String]
+    # @param arg_pos [Integer]
+    # @param parts [Array<String>]
+    #
+    # @return [Array<String, Symbol, Integer>]
+    #   - type [String]
+    #   - pointer [Symbol]
+    #   - length [Integer]
+    def analyze_argument_type(function_name:, arg_pos:, parts:)
+      pointer, length = prepare_argument_parts(arg_pos:, parts:)
       original_type = Util.sanitize_type(parts[0...-1].join(" "))
-      name = parts[-1]
 
-      if original_type.match?(/\*+$/)
+      case original_type
+      when /\*+$/
         type = original_type.gsub(/\*+$/, "").strip
         pointer = data.function_arg_pointer_hint(function_name:, pos: arg_pos)
-      elsif /^void\s*\s/.match?(original_type) || /\(.*\)/.match?(original_type)
+
+      when /^void\s*/, /\(.*\)/
         # function pointer (e.g. void *(*func)(void *)) is treated as `void*`
         type = "void"
         pointer = data.function_arg_pointer_hint(function_name:, pos: arg_pos)
+
       else
         type = original_type
       end
 
-      if pointer == :sref
-        original_type =~ /(\*+)$/
-        length = ::Regexp.last_match(1).length
+      length = pointer_length(original_type) if pointer == :sref
+
+      [type, pointer, length]
+    end
+
+    # @param arg_pos [Integer]
+    # @param parts [Array<String>]
+    #
+    # @return [Array<Symbol, Integer>]
+    #   - pointer [Symbol,nil]
+    #   - length [Integer]
+    def prepare_argument_parts(parts:, arg_pos:)
+      pointer = nil
+      length = 0
+
+      if parts[-1] =~ /\[([0-9]+)?\]$/
+        parts[-1].gsub!(/\[([0-9]+)?\]$/, "")
+        length = ::Regexp.last_match(1).to_i
+        pointer = :array
+      end
+
+      unless parts[-1] =~ /^[0-9a-zA-Z_]+$/
+        # last elements isn't dummy argument
+        parts << "arg#{arg_pos}"
       end
 
-      ArgumentDefinition.new(
-        type:,
-        name:,
-        pointer:,
-        length:,
-      )
+      [pointer, length]
+    end
+
+    # @param type [String]
+    def pointer_length(type)
+      type =~ /(\*+)$/
+      ::Regexp.last_match(1).length
     end
   end
 end