Merge pull request #4 from sue445/feature/import-from-go-gem-wrapper

Import from go-gem-wrapper

Author: sue445

.github/workflows/test.yml

@@ -38,7 +38,8 @@ jobs:
       - run: sudo apt-get update
       - run: sudo apt-get install -y universal-ctags
 
-      - run: bundle exec rspec
+      - run: bundle exec rake spec
+      - run: bundle exec rake rubocop
 
       - name: Slack Notification (not success)
         uses: act10ns/slack@v2

.rspec

@@ -1,3 +1,3 @@
---format documentation
+--format progress
 --color
 --require spec_helper

.rubocop.yml

@@ -0,0 +1,64 @@
+AllCops:
+  TargetRubyVersion: 3.3
+  NewCops: enable
+  SuggestExtensions: false
+
+Gemspec/DevelopmentDependencies:
+  EnforcedStyle: gemspec
+
+Layout/DotPosition:
+  EnforcedStyle: trailing
+
+Layout/HashAlignment:
+  EnforcedColonStyle: table
+  EnforcedHashRocketStyle: table
+
+Layout/SpaceAroundOperators:
+  Exclude:
+    # Suppress line breaks in spec files (e.g `it { should xxxx }`, `its(:method) { should xxxx }` )
+    - "**/*_spec.rb"
+
+Lint/BinaryOperatorWithIdenticalOperands:
+  Exclude:
+    - "**/*_spec.rb" # for rspec-parameterized
+
+Metrics/AbcSize:
+  Max: 20
+
+Metrics/BlockLength:
+  Exclude:
+    - "*.gemspec"
+    - "**/*_spec.rb"
+
+Metrics/CyclomaticComplexity:
+  Max: 13
+
+Metrics/MethodLength:
+  Max: 28
+
+Metrics/PerceivedComplexity:
+  Max: 11
+
+Style/FetchEnvVar:
+  Enabled: false
+
+Style/NumericPredicate:
+  EnforcedStyle: comparison
+
+Style/SingleLineMethods:
+  Enabled: false
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes
+
+Style/TrailingCommaInArguments:
+  EnforcedStyleForMultiline: comma
+
+Style/TrailingCommaInArrayLiteral:
+  EnforcedStyleForMultiline: comma
+
+Style/TrailingCommaInHashLiteral:
+  EnforcedStyleForMultiline: comma

Gemfile

@@ -4,7 +4,3 @@ source "https://rubygems.org"
 
 # Specify your gem's dependencies in ruby_header_parser.gemspec
 gemspec
-
-gem "rake", "~> 13.0"
-
-gem "rspec", "~> 3.0"

Rakefile

@@ -5,4 +5,11 @@ require "rspec/core/rake_task"
 
 RSpec::Core::RakeTask.new(:spec)
 
-task default: :spec
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+desc "Run all development tasks"
+task dev_all: %i[spec rubocop]
+
+task default: :dev_all

lib/ruby_header_parser.rb

@@ -1,8 +1,20 @@
 # frozen_string_literal: true
 
+require "yaml"
+
 require_relative "ruby_header_parser/version"
 
+# Parser for ruby.h
 module RubyHeaderParser
   class Error < StandardError; end
-  # Your code goes here...
+
+  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

lib/ruby_header_parser/argument_definition.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RubyHeaderParser
+  # argument definition for {RubyHeaderParser::FunctionDefinition}
+  class ArgumentDefinition
+    # @!attribute type
+    #   @return [String]
+    attr_accessor :type
+
+    # @!attribute name
+    #   @return [String]
+    attr_accessor :name
+
+    # @!attribute pointer
+    #   @return [Symbol,nil] :ref, :array
+    attr_accessor :pointer
+
+    # @!attribute length
+    #   @return [Integer]
+    attr_accessor :length
+
+    # @param type [String]
+    # @param name [String]
+    # @param pointer [Symbol,nil] :ref, :array
+    # @param length [String]
+    def initialize(type:, name:, pointer: nil, length: 0)
+      @type = type
+      @name = name
+      @pointer = pointer
+      @length = length
+    end
+
+    # @param other [ArgumentDefinition]
+    # @return [Boolean]
+    def ==(other)
+      other.is_a?(ArgumentDefinition) && type == other.type && name == other.name && pointer == other.pointer &&
+        length == other.length
+    end
+
+    # @return [Boolean]
+    def pointer?
+      !!pointer
+    end
+  end
+end

lib/ruby_header_parser/data.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module RubyHeaderParser
+  # Manager for `data.yml`
+  class Data
+    # @!attribute [r] data
+    #   @return [Hash]
+    attr_reader :data
+
+    def initialize
+      yaml = File.read(File.join(__dir__, "data.yml"))
+      @data = YAML.safe_load(yaml, aliases: true, permitted_classes: [Regexp])
+    end
+
+    # @param function_name [String]
+    # @param pos [Integer] arg position (1 origin)
+    # @return [Symbol] :ref, :array, :ref_array, :function, :sref, :str_array, :in_ref
+    def function_arg_pointer_hint(function_name:, pos:)
+      pointer_hint = data["function"]["pointer_hint"].dig(function_name, pos)
+      return pointer_hint.to_sym if pointer_hint
+
+      :ref
+    end
+
+    # @param function_name [String]
+    # @return [Symbol] :ref, :raw
+    def function_self_pointer_hint(function_name)
+      pointer_hint = data["function"]["pointer_hint"].dig(function_name, "self")
+      return pointer_hint.to_sym if pointer_hint
+
+      :ref
+    end
+
+    # rubocop:disable Style/CaseEquality
+
+    # Whether generate C function to go
+    # @param function_name [String]
+    # @return [Boolean]
+    def should_generate_function?(function_name)
+      return false if data["function"]["exclude_name"].any? { |format| format === function_name }
+
+      data["function"]["include_name"].any? { |format| format === function_name }
+    end
+
+    # Whether generate C struct to go
+    # @param struct_name [String]
+    # @return [Boolean]
+    def should_generate_struct?(struct_name)
+      return false if data["struct"]["exclude_name"].any? { |format| format === struct_name }
+
+      data["struct"]["include_name"].any? { |format| format === struct_name }
+    end
+
+    # Whether generate C type to go
+    # @param type_name [String]
+    # @return [Boolean]
+    def should_generate_type?(type_name)
+      return false if data["type"]["exclude_name"].any? { |format| format === type_name }
+
+      data["type"]["include_name"].any? { |format| format === type_name }
+    end
+
+    # Whether generate C enum to go
+    # @param enum_name [String]
+    # @return [Boolean]
+    def should_generate_enum?(enum_name)
+      return false if data["enum"]["exclude_name"].any? { |format| format === enum_name }
+
+      data["enum"]["include_name"].any? { |format| format === enum_name }
+    end
+
+    # rubocop:enable Style/CaseEquality
+  end
+end